第 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 <= 105
matches[i].length == 2
- 1 <= winneri, loseri <= 105
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;
}
};
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 <= 105
- 1 <= candies[i] <= 107
- 1 <= k <= 1012
题目分析:
-
确定查找区间
- 根据题意,我们需要搜寻的目标是小孩子最多可以拿走多少个糖果;小孩一次最少也得拿一个糖果,最多一次拿走全部
- 由此,我们首先对糖果总数进行统计;同时可知,若糖果总数小于小孩子的总数,无论如何不会有符合条件的答案,直接返回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;
}
};
我纠结于很多奇形怪状的人际关系里,后来我发现这些人和事消耗了我,他们带来无止境负面情绪。现在我才意识到,他们曾经消耗了我的理想,消耗了我对生活的热情,所以远离消耗你的人,也不要做消耗别人的人。 |
---|