📖本文目录

• 🙊写在前面
• 📆第287场周赛——2022-04-03
• • 📝T1.6055. 转化时间需要的最少操作数
  • • 题目
    • 示例
    • ⭐思路 ⭐
    • 代码实现
    • 执行结果
  • 📝T2. 5235. 找出输掉零场或一场比赛的玩家
  • • 题目
    • 示例
    • 提示
    • ⭐思路 ⭐
    • 代码实现
    • 执行结果
  • 📝T3. 5219. 每个小孩最多能分到多少糖果
  • • 题目
    • 示例
    • 提示
    • ⭐思路 ⭐
    • 代码实现
    • 执行结果
• 🙊写在最后

🙊写在前面

🙊小付来喽，今天接着有更新周赛栏目了哦

📆第287场周赛——2022-04-03

📝T1.6055. 转化时间需要的最少操作数

题目

示例

示例1：

输入：current = "02:30", correct = "04:35"
输出：3
解释：
可以按下述 3 步操作将 current 转换为 correct ：
- 为 current 加 60 分钟，current 变为 "03:30" 。
- 为 current 加 60 分钟，current 变为 "04:30" 。 
- 为 current 加 5 分钟，current 变为 "04:35" 。
可以证明，无法用少于 3 步操作将 current 转化为 correct 。

示例2：

输入：current = "11:00", correct = "11:01"
输出：1
解释：只需要为 current 加一分钟，所以最小操作数是 1 。

⭐思路 ⭐

📖本题思路以及考察点：

• 这题不难，因为题中给定了 current <= correct 所以说明这肯定是在一天中的两个时间点，我们只需要记录对应的秒数，然后依次从能操作最小的最大修改进行逐一操作记录即可。

代码实现

class Solution {
    public int convertTime(String current, String correct) {
        String[] currentTime = current.split(":");
        int currentSecond = Integer.parseInt(currentTime[0]) * 60 + Integer.parseInt(currentTime[1]);
        String[] correctTime = correct.split(":");
        int correctSecond = Integer.parseInt(correctTime[0]) * 60 + Integer.parseInt(correctTime[1]);
        
        int difSecond  =correctSecond - currentSecond;
        int cnt = 0;
        cnt += difSecond / 60;
        difSecond = difSecond % 60;
        cnt += difSecond / 15;
        difSecond = difSecond % 15;
        cnt += difSecond / 5;
        difSecond = difSecond % 5;
        cnt += difSecond / 1;
        difSecond = difSecond % 1;
        return cnt;
    }
}

执行结果

📝T2. 5235. 找出输掉零场或一场比赛的玩家

题目

示例

示例1：

输入：matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]
输出：[[1,2,10],[4,5,7,8]]
解释：
玩家 1、2 和 10 都没有输掉任何比赛。
玩家 4、5、7 和 8 每个都输掉一场比赛。
玩家 3、6 和 9 每个都输掉两场比赛。
因此，answer[0] = [1,2,10] 和 answer[1] = [4,5,7,8] 。

示例2：

输入：matches = [[2,3],[1,3],[5,4],[6,4]]
输出：[[1,2,5,6],[]]
解释：
玩家 1、2、5 和 6 都没有输掉任何比赛。
玩家 3 和 4 每个都输掉两场比赛。
因此，answer[0] = [1,2,5,6] 和 answer[1] = [] 。

提示

• 1 <= matches.length <= $10^5$
• matches[i].length == 2
• 1 <= winner[i], loser[i] <= $10^5$
• winner[i]!=loser[i]
• 所有 matches[i] 互不相同

⭐思路 ⭐

📖本题思路以及考察点：

• 这题是简单的一道集合应用题，我们可以先通过对每场比赛的获胜方与失败方得知本次参赛人的标号。
• 然后利用hashMap来存储每位选手获胜与失败的场数 ---> 这里的Map 的 key 代表选手号，val 代表选手获胜或者失败的场数。
• 最后遍历每位选手获取符合条件的选手之后对集合进行排序然后追加入结果即可。

代码实现

