Leetcode每周.周赛第287场周赛 地平线专场 简单模拟计算 + 集合应用 + 二分

📖本篇内容：Leetcode每周.周赛第287场周赛 地平线专场 简单模拟计算 + 集合应用 + 二分

📑 文章专栏：leetcode周赛打卡《周周打卡》

📆 最近更新：2022 年 3 月 27 日 Leetcode每周.周赛第286场周赛 六方云专场 集合差集 + 遍历考察

🙊个人简介：一只二本院校在读的大三程序猿，本着注重基础，打卡算法，分享技术作为个人的经验总结性的博文博主，虽然可能有时会犯懒，但是还是会坚持下去的，如果你很喜欢博文的话，建议看下面一行~（疯狂暗示QwQ）

🌇 点赞 👍 收藏 ⭐留言 📝 一键三连 _{关爱程序猿，从你我做起}

🙊写在前面

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

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

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

题目

给你两个字符串 current 和 correct ，表示两个 24 小时制时间 。

24 小时制时间 按 “HH:MM” 进行格式化，其中 HH 在 00 和 23 之间，而 MM 在 00 和 59 之间。最早的 24 小时制时间为 00:00 ，最晚的是 23:59 。

在一步操作中，你可以将 current 这个时间增加 1、5、15 或 60 分钟。你可以执行这一操作 任意 次数。

返回将 current 转化为 correct 需要的 最少操作数 。

示例

示例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. 找出输掉零场或一场比赛的玩家

题目

给你一个整数数组 matches 其中 matches[i] = [winneri, loseri] 表示在一场比赛中 winneri 击败了 loseri 。

返回一个长度为 2 的列表 answer ：

answer[0] 是所有 没有 输掉任何比赛的玩家列表。
answer[1] 是所有恰好输掉 一场 比赛的玩家列表。
两个列表中的值都应该按 递增 顺序返回。

注意：

只考虑那些参与 至少一场 比赛的玩家。
生成的测试用例保证 不存在 两场比赛结果 相同 。

示例

示例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. 每个小孩最多能分到多少糖果

题目

给你一个 下标从 0 开始 的整数数组 candies 。数组中的每个元素表示大小为 candies[i] 的一堆糖果。你可以将每堆糖果分成任意数量的 子堆 ，但 无法 再将两堆合并到一起。

另给你一个整数 k 。你需要将这些糖果分配给 k 个小孩，使每个小孩分到 相同 数量的糖果。每个小孩可以拿走 至多一堆 糖果，有些糖果可能会不被分配。

返回每个小孩可以拿走的 最大糖果数目 。

示例

示例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掉，尽自己做大努力就好了。