Leetcode-914. 卡牌分组

• 题目：

给定一副牌，每张牌上都写着一个整数。

此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：

每组都有 X 张牌。
组内所有的牌上都写着相同的整数。
仅当你可选的 X >= 2 时返回 true。

 

示例 1：

输入：[1,2,3,4,4,3,2,1]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[3,3]，[4,4]
示例 2：

输入：[1,1,1,2,2,2,3,3]
输出：false
解释：没有满足要求的分组。
示例 3：

输入：[1]
输出：false
解释：没有满足要求的分组。
示例 4：

输入：[1,1]
输出：true
解释：可行的分组是 [1,1]
示例 5：

输入：[1,1,2,2,2,2]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[2,2]

提示：

1 <= deck.length <= 10000
0 <= deck[i] < 10000

• 我的思路：

因为和数字有关系，所以肯定要遍历，计数！我用到了HashMap来计数，当然也学会用int数组来计数，可以用下标来当作这个卡牌的数组，但是发现如果顺序不是从0开始，而是中间有空的，比如[0,0,1,1,4,7,13,24]这样子用下标来记录的话，很麻烦，无法判断新创建的int数组的长度。

计数完之后，继续分析问题，发现这是一个分组问题，再想想已经将每张卡牌的数目计算出来了，于是分组问题也变成了，求最大公约数。只不过是多个数字的最大公约数。如果最大公约数大于等于2则返回true。否则返回false；

class Solution {
    public boolean hasGroupsSizeX(int[] deck) {
        //空数组直接返回false；
        if(deck.length == 0){
            return false;
        }
        //计数，HashMap计数法
        Map<Integer, Integer> map = new HashMap<>();
        for(int num : deck){
            if(map.containsKey(num)){
                map.put(num, map.get(num) + 1);
            }else{
                map.put(num, 1);
            }
        }

        //计数，数组计数法
        //int[] count = new int[duck.length];
        //for(int num : duck){
        //    count[num]++;
        //}

        //先给最大公约数，随便赋值一个存在的值。
        int bigDiv = map.get(deck[0]);
        if(bigDiv < 2){
            return false;
        }
        for(Integer key : map.keySet()){
            //存在只有一张卡牌的情况，直接返回false；
            if(map.get(key) == 1){
                return false;
            }
            //求这两个数的最大公约数
            bigDiv = getDiv(bigDiv, map.get(key));
        }
        //最后对最大公约数判断
        if(bigDiv < 2){
            return false;
        }else{
            return true;
        }
    }
    //辗转相除法，求最大公约数，辗转相除法的时间复杂度远小于辗转相减法！
    public Integer getDiv(Integer x, Integer y){
        if(y > x){
            int temp = x;
            x = y;
            y = temp;
        }
        while(x%y != 0){
            int temp = x%y;
            x = y;
            y = temp;
        }
        return y;
    }
}

有一点问题就是，如果求最大公约数时用的是辗转相减法，则会超时！辗转相除法的时间复杂度更小！

 

大佬的代码：

public class Solution {

    public boolean hasGroupsSizeX(int[] deck) {
        int len = deck.length;
        if (len < 2) {
            return false;
        }

        // 计数数组，10000 是根据题目给出的数值范围定的
        int[] cnt = new int[10000];
        for (int num : deck) {
            cnt[num]++;
        }

        // 先得到第 1 个数的个数，以避免在循环中赋值
        int x = cnt[deck[0]];

        for (int i = 0; i < 10000; i++) {
            if (cnt[i] == 1) {
                return false;
            }

            if (cnt[i] > 1) {
                x = gcd(x, cnt[i]);

                // 这里做判断可以提前终止运行，也可以等到最后再做，各有优劣，任选其一
                if (x == 1) {
                    return false;
                }
            }
        }
        return true;
    }

    private int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        // int[] deck = new int[]{1, 2, 3, 4, 4, 3, 2, 1};
        // int[] deck = new int[]{1, 1, 1, 2, 2, 2, 3, 3};
        // int[] deck = new int[]{1};
        // int[] deck = new int[]{1, 1};
        int[] deck = new int[]{0, 0, 1, 1, 1, 1, 2, 2, 3, 4};
        //boolean res = solution.hasGroupsSizeX(deck);
        //System.out.println(res);
        System.out.println(solution.gcd(2, 8));
    }
}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/x-of-a-kind-in-a-deck-of-cards/solution/qiu-jie-zui-da-gong-yue-shu-java-by-liweiwei1419/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

大佬思路也是一样的，代码比我好看！！

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/x-of-a-kind-in-a-deck-of-cards
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。