第 287 场周赛

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

给你两个字符串 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 都符合 "HH:MM" 格式
current <= correct

题目分析：（贪心）

因为时间是递增的，所以每次只需要减去当前最大的可操作的时间，记录次数，即为想要的答案

class Solution {
public:
    int convertTime(string current, string correct) {
        int a=current[0]*10+current[1];
        int b=correct[0]*10+correct[1];
        int c=current[3]*10+current[4];
        int d=correct[3]*10+correct[4];
        int ab=b-a;
        int cd=d-c;
        int ans=0;
        int num=ab*60+cd;
         while(num>=60){
            num-=60;
            ++ans;
        }
        while(num>=15){
            num-=15;
            ++ans;
        }
        while(num>=5){
            num-=5;
            ++ans;
        }
        while(num){
            num-=1;
            ++ans;
        }
        return ans;
    }
};

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

给你一个整数数组 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⁵
matches[i].length == 2
1 <= winneri, loseri <= 10⁵
winneri != loseri
所有matches[i]互不相同

方法一：map+set

首先把所有赢过的人存进s1，然后把所有输的人存进s2，然后统计一下输的人的次数
然后遍历s1，只赢不输的人为在s1出现的人，但是不在s2出现的人
输过一次的人为s1中的人同时出现在s2中的人，并且输掉的次数为1的人加上在s2中的人输掉一次的人的总和
最后对动态数组中的元素进行排序

class Solution {
public:
    vector<vector<int>> findWinners(vector<vector<int>>& matches) {
        int n=matches.size();
        map<int,int>mp;
        set<int>s1,s2,s3;
        vector<vector<int> >ve(2);
        for(int i=0;i<n;++i){
            s1.insert(matches[i][0]);
            s2.insert(matches[i][1]);
            mp[matches[i][1]]++;
        }
        for(auto x:s1){
            if(!s2.count(x)){
                ve[0].push_back(x);
            }
            if(s2.count(x)&&mp[x]==1){
                ve[1].push_back(x);
            }
        }
        for(auto y:s2){
            if(mp[y]==1&&!s1.count(y))
                ve[1].push_back(y);
        }
        sort(ve[0].begin(),ve[0].end());
        sort(ve[1].begin(),ve[1].end());
        return ve;
    }
};

方法二：map+迭代器

后面我想了一下，其实不用set去做，以为题目已经说了不会出现重复的人，所以可以直接使用map，map的底层是一个红黑树，已经会自动排序，所以这个题目的标准答案应该是map
首先把所有参与的人存进map，不同的是输的人次数加一，最后我们遍历map，去找到从未输过的人加进第一个数组，输过一次的人加进第二个数组，数组下标从零开始
这个方法非常的好，是双百解法

class Solution {
public:
    vector<vector<int>> findWinners(vector<vector<int>>& matches) {
        map<int,int>mp;
        vector<vector<int> >ve(2);
        int n=matches.size();
        for(int i=0;i<n;++i){
            mp[matches[i][0]];
            mp[matches[i][1]]++;
        }
        for(auto it=mp.begin();it!=mp.end();it++){
            if(it->second==0)
            ve[0].push_back(it->first);
            if(it->second==1)
            ve[1].push_back(it->first);
        }
        return ve;
    }
};

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bLSO8rYj-1649037119048)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220403155836849.png)]$

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

给你一个 下标从 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⁵
1 <= candies[i] <= 10⁷
1 <= k <= 10¹²

题目分析：

确定查找区间
- 根据题意，我们需要搜寻的目标是小孩子最多可以拿走多少个糖果；小孩一次最少也得拿一个糖果，最多一次拿走全部
- 由此，我们首先对糖果总数进行统计；同时可知，若糖果总数小于小孩子的总数，无论如何不会有符合条件的答案，直接返回0
- 最终，区间确定为left = 1, right = sum(nums)
二分答案进行查找
- 利用二分查找缩小查找答案的区间，每次对取得的mid进行check
- 在本题条件下，我们会发现，若某个mid符合条件时，我们会希望得到更大的答案，此时查找区间从[left, right]变为[mid + 1, right]，同时对ans进行更新
- 若mid不符合条件，则答案过大，我们希望得到符合条件的答案，因此要对右区间进行缩小，此时查找区间从[left, right]变为[left, right - 1]
确定check方法
- 这一步算是二分答案的核心内容，我们需要根据题目的要求来确定，我们所得的mid是否符合条件，从而确定区间的移动
- 在本题条件下我们只需要统计一个数中，最多可以分出多少个mid
- 例：[2,5,3,7] mid = 3, k = 4，一次拿取mid个糖果，其中：2无法满足一次拿取，k值不变；5可以分为3和2，来满足一次拿去， k -= 1；3本身正好可以满足一次拿取，k -= 1；7可以分为3和4，来满足一次拿取，而4又可以分为3和1，再一次满足一次拿取
- 根据这个思路，对数组中的糖果进行拿取；最终若可满足K个孩子，则返回true，否则返回false；返回的布尔值会决定上一步中的区间的左右移动
本题采用的时while (left <= right)最终返回ans；
若采用while (left < right)则最终返回left或right都可以(二者最终汇聚到一点)
二分查找类的题目更多类似于板子题，其核心是区间的左右移动及如何决定区间的移动

循环条件是while（left<=right）版本

class Solution {
    bool check(vector<int>& candies, long long k,int val){
        for(int candy : candies){
            k-=candy/val;
        }
        return k<=0;
    }
public:
    int maximumCandies(vector<int>& candies, long long k) {
        long long sum = 0;
        for(int candy : candies) sum+=candy;
        if(sum<k) return 0;
        int left=1,right=sum/k;
        int ans=0; //由于是left<=right，所以需要一个额外的变量ans保存答案
        while(left<=right){
            int mid = (left+right)/2;
            if(check(candies,k,mid)){
                ans=mid;
                left=mid+1;
            }
            else right=mid-1;
        }
        return ans;
    }
};

循环条件是while（left<right）版本

class Solution {
    bool check(vector<int>& candies, long long k,int val){
        for(int candy : candies){
            k-=candy/val;
        }
        return k<=0;
    }
public:
    int maximumCandies(vector<int>& candies, long long k) {
        long long sum = 0;
        for(int candy : candies) sum+=candy;
        if(sum<k) return 0;
        int left=1,right=sum/k;
        while(left<right){
            //注意这里求mid和上面的区别
            int mid = (left+right+1)/2;
            if(check(candies,k,mid)){
                left=mid;
            }
            else right=mid-1;
        }
        //不需要一个额外的变量ans保存答案，直接返回left
        return left;
    }
};

不用统计总数，直接枚举版

class Solution {
public:
    typedef long long ll;
    int inf=0x3f3f3f3f;
    int maximumCandies(vector<int>& a, long long k) {
        int n=a.size();
        ll l=0,r=10000000;
        ll mid;
        while(l<r){
            mid=(l+r+1)/2;
            ll cnt=0;
            for(int i=0;i<n;i++){
                cnt+=a[i]/mid;
            }
            if(cnt>=k) l=mid;
            else r=mid-1;
        }
        return l;
    }
};

我纠结于很多奇形怪状的人际关系里，后来我发现这些人和事消耗了我，他们带来无止境负面情绪。现在我才意识到，他们曾经消耗了我的理想，消耗了我对生活的热情，所以远离消耗你的人，也不要做消耗别人的人。