Redian新闻
>
G2是今年的神机!
avatar
G2是今年的神机!# PDA - 掌中宝
P*t
1
譬如这道LEETCODE上的题:
Longest Consecutive SequenceFeb 14
Given an unsorted array of integers, find the length of the longest
consecutive elements sequence.
For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length
Your algorithm should run in O(n) complexity.
我是想了半天也想不出O(N)的解法怎么搞。网上一搜,发现原来是用HASHMAP做 Range
Merge. 尼玛,HASHMAP insert来insert去 的效率能有多高?这个表面上O(n)的解法
实际效率其实比简单的SORT差,更不要说CODE的复杂度了。实际解决问题的时候没有人
会这样去写的。
avatar
I*4
2
版上把G2贬低的太厉害
我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
过两天我来写个note3 vs g2
g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了
avatar
p*2
3
用个hashset吧?我觉得O(n)比nlogn要快呀。
avatar
f*0
4
LZ 你24小时电池还能剩92%,你花钱买新手机干嘛用?

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
P*t
5
Hashset? 怎么搞?Logn 基本看做常数了,大小不同而已。

【在 p*****2 的大作中提到】
: 用个hashset吧?我觉得O(n)比nlogn要快呀。
avatar
k*l
6
关机然后show off 电池 LOL

【在 f*****0 的大作中提到】
: LZ 你24小时电池还能剩92%,你花钱买新手机干嘛用?
avatar
J*e
8
我在用g2,这玩意屏幕和电池真心牛b。尤其是电池,我这样的heavy user一天半冲一次
电,qq微信全开,没事看会儿漫画和视频,在公司都不用接电源。不过lg的系统不是很
好,改进空间还很大。

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
P*t
9
正好写了个Program比较了一下,再加上你的HASHSET:
Sort used time (ms): 1182
HashMap Used time (ms): 2959
HashSet Used time (ms): 3583
import java.io.Console;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
public class LongestConsecSequence {
public int longestConsecutive(int[] a) {
return v1(a);
}
public int v1(int[] in) {
int[] a = new int[in.length];
System.arraycopy(in, 0, a, 0, in.length);
if (a.length == 0)
return 0;
Arrays.sort(a);
int ret = 1;
int start = 0;
int dup = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] == a[i - 1] + 1) {
ret = Math.max(ret, i - start - dup + 1);
} else if (a[i] == a[i - 1]) {
dup += 1;
} else {
start = i;
dup = 0;
}
}
return ret;
}
public int v2(int[] a) {
HashMap map = new HashMap();
int max = 1;
for (int i : a) {
if (map.containsKey(i))
continue;
map.put(i, 1);
if (map.containsKey(i - 1)) {
max = Math.max(max, merge(map, i - 1, i));
}
if (map.containsKey(i + 1)) {
max = Math.max(max, merge(map, i, i + 1));
}
}
return max;
}
private int merge(HashMap map, int left, int right) {
int upper = right + map.get(right) - 1;
int lower = left - map.get(left) + 1;
int len = upper - lower + 1;
map.put(upper, len);
map.put(lower, len);
return len;
}
public int v3(int[] num) {
Set hs = new HashSet();
for (int v : num)
hs.add(v);
int ans = 0;
for (int v : num)
if (hs.contains(v))
ans = Math.max(ans, getCount(hs, v, false) + getCount(hs, v + 1,
true));
return ans;
}
int getCount(Set hs, int v, boolean asc) {
int count = 0;
while (hs.contains(v)) {
hs.remove(v);
count++;
if (asc)
v++;
else
v--;
}
return count;
}
public static void Run() {
LongestConsecSequence sol = new LongestConsecSequence();
int MAX_RANDOM = 327670;
int[][] ar = new int[100][100000];
for (int i = 0; i < ar.length; i++) {
for (int j = 0; j < ar[i].length; j++) {
ar[i][j] = (int) (Math.random() * MAX_RANDOM);
}
}
long milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
sol.v1(ar[i]);
}
long used = System.currentTimeMillis() - milli;
System.out.println("Sort used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
sol.v2(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashMap Used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
sol.v3(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashSet Used time (ms): " + used);
}
}

【在 p*****2 的大作中提到】
:
: http://blog.sina.com.cn/s/blog_b9285de20101iqar.html

avatar
u*d
10
G2有多大电池 ?看来电池大就是省心阿;等1520到T家,一定搞一个玩。

【在 J******e 的大作中提到】
: 我在用g2,这玩意屏幕和电池真心牛b。尤其是电池,我这样的heavy user一天半冲一次
: 电,qq微信全开,没事看会儿漫画和视频,在公司都不用接电源。不过lg的系统不是很
: 好,改进空间还很大。

avatar
p*2
11

你用Leetcode的OJ试试

【在 P***t 的大作中提到】
: 正好写了个Program比较了一下,再加上你的HASHSET:
: Sort used time (ms): 1182
: HashMap Used time (ms): 2959
: HashSet Used time (ms): 3583
: import java.io.Console;
: import java.util.Arrays;
: import java.util.HashMap;
: import java.util.HashSet;
: import java.util.Set;
: public class LongestConsecSequence {

avatar
s*z
12
过一段你就知道好不好了
通常电池半天就完了,然后有空手机就自己reboot玩

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
P*t
13
三个都通过。

【在 p*****2 的大作中提到】
:
: 你用Leetcode的OJ试试

avatar
r*y
14
注意 后几天 微软似乎1520 att 合约免费

【在 u****d 的大作中提到】
: G2有多大电池 ?看来电池大就是省心阿;等1520到T家,一定搞一个玩。
avatar
s*x
15
Set hs=new HashSet();
这个initialize 设定size为num.length应该更优化?

【在 p*****2 的大作中提到】
:
: 你用Leetcode的OJ试试

avatar
r*y
16
我才是重度玩家..
one 9点到3点就没电了...
G2能到晚上9点多还有点

【在 J******e 的大作中提到】
: 我在用g2,这玩意屏幕和电池真心牛b。尤其是电池,我这样的heavy user一天半冲一次
: 电,qq微信全开,没事看会儿漫画和视频,在公司都不用接电源。不过lg的系统不是很
: 好,改进空间还很大。

avatar
P*t
17
好一点:
Sort used time (ms): 1145
HashMap Used time (ms): 2973
HashSet Used time (ms): 3030

【在 s********x 的大作中提到】
: Set hs=new HashSet();
: 这个initialize 设定size为num.length应该更优化?

avatar
e*e
18
电池同意,目前能把电池很快用完的就是PVZ2。
不过proximity sensor好像有问题。我的会有开机自己黑屏的毛病。

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
q*x
19
大牛来了。

length
Range

【在 P***t 的大作中提到】
: 譬如这道LEETCODE上的题:
: Longest Consecutive SequenceFeb 14
: Given an unsorted array of integers, find the length of the longest
: consecutive elements sequence.
: For example,
: Given [100, 4, 200, 1, 3, 2],
: The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length
: Your algorithm should run in O(n) complexity.
: 我是想了半天也想不出O(N)的解法怎么搞。网上一搜,发现原来是用HASHMAP做 Range
: Merge. 尼玛,HASHMAP insert来insert去 的效率能有多高?这个表面上O(n)的解法

avatar
ra
20
神不神的,每个人都有不同看法。评价电池都是mid-to-heavy use才有意义。你用G2
24小时剩92%,这种用法现在人和主流手机都能剩一半多。手机如果用12小时能剩30
%,电池小幅提升就不是主要考虑因素了。

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
s*x
21
可不可以不要sequential run
第三个正好hit garbage collection 不fair啊

【在 P***t 的大作中提到】
: 正好写了个Program比较了一下,再加上你的HASHSET:
: Sort used time (ms): 1182
: HashMap Used time (ms): 2959
: HashSet Used time (ms): 3583
: import java.io.Console;
: import java.util.Arrays;
: import java.util.HashMap;
: import java.util.HashSet;
: import java.util.Set;
: public class LongestConsecSequence {

avatar
m*s
22
不是似乎。
是每家店的前20名。

【在 r******y 的大作中提到】
: 注意 后几天 微软似乎1520 att 合约免费
avatar
s*x
23
你干脆把v2和v3都intialiaze using 2*num.length 试试好了 :)

【在 P***t 的大作中提到】
: 好一点:
: Sort used time (ms): 1145
: HashMap Used time (ms): 2973
: HashSet Used time (ms): 3030

avatar
L*t
24
G2 sales below expectation, the news is everywhere:
http://gadgets.ndtv.com/mobiles/news/lg-g2-sales-below-expectat

【在 I*****4 的大作中提到】
: 版上把G2贬低的太厉害
: 我note3和G2都买了,G2除了屏幕小一点点,没有笔。其他不比note3差,某些方面更好
: 过两天我来写个note3 vs g2
: g2是刚刚到手,电池太神了,24小时后电池还有92%,比note3牛多了

avatar
s*x
25
你这样是不fair的
v1 creates a lot of objects
v2 and v3 might hit garbage collection when running.
So you should run each of them standalone

【在 s********x 的大作中提到】
: 可不可以不要sequential run
: 第三个正好hit garbage collection 不fair啊

avatar
P*y
26
G2 battery sometimes drains pretty fast even in idle, but it can still
easily last a day even in such a situation. This could be an google/android
issue, rather than G2-specific. The battery is 3000mAh.

【在 L******t 的大作中提到】
: G2 sales below expectation, the news is everywhere:
: http://gadgets.ndtv.com/mobiles/news/lg-g2-sales-below-expectat

avatar
P*t
27
It doesn't matter. Trust me. I tried.

【在 s********x 的大作中提到】
: 你这样是不fair的
: v1 creates a lot of objects
: v2 and v3 might hit garbage collection when running.
: So you should run each of them standalone

avatar
s*x
29
这个有意思
v1理论上是 (nlog(n) + n)* T1 这个constant T1 不需要hash的operation,肯定要
小些
v1完全可以优化更多。
首先把array inplace quick sort, 这样就是ordered
然后search的时候完全不用linear time
贴一下哈(不知道v2和v3可否用这种思路)
// find longest increasing continuous sequence, better than O(n). a is
sorted already
public static int findLongestIncreasingContinuousSequence(int[] a) {
if (a == null || a.length == 0)
return 0;
int max = 1;
int end = 0;
// len = j - i + 1
int i = 0, k = 0;
while (i < a.length - max) {
int j = i + max; // a[i] to a[j], length of max+1
// k is where scanner stops, scanner scans from j to k since a[k
] to
// a[j] is increasing
if (j < a.length && a[j] - a[i] >= max) { // potential
increasing array
int scanner = j;
while ((scanner - 1) >= 0 && a[scanner] > a[scanner - 1]) //
** boundary check!
scanner--;
if (scanner == k) {
// found new max
while (((j + 1) < a.length) && a[j + 1] > a[j]) // **
boundary check!
j++;
max = j - i + 1;
end = j;
i = j + 1;
k = i;
} else { // a[scanner] to a[j] is increasing
i = scanner;
k = j;
}
} else {
i = j + 1;
k = i;
}
}
System.out.println("max is " + max + "; end is " + end);
return max;
}

【在 P***t 的大作中提到】
: 正好写了个Program比较了一下,再加上你的HASHSET:
: Sort used time (ms): 1182
: HashMap Used time (ms): 2959
: HashSet Used time (ms): 3583
: import java.io.Console;
: import java.util.Arrays;
: import java.util.HashMap;
: import java.util.HashSet;
: import java.util.Set;
: public class LongestConsecSequence {

avatar
o*6
30
这才是真正的神机,价钱便宜量又足。

【在 r******y 的大作中提到】
: 注意 后几天 微软似乎1520 att 合约免费
avatar
p*2
31
这是我的测试结果
Sort used time (ms): 4573
HashMap Used time (ms): 1683
HashSet Used time (ms): 2327
avatar
m*r
32
In other words, it sucks big time.

【在 J******e 的大作中提到】
: 广告没砸够啊。
avatar
P*t
33
神了。Did you change MAX_RANDOM and the array length?

【在 p*****2 的大作中提到】
: 这是我的测试结果
: Sort used time (ms): 4573
: HashMap Used time (ms): 1683
: HashSet Used time (ms): 2327

avatar
A*Z
34
系统哪里不好?zkss

【在 J******e 的大作中提到】
: 我在用g2,这玩意屏幕和电池真心牛b。尤其是电池,我这样的heavy user一天半冲一次
: 电,qq微信全开,没事看会儿漫画和视频,在公司都不用接电源。不过lg的系统不是很
: 好,改进空间还很大。

avatar
s*x
35
HashSet Used time (ms): 1994
HashMap Used time (ms): 1577
Sort used time (ms): 1084
我测了

【在 P***t 的大作中提到】
: 神了。Did you change MAX_RANDOM and the array length?
avatar
o*6
36
还好,比较像nexus,不像三星那样大改动

【在 A****Z 的大作中提到】
: 系统哪里不好?zkss
avatar
p*2
37

你一个用int,其他两个用Integer。int本来就快。

【在 P***t 的大作中提到】
: 神了。Did you change MAX_RANDOM and the array length?
avatar
s*x
38
autoboxing 本身就是performance考虑的因素啊。
lz完全说得对,v2和v3在memory space不占优势,running time又是不行。
v1不需要additional memory。
我看是v1胜了

【在 p*****2 的大作中提到】
:
: 你一个用int,其他两个用Integer。int本来就快。

avatar
p*2
39

你没考虑worst case。

【在 s********x 的大作中提到】
: autoboxing 本身就是performance考虑的因素啊。
: lz完全说得对,v2和v3在memory space不占优势,running time又是不行。
: v1不需要additional memory。
: 我看是v1胜了

avatar
P*t
40
差不多。只有在MAX_RANDOM < ARRAY LENGTH,出现很多重复数的话,Hash会消除重复
,所以有可能更快。

【在 s********x 的大作中提到】
: HashSet Used time (ms): 1994
: HashMap Used time (ms): 1577
: Sort used time (ms): 1084
: 我测了

avatar
s*x
41
v1的bottle neck是quick sort inplace, worst case 也是nlog(n)
跟average case是一样的

【在 p*****2 的大作中提到】
:
: 你没考虑worst case。

avatar
p*2
42

你把int改成Integer试试。

【在 P***t 的大作中提到】
: 差不多。只有在MAX_RANDOM < ARRAY LENGTH,出现很多重复数的话,Hash会消除重复
: ,所以有可能更快。

avatar
p*2
43

worst case 也是nlog(n)
are you really sure?

【在 s********x 的大作中提到】
: v1的bottle neck是quick sort inplace, worst case 也是nlog(n)
: 跟average case是一样的

avatar
s*x
44
你可以create temporary array which kicks out duplicates, 然后quick sort吧

【在 P***t 的大作中提到】
: 差不多。只有在MAX_RANDOM < ARRAY LENGTH,出现很多重复数的话,Hash会消除重复
: ,所以有可能更快。

avatar
s*x
45
median of three 我记得是可以avoid 一边倒的把

【在 p*****2 的大作中提到】
:
: worst case 也是nlog(n)
: are you really sure?

avatar
p*2
46

这个不知道。但是Java比赛经常quicksort 碰到worst case fail掉。至少Java的
implementation是N^2的worst

【在 s********x 的大作中提到】
: median of three 我记得是可以avoid 一边倒的把
avatar
P*t
47
Good point. If I had to do this in V1:
Integer[] a = new Integer[in.length];
for (int i = 0; i < in.length; i++) {
a[i] = in[i];
}
Then including the copying time, performance is similar:
Sort used time (ms): 2818
HashMap Used time (ms): 2929
HashSet Used time (ms): 3134
But then again, if input is int[], why would I even bother converting it to
Integer[]? :)

【在 p*****2 的大作中提到】
:
: 这个不知道。但是Java比赛经常quicksort 碰到worst case fail掉。至少Java的
: implementation是N^2的worst

avatar
s*x
48
N^2是因为pivot的选错,median of three已经solve这个问题了,我无法想象如何还能
到N^2 in any case using median of three

【在 p*****2 的大作中提到】
:
: 这个不知道。但是Java比赛经常quicksort 碰到worst case fail掉。至少Java的
: implementation是N^2的worst

avatar
p*2
49

to
因为我们应该是做算法的比较。要公平的比较才对。

【在 P***t 的大作中提到】
: Good point. If I had to do this in V1:
: Integer[] a = new Integer[in.length];
: for (int i = 0; i < in.length; i++) {
: a[i] = in[i];
: }
: Then including the copying time, performance is similar:
: Sort used time (ms): 2818
: HashMap Used time (ms): 2929
: HashSet Used time (ms): 3134
: But then again, if input is int[], why would I even bother converting it to

avatar
p*2
50
我觉得下边的代码更公平一些。
Sort used time (ms): 4657
HashMap Used time (ms): 1696
HashSet Used time (ms): 2433
public class test {
public int v1(Integer[] in) {
Integer[] a = new Integer[in.length];
System.arraycopy(in, 0, a, 0, in.length);
if (a.length == 0)
return 0;
Arrays.sort(a);
int ret = 1;
int start = 0;
int dup = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] == a[i - 1] + 1) {
ret = Math.max(ret, i - start - dup + 1);
} else if (a[i] == a[i - 1]) {
dup += 1;
} else {
start = i;
dup = 0;
}
}
return ret;
}
public int v2(Integer[] a) {
HashMap map = new HashMap();
int max = 1;
for (int i : a) {
if (map.containsKey(i))
continue;
map.put(i, 1);
if (map.containsKey(i - 1)) {
max = Math.max(max, merge(map, i - 1, i));
}
if (map.containsKey(i + 1)) {
max = Math.max(max, merge(map, i, i + 1));
}
}
return max;
}
private int merge(HashMap map, int left, int right) {
int upper = right + map.get(right) - 1;
int lower = left - map.get(left) + 1;
int len = upper - lower + 1;
map.put(upper, len);
map.put(lower, len);
return len;
}
public int v3(Integer[] num) {
Set hs = new HashSet(Arrays.asList(num));
int ans = 0;
for (int v : num)
if (hs.contains(v))
ans = Math.max(ans, getCount(hs, v, false) + getCount(hs, v + 1,
true));
return ans;
}
int getCount(Set hs, int v, boolean asc) {
int count = 0;
while (hs.contains(v)) {
hs.remove(v);
count++;
if (asc)
v++;
else
v--;
}
return count;
}
public void run() {
Integer MAX_RANDOM = 327670;
Integer[][] ar = new Integer[1][10000000];
Random rand=new Random();
for (int i = 0; i < ar.length; i++) {
for (int j = 0; j < ar[i].length; j++) {
ar[i][j] = rand.nextInt()%MAX_RANDOM;
}
}
long milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v1(ar[i]);
}
long used = System.currentTimeMillis() - milli;
System.out.println("Sort used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v2(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashMap Used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v3(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashSet Used time (ms): " + used);
}

