Alice has a hand of cards, given as an array of integers.

Now she wants to rearrange the cards into groups so that each group is size W, and consists of Wconsecutive cards.

Return true if and only if she can.

Example 1:

Input: hand = [1,2,3,6,2,3,4,7,8], W = 3
Output: true
Explanation: Alice's hand
 
 can be rearranged as [1,2,3],[2,3,4],[6,7,8].

Example 2:

Input: hand = [1,2,3,4,5], W = 4
Output: false
Explanation: Alice's hand can't be rearranged into groups of 4.

Note:

1. 1 <= hand.length <= 10000
2. 0 <= hand[i] <= 10^9
3. 1 <= W <= hand.length

Runtime: 80 ms, faster than 24.90% of C++ online submissions for Hand of Straights.

我的思路很直接，用map儲存。

class Solution {
public:
  bool isNStraightHand(vector<int>& hand, int W) {
        int n = hand.size();
        if (n < 1 || W < 1 || n < W)
        {
            return false;
        }
       
        if (n % W != 0)
        {
            return false;
        }
    map
 
<int,int> mp;
    for(auto x : hand) mp[x]++;
    for(auto it : mp){
      if(it.second == 0) continue;
      int cntit = it.second;
      for(int i=1; i<W;i++){
        if(!mp.count(it.first) || mp[it.first+i] < mp[it.first]) return false;
        mp[it.first+i] -= mp[it.first];
      }
      mp[it.first] = 0;
    }
    for(auto it : mp){
      if(it.second != 0) return false;
    }
    return true;
  }
};

網上看到一個比較好的思路是，把所有的數%W，因為是連續的，所以一個連續的W個數modW後必定在0 ~ W-1 中是連續存在的，妙。

class Solution {
public:
    bool isNStraightHand(vector<int>& hand, int W) {
        int n = hand.size();
        if (n < 1 || W < 1 || n < W)
        {
            return false;
        }
       
        if (n % W != 0)
        {
            return false;
        }
        
        vector<int> count (W, 0);
        for (const int& h : hand)
        {
            ++count[h % W];
        }
        
        int expect = count.front();
        for(const int& c : count)
        {
            if (c != expect)
            {
                return false;
            }
        }
        
        return true;
    }
};