LeetCode 第193场周赛 题解
文章目录
- a.一维数组的动态和
- a.题目
- a.分析
- a.参考代码
- b.不同整数的最少数目
- b.题目
- b.分析
- b.参考代码
- c.制作 m 束花所需的最少天数
- c.题目
- c.分析
- c.参考代码
- d.树节点的第 K 个祖先
- d.题目
- d.分析
- d.参考代码
a.一维数组的动态和
a.题目
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。
示例 1
输入：nums = [1,2,3,4]
输出：[1,3,6,10]
解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
示例 2
输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
示例 3
输入：nums = [3,1,2,10,1]
输出：[3,4,6,16,17]
提示
- 1 <= nums.length <= 1000
- -10^6 <= nums[i] <= 10^6
a.分析
啊这… 完全就是前缀和的模板
明显的递推公式：
sum[i]=sum[i-1]+arr[i]
时间复杂度O(n) 实际上暴力n方也能过
a.参考代码
class Solution {
public:
vector<int> runningSum(vector<int>& nums) {
vector<int> ans={nums[0]};
for(int i=1;i<nums.size();i++)
ans.push_back(ans[i-1]+nums[i]);
return ans;
}
};
b.不同整数的最少数目
b.题目
给你一个整数数组 arr 和一个整数 k 。现需要从数组中恰好移除 k 个元素，请找出移除后数组中不同整数的最少数目。
示例 1
输入：arr = [5,5,4], k = 1
输出：1
解释：移除 1 个 4 ，数组中只剩下 5 一种整数。
示例 2
输入：arr = [4,3,1,1,3,3,2], k = 3
输出：2
解释：先移除 4、2 ，然后再移除两个 1 中的任意 1 个或者三个 3 中的任意 1 个，最后剩下 1 和 3 两种整数。
提示
- 1 <= arr.length <= 10^5
- 1 <= arr[i] <= 10^9
- 0 <= k <= arr.length
b.分析
题目的另一种转化表述就是：
删除k个元素 尽量多删除完一类元素
那么既然k是固定的 想要尽量多的删除完一类元素
那么就要保证这一类元素足够少 所以删除完它的代价就小
所以按照这个思路就可以得出答案了
- 对一类元素的个数进行排序
- 从个数少一直删除 直到总删除个数超过k
考虑到元素的大小1e9比较大 所以用哈希表去计数
计数完之后这一类是谁就无关紧要了 直接对计数进行排序
总的时间复杂度是O(n)的
b.参考代码
class Solution {
public:
int findLeastNumOfUniqueInts(vector<int>& arr, int k) {
unordered_map<int,int> m; //计数用哈希表
for(int i=0;i<arr.size();i++)
m[arr[i]]++;
vector<int> v;
for(auto i:m)v.push_back(i.second); //只有计数有用
sort(v.begin(),v.end()); //排序
int ans=v.size();
int idx=0;
while(k>0&&idx<v.size()) //一直删除某一类
{
k-=v[idx];
idx++;
if(k>=0)ans--; //如果k<0表示无法删除完全这一类 不应该计数
}
return ans;
}
};
c.制作 m 束花所需的最少天数
c.题目
给你一个整数数组 bloomDay，以及两个整数 m 和 k 。
现需要制作 m 束花。制作花束时，需要使用花园中 相邻的k朵花 。
花园中有 n 朵花，第 i 朵花会在 bloomDay[i] 时盛开，并可以用于一束花中。
请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。
示例 1
输入：bloomDay = [1,10,3,10,2], m = 3, k = 1
输出：3
解释：让我们一起观察这三天的花开过程，x 表示花开，而 _ 表示花还未开。
现在需要制作 3 束花，每束只需要 1 朵。
1 天后：[x, _, _, _, _] // 只能制作 1 束花
2 天后：[x, _, _, _, x] // 只能制作 2 束花
3 天后：[x, _, x, _, x] // 可以制作 3 束花，答案为 3
示例 2
输入：bloomDay = [1,10,3,10,2], m = 3, k = 2
输出：-1
解释：要制作 3 束花，每束需要 2 朵花，也就是一共需要 6 朵花。而花园中只有 5 朵花，无法满足制作要求，返回 -1 。
示例 3
输入：bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
输出：12
解释：要制作 2 束花，每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下：
7 天后：[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花，因为它们不相邻。
12 天后：[x, x, x, x, x, x, x]
显然，我们可以用不同的方式制作两束花。
示例 4
输入：bloomDay = [1000000000,1000000000], m = 1, k = 1
输出：1000000000
解释：需要等 1000000000 天才能采到花来制作花束
示例 5
输入：bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
输出：9
提示
- bloomDay.length == n
- 1 <= n <= 10^5
- 1 <= bloomDay[i] <= 10^9
- 1 <= m <= 10^6
- 1 <= k <= n
c.分析
这道题我是用了二分的
因为思考了一下 其满足二分的要求：
- 假设答案为x 且存在
- 大于x的天数 可以保证其能够满足 因为天数变大只会多出来多余的花而已 原来的花并不会枯萎
- 小于x的天数 可以保证其必定不能满足 否则违背了假设答案为x
那么二分一下就能够得出答案
然后是check当前天数是否满足的函数实现：
有得变成花束就变 贪心的策略 因为假如你不选当前的这朵花 那么显然就要再在后面连续的多出一朵 显然：要在后面多出一朵花更为苛刻
二分要求是答案存在
那么答案不存在的情况只有全部花都不够包装花束 因为等待无穷时间 总是可以把全部花都考虑到的
总的时间复杂度是O(nlogn) 二分logn check要遍历是n
c.参考代码
class Solution {
public:
vector<int> b;
int minDays(vector<int>& bd, int m, int k) {
b=bd;
int n=b.size();
if(1ll*m*k>n)return -1;
int l=*min_element(b.begin(),b.end()),r=*max_element(b.begin(),b.end()); //找到最大和最小天数
while(l<r) //二分
{
int mid=(l+r)>>1;
if(check(mid,m,k))r=mid; //可行 看下能不能更小
else l=mid+1; //不可行
}
return l;
}
bool check(int d,int m,int k) //模拟包装花过程
{
int cnt=0;
bool flag=true;
for(int i=0;i<b.size();i++)
{
if(b[i]<=d)cnt++;
else cnt=0;
if(cnt==k){
m--;
cnt=0; //花不能共用 要置0
}
}
return m<=0; //有可能能包更多束 无所谓
}
};
d.树节点的第 K 个祖先
d.题目
给你一棵树，树上有 n 个节点，按从 0 到 n-1 编号。树以父节点数组的形式给出，其中 parent[i] 是节点 i 的父节点。树的根节点是编号为 0 的节点。
请你设计并实现 getKthAncestor(int node, int k) 函数，函数返回节点 node 的第 k 个祖先节点。如果不存在这样的祖先节点，返回 -1 。
树节点的第 k 个祖先节点是从该节点到根节点路径上的第 k 个节点。
示例
输入：
[“TreeAncestor”,“getKthAncestor”,“getKthAncestor”,“getKthAncestor”]
[[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]
输出：
[null,1,0,-1]
解释：
TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
treeAncestor.getKthAncestor(3, 1); // 返回 1 ，它是 3 的父节点
treeAncestor.getKthAncestor(5, 2); // 返回 0 ，它是 5 的祖父节点
treeAncestor.getKthAncestor(6, 3); // 返回 -1 因为不存在满足要求的祖先节点
提示
- 1 <= k <= n <= 5*10^4
- parent[0] == -1 表示编号为 0 的节点是根节点。
- 对于所有的 0 < i < n ，0 <= parent[i] < n 总成立
- 0 <= node < n
- 至多查询 5*10^4 次
d.分析
首先是用的暴力做的
先看下暴力的思路：
保存所有的ans[i][k] 表示第i个节点的第k个祖先是什么
那么就有递推公式：
ans[i][k]=ans[parent[i]][k-1]
这是很显然的
但是想想看 填充完整个ans需要n^2
即使把无用的超出树根的状态不填充… 也会爆掉
那么我们就要考虑优化了
倍增优化：
其实根本没有必要把每个节点的1~n的祖先节点都保存起来
我们暴力的思路就是不断的-1 -1 -1 -1去把目标的k去找到
然后我们可以利用二进制 也可以找到任意的k （这个是二进制的特性 一个数k总是可以拆分成2的某次方的和）
如 k=7 可以拆成20+21+2^2
因此 我们可以把ans[i][k]的k优化成为ans[i][j]
此处的j表示2的j次方
那么之前就是走k步 现在就是走2^j步
递推公式为：
ans[i][j]=ans[ans[i][j-1]][j-1]
意思就是节点i向上走2j步就是先向上走了2(j-1)步然后到了那个节点 然后再在那个节点走2^(j-1)步
那么这里就需要保证拓扑关系
即需要把上面的点的全部关系都处理出来之后才能进行递推
那么这里可以采用从根节点出发的bfs来保证
总的时间复杂度为预处理需要填满所有状态为O(nlogn)
而每次询问需要用logn来求得答案 因为k要被分解为多个2的倍数
总的时间复杂度为O(nlogn)
d.参考代码
class TreeAncestor {
public:
vector<vector<int>> f; //祖先节点 即分析的ans
vector<vector<int>> g; //邻接表存图
TreeAncestor(int n, vector<int>& p) {
f=vector<vector<int>>(n,vector<int>(16,-1));
g=vector<vector<int>>(n);
for(int i=1;i<n;i++)g[p[i]].push_back(i); //存子节点关系 方便向下bfs递推
queue<int> q;
q.push(0);
while(q.size()){
int x=q.front();
q.pop();
for(auto y:g[x]){
f[y][0] = x;
for(int k=1;k<16;k++) //最多有2^16层
if(f[y][k-1]!=-1)
f[y][k]=f[f[y][k-1]][k-1]; //递推公式
q.push(y);
}
}
}
int getKthAncestor(int x, int k) {
for(int i=0;i<16;i++){
if(k>>i&1){
x=f[x][i];
if(x==-1)return x;
}
}
return x;
}
};