public static void main(String[] args) throws Exception
{
new test().run();
}
}
avatar
s*x
51
另外说一下quicksort本身能handle duplicate, 用three way partition就可以了。
另外可以用temporary array 去踢掉duplicate。
我还是觉得lz是对的,v1不管怎么看都更好。

【在 p*****2 的大作中提到】
: 我觉得下边的代码更公平一些。
: Sort used time (ms): 4657
: HashMap Used time (ms): 1696
: HashSet Used time (ms): 2433
: public class test {
: public int v1(Integer[] in) {
: Integer[] a = new Integer[in.length];
: System.arraycopy(in, 0, a, 0, in.length);
: if (a.length == 0)
: return 0;

avatar
p*2
52

关键不是O(n)呀。面试就是面试,不是工作,不是做OJ。面试就要按照面试的要求去做
。这题一点也不过分。更过分的题目多了去了

【在 s********x 的大作中提到】
: 另外说一下quicksort本身能handle duplicate, 用three way partition就可以了。
: 另外可以用temporary array 去踢掉duplicate。
: 我还是觉得lz是对的,v1不管怎么看都更好。

avatar
s*x
53
可能java自带的quicksort不够强?
怎么说也该考虑median of three, 已经three way partition来handle duplicate吧
如果你指的是Array.Sort,可能都不是implemented in quicksort。 因为quicksort不
是stable的。
http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html
(For example, the algorithm used by sort(Object[]) does not have to be a
mergesort, but it does have to be stable.)

【在 p*****2 的大作中提到】
:
: 关键不是O(n)呀。面试就是面试,不是工作,不是做OJ。面试就要按照面试的要求去做
: 。这题一点也不过分。更过分的题目多了去了

avatar
s*x
54
但这个感觉是面试官纸上谈兵,自己搞错了。
莫名其妙的优化,其实make it worse
感觉这个面试题就是面试官自己没想明白而已

【在 p*****2 的大作中提到】
:
: 关键不是O(n)呀。面试就是面试,不是工作,不是做OJ。面试就要按照面试的要求去做
: 。这题一点也不过分。更过分的题目多了去了

avatar
p*2
55

The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and
M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and
Experience, Vol. 23(11) P. 1249-1265 (November 1993).

【在 s********x 的大作中提到】
: 可能java自带的quicksort不够强?
: 怎么说也该考虑median of three, 已经three way partition来handle duplicate吧
: 如果你指的是Array.Sort,可能都不是implemented in quicksort。 因为quicksort不
: 是stable的。
: http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html
: (For example, the algorithm used by sort(Object[]) does not have to be a
: mergesort, but it does have to be stable.)

avatar
p*2
56

这个难说。面试本来复杂度就是做理论上的分析。人家要求O(n)你就得按照O(n)想吧?

【在 s********x 的大作中提到】
: 但这个感觉是面试官纸上谈兵,自己搞错了。
: 莫名其妙的优化,其实make it worse
: 感觉这个面试题就是面试官自己没想明白而已

avatar
s*x
57
其实想想用merge sort不是更简单,然后merge的时候直接把duplicate 给去掉呵呵

【在 p*****2 的大作中提到】
:
: 这个难说。面试本来复杂度就是做理论上的分析。人家要求O(n)你就得按照O(n)想吧?

avatar
p*2
58

也不是O(n)吧?

【在 s********x 的大作中提到】
: 其实想想用merge sort不是更简单,然后merge的时候直接把duplicate 给去掉呵呵
avatar
p*2
59
我又试了一下,就算直接操作输入数组不copy,也没见solution1快呀
Sort used time (ms): 4580
HashMap Used time (ms): 851
HashSet Used time (ms): 1598
avatar
s*x
60
哦,当然不是。
偶最开始没看到要handle duplicate,后来才意识到。现在再想想既然这样要sort还不
如merge sort,呵呵。
这题确实说明要考虑constant time, 那个hashtable和autoboxing都是make constant
time worse的。所以overrall 谁更快还不一定,let alone space。

【在 p*****2 的大作中提到】
: 我又试了一下,就算直接操作输入数组不copy,也没见solution1快呀
: Sort used time (ms): 4580
: HashMap Used time (ms): 851
: HashSet Used time (ms): 1598

avatar
s*x
61
你的电脑也太神了吧,连你的算法都无偿支持啊 :)
我觉得别人测大部分都是v1快的,呵呵

【在 p*****2 的大作中提到】
: 我又试了一下,就算直接操作输入数组不copy,也没见solution1快呀
: Sort used time (ms): 4580
: HashMap Used time (ms): 851
: HashSet Used time (ms): 1598

avatar
p*2
62

constant
如果输入本身就是Integer呢?
很多语言并没有int Integer之分其实。
我们现在比较算法就应该用同样的data type。不然你一个用primitive一个用class那
算咋回事呢?

【在 s********x 的大作中提到】
: 哦,当然不是。
: 偶最开始没看到要handle duplicate,后来才意识到。现在再想想既然这样要sort还不
: 如merge sort,呵呵。
: 这题确实说明要考虑constant time, 那个hashtable和autoboxing都是make constant
: time worse的。所以overrall 谁更快还不一定,let alone space。

avatar
p*2
63

代码都给你。你跑一个看看。
import java.io.Console;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class test {
public int v1(Integer[] in) {
Integer[] a = in;
//System.arraycopy(in, 0, a, 0, in.length);
if (a.length == 0)
return 0;
Arrays.sort(a);
int ret = 1;
int start = 0;
int dup = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] == a[i - 1] + 1) {
ret = Math.max(ret, i - start - dup + 1);
} else if (a[i] == a[i - 1]) {
dup += 1;
} else {
start = i;
dup = 0;
}
}
return ret;
}
public int v2(Integer[] a) {
HashMap map = new HashMap();
int max = 1;
for (int i : a) {
if (map.containsKey(i))
continue;
map.put(i, 1);
if (map.containsKey(i - 1)) {
max = Math.max(max, merge(map, i - 1, i));
}
if (map.containsKey(i + 1)) {
max = Math.max(max, merge(map, i, i + 1));
}
}
return max;
}
private int merge(HashMap map, int left, int right) {
int upper = right + map.get(right) - 1;
int lower = left - map.get(left) + 1;
int len = upper - lower + 1;
map.put(upper, len);
map.put(lower, len);
return len;
}
public int v3(Integer[] num) {
Set hs = new HashSet(Arrays.asList(num));
int ans = 0;
for (int v : num)
if (hs.contains(v))
ans = Math.max(ans, getCount(hs, v, false) + getCount(hs, v + 1,
true));
return ans;
}
int getCount(Set hs, int v, boolean asc) {
int count = 0;
while (hs.contains(v)) {
hs.remove(v);
count++;
if (asc)
v++;
else
v--;
}
return count;
}
public void run() {
Integer MAX_RANDOM = 327670;
Integer[][] ar = new Integer[1][10000000];
Random rand=new Random();
for (int i = 0; i < ar.length; i++) {
for (int j = 0; j < ar[i].length; j++) {
ar[i][j] = rand.nextInt()%MAX_RANDOM;
}
}
long milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v1(ar[i]);
}
long used = System.currentTimeMillis() - milli;
System.out.println("Sort used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v2(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashMap Used time (ms): " + used);
milli = System.currentTimeMillis();
for (int i = 0; i < ar.length; i++) {
v3(ar[i]);
}
used = System.currentTimeMillis() - milli;
System.out.println("HashSet Used time (ms): " + used);
}

