【leetcode】Longest Consecutive Sequence（hard)☆

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.

 

思路：先把大神的方法亮出来

use a hash map to store boundary information of consecutive sequence for each element; there 4 cases when a new element i reached:

1) neither i+1 nor i-1 has been seen: m[i]=1;

2) both i+1 and i-1 have been seen: extend m[i+m[i+1]] and m[i-m[i-1]] to each other;

3) only i+1 has been seen: extend m[i+m[i+1]] and m[i] to each other;

4) only i-1 has been seen: extend m[i-m[i-1]] and m[i] to each other.

int longestConsecutive(vector<int> &num) {

    unordered_map<int, int> m;

    int r = 0;

    for (int i : num) {

        if (m[i]) continue; //跳过重复

        r = max(r, m[i] = m[i + m[i + 1]] = m[i - m[i - 1]] = m[i + 1] + m[i - 1] + 1); //如果新的数字把左右连起来了，则把该连起来的序列的第一个数m[i - m[i - 1]]和最后一个数字m[i + m[i + 1]] 设为新的长度！

    }

    return r;

}

 

下面是我自己写的，可谓血与泪的历史。

首先O(n)表示一定不能排序, 那如何获得左右邻接的信息呢。 肯定要用hash了。结果花了2个小时，写了一个超复杂的代码。虽然AC，但是.......唉...................................................

int longestConsecutive(vector<int> &num) {

        //去重复

        unordered_set<int> s;

        for(int i = 0; i < num.size(); i++)

        {

            if(s.find(num[i]) == s.end())

                s.insert(num[i]);

            else

                num.erase(num.begin() + (i--));

        }

        

        int maxlen = 0;

        unordered_map<int, int> first; //记录每个连续序列的第一个数字在record中的哪个位置

        unordered_map<int, int> last; //记录每个连续序列的最后一个数字在record中的哪个位置

        vector<vector<int>> record; //记录每个连续序列的第一个数字和最后一个数字是什么

        for(int i = 0; i < num.size(); i++)

        {

            int pre, post;

            unordered_map<int, int>::iterator f = first.find(num[i] + 1);

            unordered_map<int, int>::iterator l = last.find(num[i] - 1);

            if(f != first.end() && l != last.end())

            {

                pre = l->second;

                post = f->second;

                //修改hash表

                last.erase(record[pre][1]);

                first.erase(record[post][0]);

                last[record[post][1]] = pre;

                //修改记录的区间

                record[pre][1] = record[post][1];

                maxlen = (maxlen > record[pre][1] - record[pre][0] + 1) ? maxlen :  record[pre][1] - record[pre][0] + 1;

                record[post].clear();

            }

            else if(f != first.end())

            {

                post = f->second;

                //修改hash

                first.erase(record[post][0]);

                first[num[i]] = post;

                //修改区间

                record[post][0] = num[i];

                maxlen = (maxlen > record[post][1] - record[post][0] + 1) ? maxlen :  record[post][1] - record[post][0] + 1;

            }

            else if(l != last.end())

            {

                pre = l->second;

                last.erase(record[pre][0]);

                last[num[i]] = pre;



                record[pre][1] = num[i];

                maxlen = (maxlen > record[pre][1] - record[pre][0] + 1) ? maxlen :  record[pre][1] - record[pre][0] + 1;

            }

            else

            {

                record.push_back(vector<int>(2, num[i]));

                first[num[i]] = record.size() - 1;

                last[num[i]] = record.size() - 1;

                maxlen = (maxlen > 1) ? maxlen : 1;

            }

        }

        return maxlen;

    }