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 W consecutive 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

題目理解：

給定一個數組nums，和整數W，問是否能將nums分為若干子陣列，且每組含有W個數字，並且這W個數字是連續的

解題思路：

首先我們可以想到，中間的數字可能會有比較複雜的分組可能，但是陣列中最小的數一定是某一個子陣列的第一個數字，而且陣列中一定要含有從這個數字往後的W-1個數字，所以我們首先將陣列進行排序，然後從小到大遍歷，這樣我們每次就可以知道一每一個數字應該放在什麼地方。

我們用記號[num, count]表示num這個數字是我接下在需要的，而且，這個子陣列中還需要count個數字，當我們遇到num後，這個記號變為[num+1, count - 1]，直到count變為0。在遍歷陣列的時候，我們會有一系列的記號[num, count]，如果我當前遍歷的數字是我需要的某一個num，則將記號做前述修改，否則，加入新的記號[num, W - 1]。

在具體實現上，可以使用map，key是我需要的數字num，value是與num相關的所有count的集合

class Solution {
    public boolean isNStraightHand(int[] hand, int W) {
        if(W == 1)
    		return true;
    	if(hand.length % W != 0)
    		return false;
    	Map<Integer, Queue<Integer>> map = new HashMap<Integer, Queue<Integer>>();
    	Arrays.sort(hand);
    	for(int num : hand) {    		
    		if(!map.containsKey(num))
    			map.put(num, new LinkedList<Integer>());
    		Queue<Integer> cur = map.get(num);
    		if(cur.size() == 0) {
    			if(!map.containsKey(num + 1))
        			map.put(num + 1, new LinkedList<Integer>());
    			map.get(num + 1).offer(W - 1);
    		}
    		else {
    			int ct = cur.poll();
    			ct--;
    			if(ct > 0) {
    				if(!map.containsKey(num + 1))
            			map.put(num + 1, new LinkedList<Integer>());
    				map.get(num + 1).offer(ct);
    			}
    		}

    	}
    	for(int key : map.keySet()) {
    		//System.out.println(key + " : " + map.get(key).toString());
    		if(map.get(key).size() > 0)
    			return false;
    	}
    	return true;
    }
}