<p>Given an unsorted array of integers <code>nums</code>, return <em>the length of the longest consecutive elements sequence.</em></p>

<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [100,4,200,1,3,2]
<strong>Output:</strong> 4
<strong>Explanation:</strong> The longest consecutive elements sequence is <code>[1, 2, 3, 4]</code>. Therefore its length is 4.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,3,7,2,5,8,4,6,0,1]
<strong>Output:</strong> 9
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>0 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
</ul>

class Solution {
public:
    int longestConsecutive(vector<int>& N) {
        const int S = N.size();

        if (!S)
            return 0;

        if (S == 1)
            return 1;

        vector<pair<int, int>> Buckets;

        priority_queue<int, deque<int>, greater<int>> Q;
        


        for (int i = 0; i < S; ++i)
        {
            Q.push(N[i]);
        }

        int prev = numeric_limits<int>::min(), t = numeric_limits<int>::max();
        int r = 1, cur_max = numeric_limits<int>::min(), cur_min = numeric_limits<int>::min();

        while (!Q.empty())
        {
            prev = t;
            t = Q.top();
            Q.pop();
            if (prev == t)
                continue;
            
            if (t == cur_max+1)
            {
                cur_max = t;
                r = max(r, cur_max-cur_min+1);

            }
            else
            {
                cur_min = t;
                cur_max = t;
            }

            /*bool found = false;

            if (t)

            for (auto& b : Buckets)
            {
                if (t == b.first-1)
                {
                    b.first = t;
                    r = max(r, b.second-b.first+1);
                    found = true;
                    break;
                }
                else if (t == b.second+1)
                {
                    b.second = t;
                    r = max(r, b.second-b.first+1);
                    found = true;
                    break;
                }

            }*/

            //if (!found)
            //    Buckets.push_back({t, t});
        }

        return r;


        // [100,8,200,1,7,2,9]   --> [100,200][1,2][7,8,9]
        // [1,2,7,8,9,100,200]

        // [0,3,7,2,5] --> [0] [2,3] [5] [7]
        // [0,3,7,2,5,8] 
    }
};
42151