第二次 leetcode周赛总结(开心！多总结，多进步)

T1:k件物品的最大和

袋子中装有一些物品，每个物品上都标记着数字 1 、0 或 -1 。

给你四个非负整数 numOnes 、numZeros 、numNegOnes 和 k 。

袋子最初包含：

numOnes 件标记为 1 的物品。
numZeroes 件标记为 0 的物品。
numNegOnes 件标记为 -1 的物品。

现计划从这些物品中恰好选出 k 件物品。返回所有可行方案中，物品上所标记数字之和的最大值。

解：

1.关键：

（1）贪心，“能选1不选0，能选0不选-1”

2.代码：

class Solution {
public:int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {//贪心：if(k<=numOnes){return k;}else if(k<=numOnes + numZeros){return numOnes;}else{return numOnes - (k-numOnes-numZeros);}}
};

T2:质数减法运算

给你一个下标从 0 开始的整数数组 nums ，数组长度为 n 。

你可以执行无限次下述运算：

选择一个之前未选过的下标 i ，并选择一个 严格小于 nums[i] 的质数 p ，从 nums[i] 中减去 p 。

如果你能通过上述运算使得 nums 成为严格递增数组，则返回 true ；否则返回 false 。

严格递增数组 中的每个元素都严格大于其前面的元素

解：

1.关键：

（1）核心：“贪心算法” + 从后往前遍历，

(2)最后一个元素 nums[size-1] 不要动它！

(3)计算nums[i] - nums[i+1] = diff 得到需要的 j > diff ，为了尽可能的贪心，j应该从2开始去找尽可能小的素数，然后nums[i] - j 得到更新后的 “最贪心的nums[i]”

2.代码：

class Solution {
public:bool primeSubOperation(vector<int>& nums) {//特殊 ://贪心即可 ，建议从后往前遍历 ,最后一个元素尽可能的大 ，//前一个元素nums[i] 只要达到 < nums[i+1]的 尽可能大的 数值就可以了int size = nums.size(); //最后一个元素 不要动它//特殊:if(size == 1){return true;}for(int i=size-2;i>=0 ;i--){//让nums[i] - 一个素数p， 注意 ， 这个操作只能实行1次！！！if(nums[i] < nums[i+1]){//不用执行,continue;}else{//需要减去一个 尽可能小的素数int diff = nums[i] - nums[i+1];//找到一个 p > diff 刚好成立for(int j=2;j<nums[i];j++){if(is_prime(j) && j>diff ){//i 是一个素数 ,且 i>diffnums[i] -=j;break; //此时 nums[i] < nums[i+1]}}if(nums[i] < nums[i+1]){continue;}return false; //没有找到呗}}return true;}//--辅助函数 ， 判断一个 num是否为素数bool is_prime(int num){for(int i=2;i<=sqrt(double(num)); i++){if(num%i == 0){return false;}}return true;}
};

T3:使数组元素全部相等的最少操作次数

给你一个正整数数组 nums 。

同时给你一个长度为 m 的整数数组 queries 。第 i 个查询中，你需要将 nums 中所有元素变成 queries[i] 。你可以执行以下操作任意次：

将数组里一个元素增大或者减小 1 。

请你返回一个长度为 m 的数组 answer ，其中 answer[i]是将 nums 中所有元素变成 queries[i] 的最少操作次数。

注意，每次查询后，数组变回最开始的值。

解：

法一：

1.关键：

（1）这个题：看上去暴力求解似乎很简单，但是只能通过21个测试用例就会超时

(2)我当时采用了3种方式进行优化：

<1>利用一个map1<queries[i],cnt> 记录已经计算过的 queries[i]需要计算的次数

<2>对nums数组进行排序,虽然不知道这个排序怎么用

<3>分别计算max_cnt 和 min_cnt 对 “全部变成数组最大值和最小值”需要的cnt,

这么做到好处是：之后只要有queries[i ]比max_num大或者比 min_num小可以直接利用公式计算得到所需的次数

2.代码：（超时，只通过了24个测试用例）

class Solution {
public:vector<long long> minOperations(vector<int>& nums, vector<int>& queries) {//(1)排序：然后，优化，利用set找lower_boundsort(nums.begin(),nums.end());int size_nums = nums.size();int m = queries.size();vector<long long> ans(m,0);unordered_map<long long,long long> map1;//(2)queries[0] 和 queries[1] 手算一次//map1[queries[i]] = cnt //记录已经走访过的 次数long long sum = 0;long long sum_min = 0;long long sum_max = 0;long long  max_num = nums[size_nums-1];long long  min_num = nums[0]; //得到最大最小值for(int j=0;j<=size_nums-1;j++){sum+= abs(queries[0] - nums[j]);sum_min +=abs(min_num - nums[j]);sum_max += abs(max_num - nums[j]);}ans[0] = sum;map1[queries[0]] = ans[0];//特殊:if(m == 1){return ans;}//--一般:long long lower_b = queries[0];long long up_b = queries[0]; //分别 作为 计算差值的 下限 和 上限//只要是 queries[i] > lower_b 的， 所有 <=lower_b的nums[0-i]都可以  --不过 似乎 并不可行 ，除非 //这个简单啊，只要求abs(queries[i] - nums[j])之和即可//尼玛的 ，我就直到可能会超时://应该和 queries[i] 和 queries[i+1]之间有某种联系for(int i=1;i<m;i++){long long sum=0;//case1:queries[i] 已经计算过了if(map1.count(queries[i])){ans[i] = map1[queries[i]];continue;}//case2：这个queries 比max_num还要大 -- 可以直接得到else if(queries[i] >= max_num){ans[i] = sum_max + size_nums*(queries[i] - max_num);map1[queries[i]] = ans[i];continue;}//case3:这个queries 比min_num还要小--中间的就没办法了else if(queries[i] <= min_num){ans[i] = sum_min + size_nums*(min_num - queries[i]);map1[queries[i]] = ans[i];continue;}for(int j=0;j<=size_nums-1;j++) //如果是 中间值 就只能逐个计算了{sum+= abs(queries[i] - nums[j]);}ans[i] = sum;}return ans;}
};

法二：借鉴讨论区的思路:

1.关键：

（1）其实，我比赛的时候也想过这种类似的思路，但是！！！没有熟练掌握 “前缀和”数组这个东西，所以。。。

（2）这个公式，其实和我上面那个第3中优化的计算方式的思路是一直的，主要是找上下界

(3)最核心的一点，就是 “二分思想”，排序之后，一边全部小于等于 queries[i] ,另一边全部大于queries[i]，所以可以直接利用公式进行计算（一边全部加法，另一边全部减法）

1.5:发布题解的思路总结：

1.思路:

- (1)先排序

- (2)前缀和数组num_sum[i] :含义--从nums[0]一直求和到nums[i]

- (3)遍历queries[k]数组,可以利用二分查找在nums数组中找到“刚好大于”queries[k]的那个元素nums[i]，

这样，nums[0]-nums[i]均小于等于queries[k] 作为part1

nums[i+1] - nums[size-1] 均大于queries[k] 作为part2

然后，part1都是“加上一个数”变成的 queries[k] , part2都是“减去一个数”变成的queries[k],

注意：我的代码中初始num_sum加入了一个0，所以相当于从下标1开始用

- cnt_part1 = i*queries[k] - num_sum[i];

- cnt_part2 = (num_sum.back() - num_sum[i]) - (size - i)*queries[k];

总的来说，可以得到这个公式

- ans[i](第i个数需要的操作数) = cnt_part1 + cnt_part2

2.代码:

class Solution {
public:vector<long long> minOperations(vector<int>& nums, vector<int>& queries) {//（1）排序:sort(nums.begin() , nums.end());//(2)前缀和数组vector<long long> num_sum={0};for(int num: nums){num_sum.push_back(num+ num_sum.back());}//(3)二分 计算找到位置，计算ansvector<long long> ans;//遍历queriesfor(long long querie:queries){//第一步：找到第一个大于querie的元素 的下标//底层实现--二分查找！！//查找[first, last)区域中第一个大于 val 的元素。int i = upper_bound(nums.begin(),nums.end(),querie) - nums.begin();//公式计算:ans.push_back(i*querie - num_sum[i] + (num_sum.back() - num_sum[i])-(nums.size() - i)*querie);}return ans;}
};

T4:收集树中的全部金币

给你一个 n 个节点的无向无根树，节点编号从 0 到 n - 1 。给你整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间有一条边。再给你一个长度为 n 的数组 coins ，其中 coins[i] 可能为 0 也可能为 1 ，1 表示节点 i 处有一个金币。

一开始，你需要选择树中任意一个节点出发。你可以执行下述操作任意次：

收集距离当前节点距离为 2 以内的所有金币，或者
移动到树中一个相邻节点。

你需要收集树中所有的金币，并且回到出发节点，请你返回最少经过的边数。

如果你多次经过一条边，每一次经过都会给答案加一。

解：

先延申学习一下拓扑排序相关的题目: 这里引用一个csdn博主的总结，并自主去刷这些练习题

207 Course schedule √
210 course schedule 2 √
269 Alien dictionary ×
329 longest increasing path in a matrix ×
444 sequence reconstruction √
1203 sort items by groups respecting dependencies × 、、困难题--先放弃,先理解拓扑的思想

拓扑排序无关DFS/BFS 只要能做出来就行

都是高频题目
遇到这种题目，想一下：什么数据结构用的比较多？什么样的手法（技巧）用的比较多？有哪些需要注意的点？
数据结构：HashMap(HashSet)用的比较多经常用在图的存取和维护上（有向图就存一次，无向图存两个？）
这种题目的技巧就是：先存图，然后干该干的

技巧：
如何检测图中的环
用出度入度数组来控制一些东西（BFS）
用viisted来检测之前是不是走过（DFS）
图的表示可以用hashmap也可以用邻接矩阵来做
处度入度可以用数组或者用Hahsmap来做

总结：
对于题目中需要有排序的比如说谁在谁前面我们知道现在我们想要一条valid的路径什么什么之类的大致上就是拓扑排序了，拓扑排序的话，用BFS DFS都可以注意在此过程中需要维护的东西但是同时也要注意很多corner case，而且最开始的话一定要想清楚应该如何去做，要有一个清醒的认识 corner case要敏感。总之这类题很考验一个人是不是有清醒的头脑和把一个复杂问题进行分析并用代码实现，而且很好的处理那些corner case的问题。
————————————————
版权声明：本文为CSDN博主「Tech In Pieces」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44337445/article/details/110215057

……………………………………

leetcode 207课程表：

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

解：

法一：（纯靠个人独立思考，虽然只通过了47个测试用例，逻辑上还有一些问题，但是收获很大）

1.关键：

（1）利用一个map1<ai,cnt_restriction> 记录对于课程ai的先修课程的 “当前限制数目”

(2)如果 map1[pre[i][1]] == 0,说明这个课程的限制又少了一个 map1[pre[i][0]] --;

如果 map1[pre[i][1]] == 0 ，说明这个限制可以从pre中被拿掉了,erase掉这个位置的迭代器

2.代码：

class Solution {
public:bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {//判断是否 可以 完成所有课程的学习//bfs广度优先搜索一波 ， 走起(虽然深搜也可以)//（1）set容器记录所有已经学过的课程--能学都学一遍//(2)初始把不在bi中的课程全部学了//(3)一门课 可能有多个 先修课程！！！//(4)一个条件一旦满足 就从这个数组数组pre中删除掉//(5)一个非常绝妙的想法，map<ai,cnt_restriction>//每次得到一个bi 只要不在map中就相当于是 学过了这门课程//遍历一次pre，如果bi不在，就把这个元素erase掉//同时对应map[ai]--,//直接开while(1)循环，如果pre的size没有变化--直接false//如果size==0,true//tmd，要想学习课程5 必须先学习课程5 ，你。。你不想让我们学就直说，好吗？unordered_map<int,int> map1;int size_raw = prerequisites.size();for(int i=0;i<=size_raw-1;i++){//tmd的这种测试用例:if(prerequisites[i][0] == prerequisites[i][1]){return false;}map1[prerequisites[i][0]]++; //记录课程ai 对应的先驱课程数量}//特殊：//开启while(1)循环while(1){//遍历pre数组int size1 = prerequisites.size();//出口：if(size1 == 1 || size1 == 0) //1个限制相当于没有限制{return true;}//遍历vector<vector<int>> pre_tmp = prerequisites; //遍历pre_tmpfor(int i=0;i<=size1-1;i++){//？怎么让map1[ai]--呢？//怎么直到pre[i][1]这个条件被满足了呢?if(map1[pre_tmp[i][1]] == 0){//cout<<"i= "<<i<<endl; //这里有问题map1[pre_tmp[i][0]]--;}}int cnt = 0; //记录erase相差步数!!for(int i=0;i<=size1-1;i++){//--//cout<<"i = "<<i<<endl;//cout<<pre_tmp[i][0] <<"  :map1[pre_tmp[i][0]]"<<map1[pre_tmp[i][0]]<<endl;if(map1[pre_tmp[i][1]] == 0) //有可能是这里有问题{//拿到不是因为map1[bi]已经 == 0了吗？？？？？？？？？？？？//cout<<"来过吗"<<endl;//按道理来说 ，{1,4} 和 {2,4}这两对已经被满足了，map1[1] ==0 //也就是说//说明这个ai的限制bi都消去了，从而可以让这个ai干掉//cout<<"i = "<<i<<endl;cout<<i-cnt<<endl; //为什么是2呢？我尼玛prerequisites.erase(prerequisites.begin() + i -cnt);cnt++; //干掉的个数 ，同时 i是递增向后的//我去，干掉的位置不对!!!! i==2 和 i== 3进来的}}int size2 = prerequisites.size();if(size2 == size1) return false;//我认为这里就是最终的问题所在地}}};

法二：参考讨论区的一些思路

借鉴那位讲拓扑排序讲的很好：（总的来说就是记录入度，然后每次去寻找入度==0的课程）

每次只能选你能上的课
每次只能选入度为 0 的课，因为它不依赖别的课，是当下你能上的课。
假设选了 0，课 3 的先修课少了一门，入度由 2 变 1。
接着选 1，导致课 3 的入度变 0，课 4 的入度由 2 变 1。
接着选 2，导致课 4 的入度变 0。
现在，课 3 和课 4 的入度为 0。继续选入度为 0 的课……直到选不到入度为 0 的课。
这很像 BFS
让入度为 0 的课入列，它们是能直接选的课。
然后逐个出列，出列代表着课被选，需要减小相关课的入度。
如果相关课的入度新变为 0，安排它入列、再出列……直到没有入度为 0 的课可入列。
BFS 前的准备工作
每门课的入度需要被记录，我们关心入度值的变化。
课程之间的依赖关系也要被记录，我们关心选当前课会减小哪些课的入度。
因此我们需要选择合适的数据结构，去存这些数据：
入度数组：课号 0 到 n - 1 作为索引，通过遍历先决条件表求出对应的初始入度。
邻接表：用哈希表记录依赖关系（也可以用二维矩阵，但有点大）
key：课号
value：依赖这门课的后续课（数组）
怎么判断能否修完所有课？
BFS 结束时，如果仍有课的入度不为 0，无法被选，完成不了所有课。否则，能找到一种顺序把所有课上完。
或者：用一个变量 count 记录入列的顶点个数，最后判断 count 是否等于总课程数。

作者：笨猪爆破组
链接：https://leetcode.cn/problems/course-schedule/solutions/250377/bao-mu-shi-ti-jie-shou-ba-shou-da-tong-tuo-bu-pai-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解：（自己的思路总结）

1.关键：（相当于是一个 bfs深搜的思路）

（1）进行bfs需要用到的 4个数组结构:

<1>vector<int> enter_degree,记录当前所有课程的入度！需要在update函数中进行更新

<2>unordered_map<int,vector<int>> map1 记录受到class_bi 牵制的所有后续其它课程，用一个vector存储后续这些课程

<3>unordered_set<int> Set1,记录已经入队过的课程

<4>queue<int> Que1 ,存储当前入度==0 的所有课程

(2)cnt记录已经入队过的课程的数量

(3)bfs函数：

<1>先让开始所有可以入队的元素全部入队,

<2>让后！empty的while循环

（4）update函数：

<1>先将 Que1队列中的课程依次取出，同时让所有受到这些课程限制的课程i的 vec[i]--

<2>遍历依次 vec ，找出那些最新的变成 degree == 0 的课程（其实这里可以用2个队列的思想进行优化，算了，之后再说）

2.代码：

class Solution {
public:int cnt = 0; //记录已经遍历的 课程的数量unordered_set<int> Set1;bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {//直接利用 bfs进行求解 ， 每次找到那种 入度为0的课程//(1)需要的做好的准备工作:vector<int> enter_degree(numCourses,0); //记录 0-n-1号课程的入度unordered_map<int,vector<int>> map1;//选修课程 ai 必须先 选修课程 bi 所以 bi就是ai入度条件int size_p = prerequisites.size();for(int i=0;i<=size_p - 1;i++){//如果 记得 给下标为ai的课程的入度 加1enter_degree[prerequisites[i][0]]++;map1[prerequisites[i][1]].push_back(prerequisites[i][0]);}//现在enter_degree数组中已经记录 0 -n-1号课程的 所有 入度//利用一个map<class1,vector<依赖于class1的所有课程>>bfs(enter_degree,map1);if(cnt == numCourses){return true;}return false;}void bfs(vector<int>& vec,unordered_map<int,vector<int>>& map1){//设置一个队列,记录当前 入度 == 0 的课程//(0)初始：将所有入度 == 0 的课程全部入队，每次入队 cnt++queue<int> Que1;int n = vec.size();for(int i=0;i<=n-1;i++){if(vec[i] == 0){Que1.push(i); //找到一个入度 == 0的课程//利用set记录已经入队过的 课程Set1.insert(i);cnt++; //记录访问过的 课程}}//(1)while循环遍历while(!Que1.empty()){//直到队列为空update(Que1,vec,map1); // 更新队列}}void update(queue<int>& Que1,vector<int>& vec,unordered_map<int,vector<int>>& map1){//--每次从Que1中取出所有元素，作为这一层 遍历的 课程//然后 ， 让所有 受到这一门课程约束的 其它后续课程的vec入度减1//最后 ， 再次遍历 vec得到新的入度为0的课程入队同时cnt++while(!Que1.empty()){int class_bi = Que1.front();Que1.pop();//利用map1int size_tmp = map1[class_bi].size();for(int i=0;i<=size_tmp-1;i++){vec[map1[class_bi][i]]--; //入度减1}}//遍历vec，入队，cnt++//利用 一个 set记录已经入队过的 课程int n = vec.size();for(int i=0;i<=n-1;i++){if(vec[i] == 0 && Set1.count(i)==0){Set1.insert(i); // 记录已经入队的元素Que1.push(i);cnt++; //访问过的 课程++}}}
};

……………………………………………………

leetcode210 课程表II

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前必须先选修 bi 。

例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

解：

1.关键：

（1）这一题不过是在上一题的基础上多了一个ans数组记录加入队列次序罢了

代码中多出的 3句用！！！！！标记出来了

2.代码：

class Solution {
public:int cnt = 0; //记录已经遍历的 课程的数量unordered_set<int> Set1;vector<int> ans; //最终的 入队选修 次序 //!!!!!!!!!!!!!!!!!!vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {//直接利用 bfs进行求解 ， 每次找到那种 入度为0的课程//(1)需要的做好的准备工作:vector<int> enter_degree(numCourses,0); //记录 0-n-1号课程的入度unordered_map<int,vector<int>> map1;//选修课程 ai 必须先 选修课程 bi 所以 bi就是ai入度条件int size_p = prerequisites.size();for(int i=0;i<=size_p - 1;i++){//如果 记得 给下标为ai的课程的入度 加1enter_degree[prerequisites[i][0]]++;map1[prerequisites[i][1]].push_back(prerequisites[i][0]);}//现在enter_degree数组中已经记录 0 -n-1号课程的 所有 入度//利用一个map<class1,vector<依赖于class1的所有课程>>bfs(enter_degree,map1);if(cnt == numCourses){return ans;}return {}; //不能完成课程，返回 空数组}void bfs(vector<int>& vec,unordered_map<int,vector<int>>& map1){//设置一个队列,记录当前 入度 == 0 的课程//(0)初始：将所有入度 == 0 的课程全部入队，每次入队 cnt++queue<int> Que1;int n = vec.size();for(int i=0;i<=n-1;i++){if(vec[i] == 0){Que1.push(i); //找到一个入度 == 0的课程//利用set记录已经入队过的 课程Set1.insert(i);cnt++; //记录访问过的 课程ans.push_back(i); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}}//(1)while循环遍历while(!Que1.empty()){//直到队列为空update(Que1,vec,map1); // 更新队列}}void update(queue<int>& Que1,vector<int>& vec,unordered_map<int,vector<int>>& map1){//--每次从Que1中取出所有元素，作为这一层 遍历的 课程//然后 ， 让所有 受到这一门课程约束的 其它后续课程的vec入度减1//最后 ， 再次遍历 vec得到新的入度为0的课程入队同时cnt++while(!Que1.empty()){int class_bi = Que1.front();Que1.pop();//利用map1int size_tmp = map1[class_bi].size();for(int i=0;i<=size_tmp-1;i++){vec[map1[class_bi][i]]--; //入度减1}}//遍历vec，入队，cnt++//利用 一个 set记录已经入队过的 课程int n = vec.size();for(int i=0;i<=n-1;i++){if(vec[i] == 0 && Set1.count(i)==0){Set1.insert(i); // 记录已经入队的元素Que1.push(i);cnt++; //访问过的 课程++ans.push_back(i);  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!}}}
};

………………………………………………………………

T269 火星字典：（根据给出的 string的字典，对出现过的字母进行排序）

现有一种使用英语字母的火星语言，这门语言的字母顺序与英语顺序不同。

给你一个字符串列表 words ，作为这门语言的词典，words 中的字符串已经 按这门新语言的字母顺序进行了排序 。

请你根据该词典还原出此语言中已知的字母顺序，并 按字母递增顺序 排列。若不存在合法字母顺序，返回 "" 。若存在多种可能的合法字母顺序，返回其中 任意一种 顺序即可。

字符串 s 字典顺序小于 字符串 t 有两种情况：

在第一个不同字母处，如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前，那么 s 的字典顺序小于 t 。
如果前面 min(s.length, t.length) 字母都相同，那么 s.length < t.length 时，s 的字典顺序也小于 t 。

解：

1.一些想法：

然而，并不能直接上手

class Solution {

public:

string alienOrder(vector<string>& words) {

//这是一个很明显的拓扑排序的问题 , 然而转化为代码的语言并不是那么容易

//(1)最朴素的想法就是利用双层循环，+ 一个map记录任意 2个元素的大小关系

//双层循环：从第一个string 依次和后面的 string进行比较

//既然是字典的话，好吧，还是有可能有相同的 string的

//这个map就是之前那个前置map<key, vector< int > > 所有受到key牵制的课程

//一个set容器，

}

};

那就先pass好了!!!!!!!!!!!!!!!!!!!!!!!!!!

………………………………………………………………………………………………

T444:序列重建

给定一个长度为 n 的整数数组 nums ，其中 nums 是范围为 [1，n] 的整数的排列。还提供了一个 2D 整数数组 sequences ，其中 sequences[i] 是 nums 的子序列。
检查 nums 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列，并且所有序列 sequences[i] 都是它的子序列。对于给定的数组 sequences ，可能存在多个有效的 超序列 。

例如，对于 sequences = [[1,2],[1,3]] ，有两个最短的 超序列 ，[1,2,3] 和 [1,3,2] 。
而对于 sequences = [[1,2],[1,3],[1,2,3]] ，唯一可能的最短 超序列 是 [1,2,3] 。[1,2,3,4] 是可能的超序列，但不是最短的。

如果 nums 是序列的唯一最短 超序列 ，则返回 true ，否则返回 false 。
子序列 是一个可以通过从另一个序列中删除一些元素或不删除任何元素，而不改变其余元素的顺序的序列。

解：

1.关键：

(1)依然是考虑广度优先搜索 bfs的思想

(2)这里的数据容器是借鉴的答案的思想：非常巧妙!

<1>vector<int> vec1（n+1) ：只是用下标1-n存储 1-n号元素当前被牵制的数量(也就是入度的大小)

<2>vector<unordered_set<int>> vec2(n+1): 只使用下标 1-n,用于存放对应数字可以牵制其它所有的数字,都存放到一个set容器中

(3)初始操作：遍历一次二维数组 sequences，然后得到 vec1 和 vec2的初始条件

(4)设置一个队列（bfs的标配）:queue<int>,然后初始找出所有入度为0的元素 ---入队

(5)开启 while循环广搜:

<1>先判断队列中的元素个数是否大于1 , 若是，直接false

<2>取出 front元素 num，然后出队

<3>注意：下一次只有被 num牵制的元素入度有可能减少为0

!!!所以，只要遍历 vec2[num] 这个set容器即可

2.这么做的合理性：

（1）一旦那一次有>1个元素的入度==0 ，就会造成拓扑排序产生多种可能

(2)注意：给出的nums序列一定是一种可能的 “超序列”, 所以，只要证明构造拓扑排序的 “唯一性”即可

3.代码:

class Solution {
public:bool sequenceReconstruction(vector<int>& nums, vector<vector<int>>& sequences) {//自己构造一个最短超序列，然后和nums进行比较//1.先考虑特殊情况:int n = nums.size();//原来nums的长度就是n，就是1-n的一种排列//如果都为空，false//如果有 不在1-n范围的 数字--false//如果有1-n中的数字没有出现--false//算了，先考虑一般case//先不考虑是否唯一，只要是 这些子序列的 最短超序列就完事了//好了，思路已经有了：//就只需要利用 拓扑排序 ， //<1>容器vec（n+1，0）：记录数字1-n的 入度//<2>map<key,vec<int>>:记录所有 被数字key约束的 下一个数组，存储到一个vec中//通过bfs广搜，每次找到 入度为0的而且没有在set中的节点 ，//如果有 多个 -- 直接false ， 否则去找下一个，cnt == n 才能返回true//而且数字必须要 1-n 的范围之内//vec需要更新，但是 map不需要更新vector<int> vec1(n+1,0);vector<unordered_set<int>> vec2(n+1);//unordered_map<int,vector<int>> map1;//先不要管 这个 nums序列，先直接看sequences数组中的 那些子序列int size_i = sequences.size();//我觉得官方题解 用到 2个数据容器非常巧妙://一个indegree数组vec用于存放1-n数字的入度//一个vec<set<int>>（n+1）容器，用于存放1-n号元素牵制的后续元素//初始条件，得到vec1 和 vec2 的初始情况for(auto sequen: sequences){for(int i=1;i<sequen.size();i++){int prev = sequen[i-1];int next = sequen[i];//next元素 受到 prev元素的 牵制if(!vec2[prev].count(next)){vec2[prev].insert(next); //prev元素 可以 牵制next元素vec1[next]++; //next元素受到的 牵制 ++}}}//开始进行bfs广搜queue<int> Que1; // 队列--将入度为0的元素入队for(int i =1 ;i<=n;i++){if(vec1[i] == 0){Que1.push(i);}}//循环广搜， 一旦queue中有多个元素 ，直接false//先判断队列中的元素是否>1 , //然后 取出那个元素，//最后遍历vec2[front]就是队列开头元素 牵制的所有其它元素，//只有它们的 vec1 才可能在--之后变成0while(!Que1.empty()){//(1)判断是否有 多个 元素if(Que1.size() > 1){return false;}//(2)取出 front元素int num = Que1.front();Que1.pop();//(3)从否遍历 vec2[num]for(auto item:vec2[num]){vec1[item]--;if(vec1[item] == 0){Que1.push(item);}}}return true;}
};

…………………………………………………………………………………………

好了，“言归正传”，我们还是回到那个收集树中的金币这个问题上面来:

解：（几乎都是借鉴的那个艾府的解答）

1.关键：

（1）数据结构选择:

vec1<vector<int>> : 一个二维数组，用于存放一个节点所连接的所有其它节点

vec2<int> : 一个一维数组，用于存放0-n-1号节点的度数

(2)通过遍历egdes这个二维数组--进行“构图”-构建一个无向图:

<1>更新每个节点的度数

<2>构建 “邻接表”--记录每个节点相邻的节点

(3)利用拓扑排序进行 “剪枝”操作--去掉那些没有金币的叶子节点:

好吧，本质上就是让那些和叶子节点有连接的节点的度数 “减1”，同时判断是否会产生新的叶子新的叶子节点---需要使用到一个queue<int> 队列

(4)让所有有金币的叶子节点全部加入到队列中，这些节点的入队时间设置为0，当然，我们会初始化一个大小为n的一维数组time，用于记录那些没有被剪掉的节点的入队时间(反正，有金币的叶子节点的入队时间都是0)

(5)从任意一个有金币的叶子节点出发，再次进行拓扑排序，利用队列，每次遇到的节点的度数都要"减1",从而方便下一次探索

2.代码：（我的代码好像还是有个地方有问题，但是没找到，就先放到 “笔记”中了）

这里直接把 “艾符”的代码给出来了

class Solution {
public:int collectTheCoins(vector<int> &coins, vector<vector<int>> &edges) {int n = coins.size();vector<vector<int>> g(n);int deg[n]; memset(deg, 0, sizeof(deg));for (auto &e: edges) {int x = e[0], y = e[1];g[x].push_back(y);g[y].push_back(x); // 建图++deg[x];++deg[y];}// 用拓扑排序「剪枝」：去掉没有金币的子树queue<int> q;for (int i = 0; i < n; ++i)if (deg[i] == 1 && coins[i] == 0) // 无金币叶子q.push(i);while (!q.empty()) {int x = q.front();q.pop();for (int y: g[x])if (--deg[y] == 1 && coins[y] == 0)q.push(y);}// 再次拓扑排序for (int i = 0; i < n; ++i)if (deg[i] == 1 && coins[i]) // 有金币叶子q.push(i);if (q.size() <= 1) return 0; // 至多一个有金币的叶子，直接收集int time[n]; memset(time, 0, sizeof(time));while (!q.empty()) {int x = q.front();q.pop();for (int y: g[x])if (--deg[y] == 1) {time[y] = time[x] + 1; // 记录入队时间q.push(y);}}// 统计答案int ans = 0;for (auto &e: edges)if (time[e[0]] >= 2 && time[e[1]] >= 2)ans += 2;return ans;}
};作者：灵茶山艾府
链接：https://leetcode.cn/problems/collect-coins-in-a-tree/solutions/2191371/tuo-bu-pai-xu-ji-lu-ru-dui-shi-jian-pyth-6uli/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

总的来说：

这一次周赛比上一次有所进步，不过呢，第3题因为算法的原因，一直超时,就是那个前缀和数组的问题，第4题的话，对于“拓扑排序”这个知识点之前没有进行系统的学习，但是，收获很多，包括第一次认识到“剪枝”的一种实现方法,前缀和数组的使用，拓扑排序问题的识别

第二次 leetcode周赛总结(开心！多总结，多进步)相关推荐

宝宝也能看懂的 leetcode 周赛 - 174 - 3
1339. 分裂二叉树的最大乘积 Hi 大家好,我是张小猪.欢迎来到『宝宝也能看懂』系列之 leetcode 周赛题解. 这里是第 174 期的第 3 题,也是题目列表中的第 1339 题 -- 『分 ...
我也是LeetCode周赛“三道题选手”啦第270场周赛
第270场周赛小结我的Weekly Contest 270战况什么是LeetCode周赛? show my code! 复盘解决Hard题我的Weekly Contest 270战况参加周赛有 ...
C/C++描述 LeetCode 周赛第199场周赛（阿里云专场）
C/C++描述 LeetCode 周赛第199场周赛(阿里云专场) 大家好,我叫亓官劼(qí guān jié ),在CSDN中记录学习的点滴历程,时光荏苒,未来可期,加油~博主目前仅在CSDN ...
[LeetCode周赛复盘] 第 314 场周赛20221009
[LeetCode周赛复盘] 第 314 场周赛20221009 一.本周周赛总结二. [Easy] 6201. 找出前缀异或的原始数组 1. 题目描述 2. 思路分析 3. 代码实现三.[Eas ...
leetcode周赛5465. 子树中标签相同的节点数
leetcode周赛5465. 子树中标签相同的节点数给你一棵树(即,一个连通的无环无向图),这棵树由编号从 0 到 n - 1 的 n 个节点组成,且恰好有 n - 1 条 edges .树的根节 ...
[LeetCode周赛复盘] 第 89 场双周赛20221015
[LeetCode周赛复盘] 第 89 场双周赛20221015 一.本周周赛总结二. [Easy] 6208. 有效时间的数目 1. 题目描述 2. 思路分析 3. 代码实现三.[Medium] ...
[LeetCode周赛复盘] 第 324 场周赛20221218
[LeetCode周赛复盘] 第 324 场周赛20221218 一.本周周赛总结二. [Easy] 6265. 统计相似字符串对的数目 1. 题目描述 2. 思路分析 3. 代码实现三.[Med ...
[LeetCode周赛复盘] 第 310 场周赛20220911
[LeetCode周赛复盘] 第 310 场周赛20220911 一.本周周赛总结二. [Easy] 6176. 出现最频繁的偶数元素 1. 题目描述 2. 思路分析 3. 代码实现三.[Medi ...
leetcode周赛第二题6230. 长度为 K 子数组中的最大和
题目: 给你一个整数数组 nums 和一个整数 k .请你从 nums 中满足下述条件的全部子数组中找出最大子数组和: 子数组的长度是 k,且子数组中的所有元素各不相同 . 返回满足题面要求的最大 ...

第二次 leetcode周赛总结(开心！多总结，多进步)

第二次 leetcode周赛总结(开心！多总结，多进步)相关推荐

最新文章

热门文章