public static void main(String[] args) throws Exception
{
new test().run();
}
}

【在 s********x 的大作中提到】
: 你的电脑也太神了吧,连你的算法都无偿支持啊 :)
: 我觉得别人测大部分都是v1快的,呵呵

avatar
s*x
64
我找到proof啦 - quick sort worst case is nlog(n)
Data Structures
& Algorithms
in Java
Second Edition
Robert Lafore
page 725
TABLE 15.3 Comparison of Sorting Algorithms
Sort Average Worst Comparison Extra Memory
Bubble O(N2) O(N2) Poor No
Selection O(N2) O(N2) Fair No
Insertion O(N2) O(N2) Good No
Shellsort O(N3/2) O(N3/2) — No
Quicksort O(N*logN) O(N2) Good No
Mergesort O(N*logN) O(N*logN) Fair Yes
Heapsort O(N*logN) O(N*logN) Fair No
avatar
p*2
65

prove什么了?

【在 s********x 的大作中提到】
: 我找到proof啦 - quick sort worst case is nlog(n)
: Data Structures
: & Algorithms
: in Java
: Second Edition
: Robert Lafore
: page 725
: TABLE 15.3 Comparison of Sorting Algorithms
: Sort Average Worst Comparison Extra Memory
: Bubble O(N2) O(N2) Poor No

