LeetCode-Longest Consecutive Sequence

哎，这题又不会做，想了好久，还是想不出来，最长连续的数的长度，首先想到的肯定是排序，O(nlogn)，不过题目要求是O(n)，

于是又想到用hash的思想，类似数组记数的方式，不过即便不考虑存的空间的话，因为给定的数的大小并不在一定的范围之内，

所以最后的时间复杂度会是O(max - min)，max是最大的数，min是最小的数，还是不满足题目的要求。

其实思考一下题目，所谓连续的数，只需要记录一段连续的数的最小的数和最大的数即可，当时也想到了这个，不过下意识的想法是用数组来存每个数所在的连续段，

这样每个数还是都要往回查找是否可以扩展前面某个连续段，感觉复杂度是O(n²)了，所以放弃了这个想法。

做不出来，无奈只好看别人的方法了，参考了peking2的解法(http://blog.sina.com.cn/s/blog_b9285de20101iqar.html)，很巧妙的利用了set，

不过感觉也不能完全算是O(n)的呀，因为set的插入、删除操作并不是O(1)，而是O(logn)，实际复杂度应该是O(log(n!))呀，实际具体和O(n)的差距是多少，还很难评估！

class Solution {
public:
    set<int> store;
    int consecute(int n, bool direct) {
        int count = 0;
        while (store.count(n)) {
            ++count;
            store.erase(n);
            if (direct) 
                n--;
            else 
                n++;
        }
        return count;
    }
    int longestConsecutive(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int res = 0;
        if (num.size() == 0) {
            return res;
        }
        store.clear();
        for (int i = 0; i < num.size(); i++) {
            store.insert(num[i]);
        }
        for (int i = 0; i < num.size(); i++) {
            if (store.count(num[i])) {
                res = max(res, (consecute(num[i], true) + consecute(num[i] + 1, false)));
            }
        }
        return res;
    }
};

 其实用记录每个数所在的连续段的范围（最小值，最大值）也是可以的，可以利用map<int, pair<int, int> >来每个数的对应范围。

然后遇到可以扩展区间的数时更新区间范围即可。同样也参考了peking2的代码(http://blog.sina.com.cn/s/blog_b9285de20101i09x.html)，

不过他的代码有个bug，遇到重复的数应该忽略。

class Solution {
public:
    map<int, pair<int, int> > section;
    int longestConsecutive(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        section.clear();
        int start = 0;
        int end = 0;
        for (int i = 0; i < num.size(); i++) {
            int k = num[i];
            map<int, pair<int, int> >::iterator it = section.find(k);
            if (it != section.end()) {
                continue;
            }
            else {
                section.insert(make_pair(k, pair<int, int>(k, k)));
            }
            it = section.find(k - 1);
            if (it != section.end()) {
                section[k].first = (it->second).first;
            }
            it = section.find(k + 1);
            if (it != section.end()) {
                section[k].second = (it->second).second;
            }
            it = section.find(section[k].first);
            if (it != section.end()) {
                (it->second).second = section[k].second;
            }
            it = section.find(section[k].second);
            if (it != section.end()) {
                (it->second).first = section[k].first;
            }
            if (section[k].second - section[k].first > end - start) {
                start = section[k].first;
                end = section[k].second;
            }
         }
         return (end - start + 1);
    }
};