LeetCode - Longest Consecutive Sequence

Longest Consecutive Sequence

2014.1.13 19:00

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.

Solution:

　　I've seen this problem at the interview of NetEase before. Back then I discussed about an O(n * log(n)) algorithm wit my friends.

　　The solution uses a map to record the occurrence of each number. For a number N in the sequence, we scan the map to see if N - 1, N -2, .... and N + 1, N + 2, ... are in the sequence. From that we know the length of the longest consecutive sequence contain N.

　　To avoid repeated searches in the map, we'll use another map to mark each element as "already scanned" when they're found in the map.

　　For instance, the sequence [3, 1, 2] will produce result 3. It doesn't you start searching from 1, 2 or 3, because you always get [1, 2, 3] at last.

　　Like the following:

　　　　1: [] 1 [2, 3]

　　　　2: [1] 2 [3]

　　　　3: [1, 2] 3

　　Thus we can mark all consecutive elements as "already scanned" to avoid searching them again in the map. That saves some time indeed.

　　Although stl map is quite elegant and optimized, it is still O(log(n)) for every search action. So I chose unordered_map from C++11, which has an ammortized O(1) time complexity for insert and search action.

　　It is the difference between a hash-table and a red-black tree that decides their difference in time complexity level.

　　Time and space complexity are both O(n).

Accepted code:

// 1AC, excellent!!!
#include <unordered_map>
using namespace std;

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int res, max_res;
        unordered_map<int, int> a, b;
        
        a.clear();
        b.clear();
        
        int n = num.size();
        if(n <= 0){
            return 0;
        }
        
        int i, j;
        for(i = 0; i < n; ++i){
            a[num[i]] = 1;
        }
        
        max_res = 0;
        for(i = 0; i < n; ++i){
            res = 0;
            if(b.find(num[i]) != b.end()){
                continue;
            }
            b[num[i]] = 1;
            ++res;
            j = num[i] - 1;
            while(a.find(j) != a.end() && b.find(j) == b.end()){
                b[j] = 1;
                ++res;
                --j;
            }
            j = num[i] + 1;
            while(a.find(j) != a.end() && b.find(j) == b.end()){
                b[j] = 1;
                ++res;
                ++j;
            }
            
            if(res > max_res){
                max_res = res;
            }
        }
        
        a.clear();
        b.clear();
        
        return max_res;
    }
};