leetcode周赛 第166场

5279. 整数的各位积和之差

题目描述：给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
示例 1：

输入：n = 234
输出：15 
解释：
各位数之积 = 2 * 3 * 4 = 24 
各位数之和 = 2 + 3 + 4 = 9 
结果 = 24 - 9 = 15

示例 2：

输入：n = 4421
输出：21
解释： 
各位数之积 = 4 * 4 * 2 * 1 = 32 
各位数之和 = 4 + 4 + 2 + 1 = 11 
结果 = 32 - 11 = 21

提示：

1 <= n <= 10^5

代码：

class Solution {
    public int subtractProductAndSum(int n) {
        String s = String.valueOf(n);
        char[] chars = s.toCharArray();
        int sum=0;
        int ji = 1;
        for (char aChar : chars) {
            sum=sum+(int)aChar-48;
            ji=ji*((int)aChar-48);
        }
        return ji-sum;
    }
}

5280. 用户分组

题目描述:有 n 位用户参加活动，他们的 ID 从 0 到 n - 1，每位用户都 恰好 属于某一用户组。给你一个长度为 n 的数组 groupSizes，其中包含每位用户所处的用户组的大小，请你返回用户分组情况（存在的用户组以及每个组中用户的 ID）。你可以任何顺序返回解决方案，ID 的顺序也不受限制。此外，题目给出的数据保证至少存在一种解决方案。

示例 1：

输入：groupSizes = [3,3,3,3,3,1,3]
输出：[[5],[0,1,2],[3,4,6]]
解释： 
其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。

示例 2：

输入：groupSizes = [2,1,3,3,3,2]
输出：[[1],[0,5],[2,3,4]]

提示：

groupSizes.length == n
1 <= n <= 500
1 <= groupSizes[i] <= n

思路：

	1.将数组转换为map<Integer,Integer> key:下标-value数值 的形式
	2.将map按照value进行排序（这里需要将map转为list，利用了重写list的sort方法进行实现）
	3.对已排序好的用户进行遍历，分组存入List集合中即可

class Solution {
    public List<List<Integer>> groupThePeople(int[] groupSizes) {
        
        Map<Integer,Integer> map = new LinkedHashMap<>();
        for(int i=0;i<groupSizes.length;i++){
            map.put(i,groupSizes[i]);
        }
        //转换为list
        List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
        list.sort(new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        });

        List<List<Integer>> ans = new LinkedList<>();
        int index=0;
        int val_now=list.get(0).getValue();
//        System.out.println(val_now);
        List<Integer> li = new LinkedList<>();
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i).getValue()==val_now && li.size()<list.get(i).getValue()){
                li.add(list.get(i).getKey());
            }else if(list.get(i).getValue()==val_now && li.size()==list.get(i).getValue()){
                ans.add(li);
                li=new LinkedList<>();
                i--;
            }else if(list.get(i).getValue()!=val_now){
                ans.add(li);
                li=new LinkedList<>();
                val_now = list.get(i).getValue();
                i--;
            }
        }
        if(!li.isEmpty()){
            ans.add(li);
        }
//        System.out.println(ans);
        return  ans;
    }
}

5281使结果不超过阈值的最小除数

题目描述：给你一个整数数组 nums 和一个正整数 threshold ，你需要选择一个正整数作为除数，然后将数组里每个数都除以它，并对除法结果求和。
请你找出能够使上述结果小于等于阈值 threshold 的除数中 最小 的那个。
每个数除以除数后都向上取整，比方说 7/3 = 3 ， 10/2 = 5 。
题目保证一定有解。
示例 1：

输入：nums = [1,2,5,9], threshold = 6
输出：5
解释：如果除数为 1 ，我们可以得到和为 17 （1+2+5+9）。
如果除数为 4 ，我们可以得到和为 7 (1+1+2+3) 。如果除数为 5 ，和为 5 (1+1+1+2)。

示例 2：

输入：nums = [2,3,5,7,11], threshold = 11
输出：3

示例 3：

输入：nums = [19], threshold = 5
输出：4

提示：

1 <= nums.length <= 5 * 10^4
1 <= nums[i] <= 10^6
nums.length <= threshold <= 10^6

思路

二分法

class Solution {
    public int smallestDivisor(int[] nums, int threshold) {
        int low=0;
        int high=Integer.MAX_VALUE;
        while(low<=high){
            int mid = (int)(high+low)/2;
            int sum=0;
            for(int i=0;i<nums.length;i++){
                sum += divide(nums[i],mid);
                if(sum>threshold){
                    break;
                }
            }
            if(sum<=threshold){
                high=mid-1;
            }
            if(sum>threshold){
                low =mid+1;
            }
        }
        return low;
    }

    public static int divide(int a,int b){
        return (int)Math.ceil((double)a/b);
    }
}

5282. 转化为全零矩阵的最少反转次数

题目描述：给你一个 m x n 的二进制矩阵 mat。

每一步，你可以选择一个单元格并将它反转（反转表示 0 变 1 ，1 变 0 ）。如果存在和它相邻的单元格，那么这些相邻的单元格也会被反转。（注：相邻的两个单元格共享同一条边。）
请你返回将矩阵 mat 转化为全零矩阵的最少反转次数，如果无法转化为全零矩阵，请返回 -1 。
二进制矩阵的每一个格子要么是 0 要么是 1 。
全零矩阵是所有格子都为 0 的矩阵。
示例 1：

输入：mat = [[0,0],[0,1]]
输出：3
解释：一个可能的解是反转 (1, 0)，然后 (0, 1) ，最后是 (1, 1) 。

示例 2：

输入：mat = [[0]]
输出：0
解释：给出的矩阵是全零矩阵，所以你不需要改变它。

示例 3：

输入：mat = [[1,1,1],[1,0,1],[0,0,0]]
输出：6

示例 4：

输入：mat = [[1,0,0],[1,0,0]]
输出：-1
解释：该矩阵无法转变成全零矩阵

提示：

m == mat.length
n == mat[0].length
1 <= m <= 3
1 <= n <= 3
mat[i][j] 是 0 或 1 。

太菜还没做出来

//TODO