avatar
s*x
66
quick sort worst case is nlog(n)

【在 p*****2 的大作中提到】
:
: prove什么了?

avatar
p*2
67

Quicksort O(N*logN) O(N2) Good No

【在 s********x 的大作中提到】
: quick sort worst case is nlog(n)
avatar
s*x
68
还真是俺看错了哎,啊呀

【在 p*****2 的大作中提到】
:
: Quicksort O(N*logN) O(N2) Good No

avatar
s*x
69
Sort used time (ms): 5182
HashMap Used time (ms): 900
HashSet Used time (ms): 7137

【在 p*****2 的大作中提到】
:
: Quicksort O(N*logN) O(N2) Good No

avatar
p*2
70

你现在是不是在F太爽了?

【在 s********x 的大作中提到】
: 还真是俺看错了哎,啊呀
avatar
p*2
71

这个估计真是hit GC了。

【在 s********x 的大作中提到】
: Sort used time (ms): 5182
: HashMap Used time (ms): 900
: HashSet Used time (ms): 7137

avatar
s*x
72
不在F, 去年试了,店面碰到阿三,俺心就凉了,呵呵
不过俺也没打算真的要去,只是怕老板不给promotion就想给点颜色,不过老板给了

【在 p*****2 的大作中提到】
:
: 这个估计真是hit GC了。

