数组 Longest Consecutive Sequence

最新推荐文章于 2022-03-06 23:29:26 发布

qwurey

最新推荐文章于 2022-03-06 23:29:26 发布

阅读量456

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/yeruby/article/details/44937795

版权

leetcode 专栏收录该内容

234 篇文章 1 订阅

订阅专栏

思想：

序列无序且要求O(n)，哈希最有可能。

线性的找一个可以向两边扩张最大的元素，返回扩张的长度。

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        unordered_map<int, bool> used;
        
        for(auto i: num)
            used[i] = false;
        
        int longest = 0;
        
        for(auto i: num) {
            if(used[i])
                continue;
            int length = 1;
            used[i] = true;
            for(int j = i + 1; used.find(j) != used.end(); j++) {
                used[j] = true;
                length++;
            }
            for(int j = i - 1; used.find(j) != used.end(); j--) {
                used[j] = true;
                length++;
            }
            longest = max(longest, length);
        }
        return longest;
    }
};

std::unordered_map

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

Unordered Map

Unordered maps are associative containers that store elements formed by the combination of a key value and a mapped value, and which allows for fast retrieval of individual elements based on their keys.

In an unordered_map, the key value is generally used to uniquely identify the element, while the mapped value is an object with the content associated to this key. Types of key and mapped value may differ.

Internally, the elements in the unordered_map are not sorted in any particular order with respect to either their key or mapped values, but organized into buckets depending on their hash values to allow for fast access to individual elements directly by their key values (with a constant average time complexity on average).

unordered_map containers are faster than map containers to access individual elements by their key, although they are generally less efficient for range iteration through a subset of their elements.

Unordered maps implement the direct access operator ( operator[]) which allows for direct access of the mapped valueusing its key value as argument.

Iterators in the container are at least forward iterators.