LeetCode: Longest Consecutive Sequence 解题报告

Longest Consecutive Sequence

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: 4.

Your algorithm should run in O(n) complexity.

SOLUTION1:

用HashMap来空间换时间.

1. 在map中创建一些集合来表示连续的空间。比如，如果有[3，4，5]这样的一个集合，我们表示为key:3， value:5和key:5， value3两个集合，并且把这2个放在hashmap中。这样我们可以在O(1)的时间查询某个数字开头和结尾的集合。

2. 来了一个新的数字时，比如：N=6，我们可以搜索以N-1结尾 以N+1开头的集合有没有存在。从1中可以看到，key:5是存在的，这样我们可以删除3，5和5，3这两个key-value对，同样我们要查以7起头的集合有没有存在，同样可以删除以7起始的集合。删除后我们可以更新left,right的值，也就是合并和扩大集合。

3. 合并以上这些集合，创建一个以新的left,right作为开头，结尾的集合，分别以left, right作为key存储在map中。并且更新max (表示最长连续集合）

public class Solution {
    public int longestConsecutive(int[] num) {
        if (num == null) {
            return 0;
        }
        
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        
        int max = 0;
        
        int len = num.length;
        for (int i = 0; i < len ; i++) {
            // 寻找以num[i] 起头或是结尾的，如果找到，则可以跳过，因为我们
            // 不需要重复的数字
            if (map.get(num[i]) != null) {
                continue;
            }
            
            int left = num[i];
            int right = num[i];
            
            // 寻找左边界
            Integer board = map.get(num[i] - 1);
            if (board != null && board < left) {
                // 更新左边界
                left = board;
                
                // 删除左边2个集合
                map.remove(left);
                map.remove(num[i] - 1);
            }
            
            // 寻找右边界
            board = map.get(num[i] + 1);
            if (board != null && board > right) {
                // 更新右边界
                right = board;
                
                // 删除右边2个集合
                map.remove(right);
                map.remove(num[i] + 1);
            }
            
            // 创建新的合并之后的集合
            map.put(left, right);
            map.put(right, left);
            
            max = Math.max(max, right - left + 1);
        }
        
        return max;
    }
}

SOLUTION2:

引自大神的解法：http://blog.csdn.net/fightforyourdream/article/details/15024861

我们可以把所有的数字放在hashset中，来一个数字后，取出HashSet中的某一元素x，找x-1,x-2....x+1,x+2...是否也在set里。

// solution 2: use hashset.
    public int longestConsecutive(int[] num) {
        if (num == null) {
            return 0;
        }
        
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i: num) {
            set.add(i);
        }
        
        int max = 0;
        for (int i: num) {
            int cnt = 1;
            set.remove(i);
            
            int tmp = i - 1;
            while (set.contains(tmp)) {
                set.remove(tmp);
                cnt++;
                tmp--;
            }
            
            tmp = i + 1;
            while (set.contains(tmp)) {
                set.remove(tmp);
                cnt++;
                tmp++;
            }
            
            max = Math.max(max, cnt);
        }
        
        return max;
    }

 2015.1.2 redo:

public class Solution {
    public int longestConsecutive(int[] num) {
        if (num == null) {
            return 0;
        }
        
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i: num) {
            set.add(i);
        }
        
        int max = 0;
        
        for (int i: num) {
            set.remove(i);
            int sum = 1;
            
            int tmp = i - 1;
            while (set.contains(tmp)) {
                // bug 1：forget to add the remove statement.
                set.remove(tmp);
                sum++;
                tmp--;
            }
            
            tmp = i + 1;
            while (set.contains(tmp)) {
                set.remove(tmp);
                sum++;
                tmp++;
            }
            
            max = Math.max(max, sum);
        }
        
        return max;
    }
}

GITHUB:

LongestConsecutive.java