avatar
p*2
73

太牛了。你在哪里组呢?刚进去就被promote了?

【在 s********x 的大作中提到】
: 不在F, 去年试了,店面碰到阿三,俺心就凉了,呵呵
: 不过俺也没打算真的要去,只是怕老板不给promotion就想给点颜色,不过老板给了

avatar
s*x
74
这个俺再爆料都可以被人肉出来了吧,呵呵,俺要睡了,二爷good night

【在 p*****2 的大作中提到】
:
: 太牛了。你在哪里组呢?刚进去就被promote了?

avatar
P*t
75
Your code:
Integer MAX_RANDOM = 327670;
Integer[][] ar = new Integer[1][10000000];
Random rand=new Random();
for (int i = 0; i < ar.length; i++) {
for (int j = 0; j < ar[i].length; j++) {
ar[i][j] = rand.nextInt()%MAX_RANDOM;
}
}
A long array 10000000 with member only ranging from 0 - 327669. That means
there are on average 30 duplicates per number. 当然是HASH完胜。

【在 p*****2 的大作中提到】
:
: 太牛了。你在哪里组呢?刚进去就被promote了?

avatar
M*u
76
Java的hashset效率的确不高

length
Range

【在 P***t 的大作中提到】
: 譬如这道LEETCODE上的题:
: Longest Consecutive SequenceFeb 14
: Given an unsorted array of integers, find the length of the longest
: consecutive elements sequence.
: For example,
: Given [100, 4, 200, 1, 3, 2],
: The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length
: Your algorithm should run in O(n) complexity.
: 我是想了半天也想不出O(N)的解法怎么搞。网上一搜,发现原来是用HASHMAP做 Range
: Merge. 尼玛,HASHMAP insert来insert去 的效率能有多高?这个表面上O(n)的解法

