Split Array into Consecutive Subsequences

659. Split Array into Consecutive Subsequences

You are given an integer array sorted in ascending order (may contain duplicates), you need to split them into several subsequences, where each subsequences consist of at least 3 consecutive integers. Return whether you can make such a split.

Example 1:

Input: [1,2,3,3,4,5]
Output: True
Explanation:
You can split them into two consecutive subsequences : 
1, 2, 3
3, 4, 5

Example 2:

Input: [1,2,3,3,4,4,5,5]
Output: True
Explanation:
You can split them into two consecutive subsequences : 
1, 2, 3, 4, 5
3, 4, 5

Example 3:

Input: [1,2,3,4,4,5]
Output: False

Note:

1. The length of the input is in range of [1, 10000]

 

参考：https://discuss.leetcode.com/topic/99187/java-o-n-time-o-n-space
思路：O(N)
1. 一个数要么加到一个已经形成的序列里，要么以它为首新开辟一个3个元素序列
所有元素都可以添加到这两种序列中，那么返回true

2. 是先往已有的序列后追加， 还是先自己为首成立一个新序列？

应该是先加入已有序列中的：

如给定：前面有1 2 3 4，后面跟上5 5 6 6 7 7
是先有新序列1 2 3
再将4加入已有序列 1 2 3的后面变成 1 2 3 4
再将5加入已有序列 1 2 3 4 的后面变成 1 2 3 4 5
再有新序列5 6 7
再将6加入已有序列 1 2 3 4 5 的后面变成 1 2 3 4 5 6
再将7加入已有序列 1 2 3 4 5 6 的后面变成 1 2 3 4 5 6 7

不能是
先有新序列 1 2 3
新序列 4 5 6
新序列 5 6 7
最后一个7没地儿放

bool isPossible(vector<int>& nums)
{
    unordered_map< int, int > freq; //每个key的出现次数
    unordered_map< int , int > afreq;//表示有val个 key，可以和之前已有的连续序列（多个）接上
    for ( auto &e : nums )
        freq[e]++;
    for ( auto &e : nums )
    {
        // the number has been used
        if (freq[e] == 0)    continue;

        // the number follow after other sequence
        // 表示 key，可以和 之前已有的连续序列（可能有多个） 接上
        // 这里是优先把key放到 一个已有的连续序列 后，为什么？
        //
        else if ( afreq.find(e) != afreq.end() && afreq[e] > 0 )
        {
            //将e连接到 一个已有的连续序列 之后
            freq[e]--;
            afreq[e]--;

            //下一个可以放到 上面这个已有的连续序列 后的数为 e+1（如果有）
            afreq[e + 1]++;
        }

        // the number form a new sequence
        // 这个序列只要 >= 3 即可，那就只判断3个元素的序列
        else if ( freq.find(e + 1) != freq.end() && freq[e + 1] > 0
            && freq.find(e + 2) != freq.end() && freq[e + 2]>0)
        {
            // e, e+1, e+2，组成一个新的序列
            freq[e]--;
            freq[e + 1]--;
            freq[e + 2]--;
            // e+3（如果有）可以连接到上面这个新的序列之后
            afreq[e + 3]++;
        }

        // can't deal with this number
        //既不能放到之前已有的连续序列之后，又不能组成一个新的队列
        else    return false;

    }
    return true;
}