目录
1. 拿硬币
桌上有 n
堆力扣币,每堆的数量保存在数组 coins
中。我们每次可以选择任意一堆,拿走其中的一枚或者两枚,求拿完所有力扣币的最少次数。
示例 1:
输入:
[4,2,1]
输出:
4
解释:第一堆力扣币最少需要拿 2 次,第二堆最少需要拿 1 次,第三堆最少需要拿 1 次,总共 4 次即可拿完。
示例 2:
输入:
[2,3,10]
输出:
8
限制:
1 <= n <= 4
1 <= coins[i] <= 10
解题思路:
很明显每堆两个两个拿,不够两个拿一个
代码:
class Solution {
public:
int minCount(vector<int>& coins) {
int ans = 0;
for(int x:coins){
ans += (x+1)/2;
}
return ans;
}
};
2. 传递信息
小朋友 A 在和 ta 的小伙伴们玩传信息游戏,游戏规则如下:
- 有 n 名玩家,所有玩家编号分别为 0 ~ n-1,其中小朋友 A 的编号为 0
- 每个玩家都有固定的若干个可传信息的其他玩家(也可能没有)。传信息的关系是单向的(比如 A 可以向 B 传信息,但 B 不能向 A 传信息)。
- 每轮信息必须需要传递给另一个人,且信息可重复经过同一个人
给定总玩家数 n
,以及按 [玩家编号,对应可传递玩家编号]
关系组成的二维数组 relation
。返回信息从小 A (编号 0 ) 经过 k
轮传递到编号为 n-1 的小伙伴处的方案数;若不能到达,返回 0。
示例 1:
输入:
n = 5, relation = [[0,2],[2,1],[3,4],[2,3],[1,4],[2,0],[0,4]], k = 3
输出:
3
解释:信息从小 A 编号 0 处开始,经 3 轮传递,到达编号 4。共有 3 种方案,分别是 0->2->0->4, 0->2->1->4, 0->2->3->4。
示例 2:
输入:
n = 3, relation = [[0,2],[2,1]], k = 2
输出:
0
解释:信息不能从小 A 处经过 2 轮传递到编号 2
限制:
2 <= n <= 10
1 <= k <= 5
1 <= relation.length <= 90, 且 relation[i].length == 2
0 <= relation[i][0],relation[i][1] < n 且 relation[i][0] != relation[i][1]
解题思路:
用一个队列还储存传递k次后的位置,然后统计有多少次到达了最后的位置
代码:
class Solution {
public:
int numWays(int n, vector<vector<int>>& relation, int k) {
vector<vector<int>>res(n);
for(auto x:relation){
res[x[0]].push_back(x[1]);
}
queue<int>q;
q.push(0);
while(!q.empty()&&k>0){
int size = q.size();
while(size--){
auto u = q.front();
q.pop();
for(int i = 0;i<res[u].size();i++)
q.push(res[u][i]);
}
k--;
}
int ans = 0;
while(!q.empty()){
int c = q.front();
if(c==n-1)ans++;
q.pop();
}
return ans;
}
};
3. 剧情触发时间
在战略游戏中,玩家往往需要发展自己的势力来触发各种新的剧情。一个势力的主要属性有三种,分别是文明等级(C
),资源储备(R
)以及人口数量(H
)。在游戏开始时(第 0 天),三种属性的值均为 0。
随着游戏进程的进行,每一天玩家的三种属性都会对应增加,我们用一个二维数组 increase
来表示每天的增加情况。这个二维数组的每个元素是一个长度为 3 的一维数组,例如 [[1,2,1],[3,4,2]]
表示第一天三种属性分别增加 1,2,1
而第二天分别增加 3,4,2
。
所有剧情的触发条件也用一个二维数组 requirements
表示。这个二维数组的每个元素是一个长度为 3 的一维数组,对于某个剧情的触发条件 c[i], r[i], h[i]
,如果当前 C >= c[i]
且 R >= r[i]
且 H >= h[i]
,则剧情会被触发。
根据所给信息,请计算每个剧情的触发时间,并以一个数组返回。如果某个剧情不会被触发,则该剧情对应的触发时间为 -1 。
示例 1:
输入:
increase = [[2,8,4],[2,5,0],[10,9,8]]
requirements = [[2,11,3],[15,10,7],[9,17,12],[8,1,14]]
输出:
[2,-1,3,-1]
解释:
初始时,C = 0,R = 0,H = 0
第 1 天,C = 2,R = 8,H = 4
第 2 天,C = 4,R = 13,H = 4,此时触发剧情 0
第 3 天,C = 14,R = 22,H = 12,此时触发剧情 2
剧情 1 和 3 无法触发。
示例 2:
输入:
increase = [[0,4,5],[4,8,8],[8,6,1],[10,10,0]]
requirements = [[12,11,16],[20,2,6],[9,2,6],[10,18,3],[8,14,9]]
输出:
[-1,4,3,3,3]
示例 3:
输入:
increase = [[1,1,1]]
requirements = [[0,0,0]]
输出:
[0]
限制:
1 <= increase.length <= 10000
1 <= requirements.length <= 100000
0 <= increase[i] <= 10
0 <= requirements[i] <= 100000
解题思路:
数据量比较大,很明显不能在n平方复杂度下完成,于是可以用三个数组c[i],r[i],h[i]分别维护三个属性值在第i天的数值,对于每一个剧情,使用二分查找来寻找满足的天数,取三个天数的最大值就是解锁天数,注意判断第0天就满足的条件。这样时间复杂度
代码:
class Solution {
public:
vector<int> getTriggerTime(vector<vector<int>>& increase, vector<vector<int>>& requirements) {
int n = requirements.size();
vector<int>c(increase.size(),0);
vector<int>r(increase.size(),0);
vector<int>h(increase.size(),0);
c[0] = increase[0][0];
r[0] = increase[0][1];
h[0] = increase[0][2];
for(int i = 1;i<increase.size();i++){
c[i] = c[i-1] + increase[i][0];
r[i] = r[i-1] + increase[i][1];
h[i] = h[i-1] + increase[i][2];
}
vector<int>ans;
for(int i = 0;i<n;i++){
if(requirements[i][0]==0&&requirements[i][1]==0&&requirements[i][2]==0){
ans.push_back(0);
continue;
}
int id1 = lower_bound(c.begin(),c.end(),requirements[i][0])-c.begin();
int id2 = lower_bound(r.begin(),r.end(),requirements[i][1])-r.begin();
int id3 = lower_bound(h.begin(),h.end(),requirements[i][2])-h.begin();
int id = max(max(id1,id2),id3);
// cout<<id1<<" "<<id2<<" "<<id3<<" "<<id<<endl;
if(id==increase.size())ans.push_back(-1);
else ans.push_back(id+1);
}
return ans;
}
};
4. 最小跳跃次数
为了给刷题的同学一些奖励,力扣团队引入了一个弹簧游戏机。游戏机由 N
个特殊弹簧排成一排,编号为 0
到 N-1
。初始有一个小球在编号 0
的弹簧处。若小球在编号为 i
的弹簧处,通过按动弹簧,可以选择把小球向右弹射 jump[i]
的距离,或者向左弹射到任意左侧弹簧的位置。也就是说,在编号为 i
弹簧处按动弹簧,小球可以弹向 0
到 i-1
中任意弹簧或者 i+jump[i]
的弹簧(若 i+jump[i]>=N
,则表示小球弹出了机器)。小球位于编号 0 处的弹簧时不能再向左弹。
为了获得奖励,你需要将小球弹出机器。请求出最少需要按动多少次弹簧,可以将小球从编号 0
弹簧弹出整个机器,即向右越过编号 N-1
的弹簧。
示例 1:
输入:
jump = [2, 5, 1, 1, 1, 1]
输出:
3
解释:小 Z 最少需要按动 3 次弹簧,小球依次到达的顺序为 0 -> 2 -> 1 -> 6,最终小球弹出了机器。
限制:
1 <= jump.length <= 10^6
1 <= jump[i] <= 10000
解题思路:
一开始觉得是动态规划,后来发现不同位置跳跃的最远点需要按照顺序进行处理,于是考虑用一个队列,里边的两个值代表下标和跳到当前位置需要次数,当跳到位置i的时候,i+jump[i]≥n作为终止条件,如果没有终止则将{i+jump[i],d+1}放入队列,然后再将i位置之前还没有访问过的位置也放入队列,这样在队列中就实现了访问的先后顺序,这里还要用vis标记是否访问过。复杂度是O(n)
代码:
class Solution {
public:
int minJump(vector<int>& jump) {
queue<pair<int,int>>q;
// int i = 0;
int n = jump.size();
vector<int>vis(n,0);
q.push({0,0});
int start = 0;
while(!q.empty()){
int u = q.front().first;
int d = q.front().second;
q.pop();
if(u+jump[u]>=n)return d+1;
if(vis[u+jump[u]]==0){
vis[u+jump[u]] = 1;
q.push({u+jump[u],d+1});
}
for(int i = start;i<u;i++){
if(!vis[i]){
vis[i] = 1;
q.push({i,d+1});
}
}
start = max(start,u);
}
return -1;
}
};
5. 二叉树任务调度
任务调度优化是计算机性能优化的关键任务之一。在任务众多时,不同的调度策略可能会得到不同的总体执行时间,因此寻求一个最优的调度方案是非常有必要的。
通常任务之间是存在依赖关系的,即对于某个任务,你需要先完成他的前导任务(如果非空),才能开始执行该任务。我们保证任务的依赖关系是一棵二叉树,其中 root
为根任务,root.left
和 root.right
为他的两个前导任务(可能为空),root.val
为其自身的执行时间。
在一个 CPU 核执行某个任务时,我们可以在任何时刻暂停当前任务的执行,并保留当前执行进度。在下次继续执行该任务时,会从之前停留的进度开始继续执行。暂停的时间可以不是整数。
现在,系统有两个 CPU 核,即我们可以同时执行两个任务,但是同一个任务不能同时在两个核上执行。给定这颗任务树,请求出所有任务执行完毕的最小时间。
示例 1:
输入:root = [47, 74, 31]
输出:121
解释:根节点的左右节点可以并行执行31分钟,剩下的43+47分钟只能串行执行,因此总体执行时间是121分钟。
示例 2:
输入:root = [15, 21, null, 24, null, 27, 26]
输出:87
示例 3:
输入:root = [1,3,2,null,null,4,4]
输出:7.5
限制:
1 <= 节点数量 <= 1000
1 <= 单节点执行时间 <= 1000
解题思路:
我们设f(i) 为节点 ii 的最短时间,然后分类讨论。
如果 i 是一个叶子,那么显然 f(i) = val(i)。如果 i 只有一个儿子,那么先要执行完儿子才轮得到自己,f(i) = f(son(i)) + val(i)
如果 i 有两个儿子 l, r,那么我们就可以考虑用双核来优化。一种最简单的优化策略是:两个子树分别使用双核跑完,然后再根节点跑。这样的时间消耗是 f(l)+f(r) + val(i)
还有一种策略是:在左边花费 x 时间使用双核(这里是有效使用,即两个核都必须用上,后同),在右边花费 y 时间使用双核,然后在左右两棵子树一边一个核。可以看出,第三个样例使用的正是这样的策略,在根节点的右子树先花费了 3.5 的时间,然后左右两边一边一个核花费 3 时间。
那么,这种情况下,设左右子树的任务总时间和分别为 sum(l), sum(r)。则通过利用双核,左子树剩下的任务时间变成了 sum(l) - 2x,右子树剩下的任务时间变成了 sum(r) - 2y,然后一边一个核处理完剩下的任务所需时间为这两者的较大者。因而总时间为
val(i)+x+y+max{sum(l)−2x,sum(r)−2y}
即
val(i)+max{sum(l)+y−x,sum(r)−(y−x)}
val(i)的时间消耗是逃不掉的,我们考虑后面这个 max 怎样取得尽量小。设 t=y-x,那么后面这个max 要取到最小当且仅当 t= mid =(sum(r) - sum(l))/2 ,并且如果 t 偏离 mid 越远,那么这个 max 就越大。注意到 x∈[0,sum(l)−f(l)],y∈[0,sum(r)−f(r)],就有t∈[f(l)−sum(l),sum(r)−f(r)]。通过对 mid 和这个区间位置的讨论,我们就能算出这个 max 的最小值。
最后把以上这些情况统合起来,就有下面的转移方程:
f(i)=val(i)+min{f(l)+f(r), min(max{sum(l)+t,sum(r)−t})
其中规定如果 l或者 r 为空,对应的 sum, f均为 0。
时间复杂度 O(n)。
代码:
class Solution {
public:
pair<double,double> dfs(TreeNode* cur){
if(cur==NULL)return {0,0};
pair<double,double>lc = dfs(cur->left);
pair<double,double>rc = dfs(cur->right);
double fl = lc.first,sml = lc.second;
double fr = rc.first,smr = rc.second;
double f = cur->val + fl + fr;
double sm = cur->val + sml + smr;
double gl = sml - fl, gr = smr - fr;
double mid = (smr-sml)/2;
double t;
if(mid<-gl)
t = -gl;
else if(mid>gr)
t = gr;
else
t = mid;
f = min(f,cur->val+max(sml+t,smr-t));
return {f,sm};
}
double minimalExecTime(TreeNode* root) {
return dfs(root).first;
}
};