avatar
p*2
77

这个确实是,试了一下这个。HashMap最快。
Integer MAX_RANDOM = 32767000;
Sort used time (ms): 4666
HashMap Used time (ms): 3648
HashSet Used time (ms): 7194

【在 P***t 的大作中提到】
: Your code:
: Integer MAX_RANDOM = 327670;
: Integer[][] ar = new Integer[1][10000000];
: Random rand=new Random();
: for (int i = 0; i < ar.length; i++) {
: for (int j = 0; j < ar[i].length; j++) {
: ar[i][j] = rand.nextInt()%MAX_RANDOM;
: }
: }
: A long array 10000000 with member only ranging from 0 - 327669. That means

avatar
p*2
78
Integer MAX_RANDOM = 3276700;
Integer[][] ar = new Integer[1][1000000];
Sort used time (ms): 498
HashMap Used time (ms): 709
HashSet Used time (ms): 214
这个又是hashset快。
avatar
a*3
79
不知道楼主在哪里跑出来的结果竟然需要1+秒,leetcode上我两种方法都是70ms左右,
hash略快(C++)。不过看上面大数据测试集,也就10000,logn约为13,很小。所以说
,这个测试跟测试数据也有很大关系。如果测试数据更大一些,你自己可以算,hash的
常数和logn的大小到底哪个大。
avatar
s*x
80
真的是那么多duplicate的话干脆用bitvector 做bitset好了。
用sort的话也应该先去掉duplicate再sort,performance未必比hashset差

