tasks数组里面的数字表示难度的等级，每一轮只能完成2 或者 3个同等级的task,
问至少需要多少轮能完成所有的task, 不能完成的返回-1.

思路：

先来看下什么情况下不能完成。
由于一轮只能完成2 或 3个，那如果该等级的task只有一个呢？那就是无法完成了。

另外还需考虑一点，如果已知某个等级task的个数，如何判断最少能完成它的轮数。
一轮只能完成2或3个。

需要知道的是，除了1，剩下所有的整数都能用2，3拼出来。
或者反过来想，除了1以外，2，3自己也不用说，从4开始往后的整数，除以3以后要么余1，要么余2对吧，
余1的情况，从前面除的数字中借一个3，例如4，除3余1，1借前面一个3以后是4，4是2的倍数。
余2的情况，2能被2整除。
所以4以后的整数一定能被2和3拼出来。

同样的，一个整数m, 如果它能被3整除，需要的轮数是m/3，这能理解，
如果有余1或余2的情况，
余2： 2/2 = 1，所以需要的轮数是m / 3 + 1，
余1：前面借一个3，（3+1）/2 = 2， 所以轮数是 m/3 - 1 + 2 = m/3 + 1,
所以这两种情况是一样的，

那么就推出来，整数m, m==1时，不能完成，
m % 3 == 0时，需要m/3轮，m % 3 != 0时，需要m / 3 + 1轮。

这个整数m 就是每个数字出现的次数。
每个数字的次数可以用HashMap来统计。

    public int minimumRounds(int[] tasks) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int res = 0;

        for(int task : tasks) {
            map.put(task, map.getOrDefault(task, 0) + 1);
        }

        for (Map.Entry<Integer,Integer> entry: map.entrySet()) {
            int cur = entry.getValue();
            if(cur == 1) return -1;
            if(cur % 3 == 0) res += cur / 3;
            else res += cur / 3 + 1;
        }
       
        return res;
    }

还有一种方法是先把数组排序，那么相同的数字就会放在一起，这样利用数组下标就可以统计每个数字的次数。
这种方法会快一些。

    public int minimumRounds(int[] tasks) {
        Arrays.sort(tasks);
        int n = tasks.length;
        int res = 0;

        for(int i = 0; i < n; i ++) {
            int j = i + 1;
            while(j < n && tasks[j] == tasks[i]) j ++;
            
            int cnt = j - i;
            if(cnt == 1) return -1;
            if(cnt % 3 == 0) res += cnt / 3;
            else res += cnt / 3 + 1;
            i = j - 1;  //因为有i++,所以要退一个,如果去掉i++,则这里是i=j
        }
        return res;
    }