class Solution {
    public List<List<Integer>> findWinners(int[][] matches) {
        int m = matches.length;
        int n = matches[0].length;
        Set<Integer> humanNum = new HashSet<>();
        for (int[] tmp : matches){
            for (int i : tmp){
                if (humanNum.contains(i))continue;
                humanNum.add(i);
            }
        }
        Map<Integer,Integer> winnerMap = new HashMap<>();
        Map<Integer,Integer> loserMap = new HashMap<>();
        for (int i = 0 ;i< m;i++){
            int winner = matches[i][0];
            int loser = matches[i][1];
            winnerMap.put(winner,winnerMap.getOrDefault(winner,0)+1);
            loserMap.put(loser,loserMap.getOrDefault(loser,0)+1);
        }
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> tmp1 = new ArrayList<>();
        List<Integer> tmp2 = new ArrayList<>();
        
        for (int i : humanNum){
            if (!loserMap.containsKey(i)){
                tmp1.add(i);
            }
            if (loserMap.containsKey(i)&& loserMap.get(i) == 1){
                tmp2.add(i);
            }
        }
        
        tmp1 = tmp1.stream().sorted().collect(Collectors.toList());
        tmp2 = tmp2.stream().sorted().collect(Collectors.toList());
        res.add(tmp1);
        res.add(tmp2);
        return res;
    }
}

执行结果

📝T3. 5219. 每个小孩最多能分到多少糖果

题目

示例

示例1：

输入：candies = [5,8,6], k = 3
输出：5
解释：可以将 candies[1] 分成大小分别为 5 和 3 的两堆，然后把 candies[2] 分成大小分别为 5 和 1 的两堆。现在就有五堆大小分别为 5、5、3、5 和 1 的糖果。可以把 3 堆大小为 5 的糖果分给 3 个小孩。可以证明无法让每个小孩得到超过 5 颗糖果。

示例2：

输入：candies = [2,5], k = 11
输出：0
解释：总共有 11 个小孩，但只有 7 颗糖果，但如果要分配糖果的话，必须保证每个小孩至少能得到 1 颗糖果。因此，最后每个小孩都没有得到糖果，答案是 0 。

提示

• 1 <= candies.length <= $10^5$
• 1 <= candies[i] <= $10^7$
• 1 <= k <= $10^{12}$

⭐思路 ⭐

📖本题思路以及考察点：

• 刚好最近在刷二分板块，所以对二分比较敏感，我们先看到题中所给的提示数量级， 一般 1e7 就不能考虑 $n^2$ 的解决思路了，所以只能找找缩小时间复杂度的其他方法，对于之前的 282场周赛的T3如果你还有印象的话，这两题雷同。我们可以采用二分来解决此题，一般二分的时间复杂度是 $O(logN)$ 所以我们可以先尝试找找本题的二段性在哪里？
• 二分的本质不是单调性，而是二段性，能否找到某种性质将数段一分为二。
• 在极端条件 1e7 时每个小孩最多拥有的 🍬 是 1e7 个，但是我们需要考虑 此时这个糖果是否需要进行分堆，分的堆是否能满足大于等于k个堆，如果当前这个糖果能分出 大于等于 k 堆糖果的这个性质满足，则说明此时分出为这个糖果数就是符合条件的，我们需要找到对立性质的临界点，就是我们要找的结果。

代码实现

class Solution {
    public int maximumCandies(int[] candies, long k) {
        long l = 0 ;
        long r = (long)1e7;
        while ( l < r ){
            // 记录此时需要每堆需要分的糖果个数
            // 这里为什么要 + 1 这里我们可以理解为如果针对于 l = r - 1的情况来进行考虑，因为 如果 mid = l + r >> 1 的话,那么向下取整 ，那么 l = l 就会造成死循环，这也就是为什么这里需要加1
            long mid = (l + r + 1) / 2;
            // 记录能分多少堆
            long cnt = 0;
            // 遍历每堆糖果
            for (int i : candies){
                cnt += i / mid;
            }
            // 如果不满足性质缩小右区间，满足性质缩小左区间 
            if (cnt < k)r = mid - 1;
            else l = mid;
        }
        return (int)l;
    }
}

执行结果

🙊写在最后

小付打卡的第12场单周赛 2022-04-03

尽可能把会做的题 都做好 就可以了

本次周赛

还不错哦~上分啦 ！听说今天T4比较简单，但是字典树还是没做出来， 希望有朝一日能ak掉，尽自己做大努力就好了。