【在 a*******3 的大作中提到】
: 不知道楼主在哪里跑出来的结果竟然需要1+秒,leetcode上我两种方法都是70ms左右,
: hash略快(C++)。不过看上面大数据测试集,也就10000,logn约为13,很小。所以说
: ,这个测试跟测试数据也有很大关系。如果测试数据更大一些,你自己可以算,hash的
: 常数和logn的大小到底哪个大。

avatar
i*t
81
why not use counting sort in O(N)?

length
Range

【在 P***t 的大作中提到】
: 譬如这道LEETCODE上的题:
: Longest Consecutive SequenceFeb 14
: Given an unsorted array of integers, find the length of the longest
: consecutive elements sequence.
: For example,
: Given [100, 4, 200, 1, 3, 2],
: The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length
: Your algorithm should run in O(n) complexity.
: 我是想了半天也想不出O(N)的解法怎么搞。网上一搜,发现原来是用HASHMAP做 Range
: Merge. 尼玛,HASHMAP insert来insert去 的效率能有多高?这个表面上O(n)的解法

avatar
l*8
82
如何“先去掉duplicate再sort”?

【在 s********x 的大作中提到】
: 真的是那么多duplicate的话干脆用bitvector 做bitset好了。
: 用sort的话也应该先去掉duplicate再sort,performance未必比hashset差

avatar
s*x
83
就是counting sort with bitvector
大不了先生成hashset,然后convert成array

【在 l*********8 的大作中提到】
: 如何“先去掉duplicate再sort”?
相关阅读
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章,不代表同意其说法或描述,仅为提供更多信息,也不构成任何建议。文章信息的合法性及真实性由其作者负责,与Redian.news及其运营公司无关。欢迎投稿,如发现稿件侵权,或作者不愿在本网发表文章,请版权拥有者通知本网处理。