[leetcode笔记] 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.

 

解题笔记：

（1）第一次Submit

先排个序，再循环遍历一遍，土办法搞起。

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        //cc_print_int_vector(num);
        sort(num.begin(), num.end());
        //cc_print_int_vector(num);

        int longest = 0;

        int i = 0, j = 0;
        bool breakFlag = false;
        for(i = 0; i<num.size() - 1; i++)
        {
            for(j = i +1; j<num.size(); j++)
            {
                if(num[j-1]+1 != num[j])
                {
                    int distance = j - i;
                    if( distance > longest)
                    {
                        longest = distance;
                    }
                    breakFlag = true;
                    break;
                }
            }
            if (breakFlag)
            {
                i = j+1;
                breakFlag = false;
                continue;
            }
        }

        return longest;
    }
};

 

Submission Result: Time Limit Exceeded！

杯具。

系统打印出一串非常长的有些变态的测试用例，哎，土办法混不过去啊！

 

（2）第二次Submit

怎么破？题目中有提示，要求必须O(n)复杂度，上面程序中上来就搞了个sort，STL sort的复杂度为O(nlogn)，岂不是一下子就超了？不过空间复杂度没有提要求。

俺的第二反应又是土办法搞起，空间换时间。

 

@#……%#@&……！@%#！&

（冥思苦想了好几天都没有结果）

！@&……@！*……

后来检索了一下，终于找到方法了。[冷汗]

此题要求O(n)复杂度，决定了是不能做排序的，排序至少O(nlogn)复杂度，建map红黑树也不行，构造红黑树其实就相当于做了一遍排序。

只能用哈希表。标准C++中hash表现在名字叫做unordered_set或者unordered_map。

整理清楚思路后，代码一次提交通过。

 

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        unordered_map<int, bool> map_num;
        int longest = 0;
        int i = 0;

        for (i = 0; i < static_cast<int>(num.size()); ++i)
        {
            map_num[num[i]] = true;
        }

        for (i = 0; i < static_cast<int>(num.size()); ++i)
        {
            //search num[i]
            int search_value = num[i];
            unordered_map<int, bool>::iterator it = map_num.find(search_value);
            if (it == map_num.end())
            {
                continue;
            }

            int cur_length = 1;

            search_value = num[i] - 1;
            bool bFound = true;
            while ( bFound )
            {
                unordered_map<int, bool>::iterator it = map_num.find(search_value);
                bFound = (it != map_num.end());
                if (bFound)
                {
                    search_value -= 1;
                    cur_length += 1;
                    map_num.erase(it);
                }
                else
                {
                    break;
                }
            }

            search_value = num[i] + 1;
            bFound = true;
            while ( bFound )
            {
                unordered_map<int, bool>::iterator it = map_num.find(search_value);
                bFound = (it!=map_num.end());
                if (bFound)
                {
                    search_value += 1;
                    cur_length += 1;
                    map_num.erase(it);
                }
                else
                {
                    break;
                }
            }

            if(cur_length>longest)
            {
                longest = cur_length;
            }

        }

        return longest;
    }
};