力扣第 304 场周赛复盘_力扣周赛预测

1.使数组中所有元素都等于零

6132. 使数组中所有元素都等于零

题目描述

思路分析

这道题很简单，因为不断要拿最小的数将所有数减少，那么我们只需要看有多少个不同的数，因为不同的数相减始终会出现差值，那么最大的数肯定是最后一个减

AC代码

class Solution {
public:
    int minimumOperations(vector<int>& nums) {
        set<int> res;
        for(auto it:nums)
            if(it>0)res.insert(it);
        return res.size();
    }
};
1
2
3
4
5
6
7
8
9

2.分组的最大数量

6133. 分组的最大数量

题目描述

思路分析

我们可以贪心的知道，从小到大排序，按照顺序第一组1个、第二组2个以此类推，当最后一组不足个数时，将其放在前面一组即可。那么就是计算一个数被分成最多的组数。

AC代码

class Solution {
public:
    int maximumGroups(vector<int>& grades) {
        int index=0,size=grades.size();
        while(size>0)
            size-=++index;
            
        if(size<0)return index-1;
        return index;
    }
};
1
2
3
4
5
6
7
8
9
10
11

3.找到离给定两个节点最近的节点

6134. 找到离给定两个节点最近的节点

题目描述

思路分析

首先简化思路，如何求出一个点到达每个结点的距离？
1.因为每个结点只能有一个出边，所以我们可以使用dfs求出路径
2.可能有环，我们用数组保存到每个点的距离，如果当前点访问过，我们就可以退出，就可以防止环
然后他只是求两个结点的的共同到达的位置，所以我们只需要两个dfs即可
最后用两个变量维护答案，遍历所有点如果能够到达这个点进行答案维护

AC代码

class Solution {
public:
    int closestMeetingNode(vector<int>& edges, int node1, int node2) {
        if(node1==node2)return node1; // 如果相等就是当前结点
        int dp1[100010],dp2[100010];
        memset(dp1,0,sizeof(dp1)),memset(dp2,0,sizeof(dp2));
        // 预处理node1
        int dis=1,node=node1;
        while(node!=-1)
        {
            if(dp1[node]>0)break;
            dp1[node]=dis++;
            node=edges[node];
        }
        // 预处理node2
        dis=1,node=node2;
        while(node!=-1)
        {
            if(dp2[node]>0)break;
            dp2[node]=dis++;
            node=edges[node];
        }
        // 遍历所有结点
        int maxnode=-1,maxnum=0x3f3f3f3f;
        for(int i=0;i<edges.size();i++)
        {
            if(dp1[i]==0||dp2[i]==0)continue;
            int mid=max(dp1[i]-1,dp2[i]-1);
            if(mid<maxnum)maxnode=i,maxnum=mid;
        } 
        return maxnode;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

4.图中的最长环

6135. 图中的最长环

题目描述

思路分析

同样因为只能有一个出点，所以一直循环找下去就可能找到终点或者环。
遍历每个结点作为起点dfs，如果碰到遍历过，则就不需要遍历了
如果碰到是环，因为我们用数组维护了当前点到起点的距离，所以我们用距离差求出环的长度
ps：这只是个人思路，代码相对来说也比较长

AC代码

class Solution {
public:
    int visit[100010]; // 保存到初始点的距离和是否访问过
    int maxlen=-1; // 维护最长环的答案
    void dfs(vector<int>& edges,int node)
    {
        if(visit[node]>0)return;// 如果访问过
        set<int> s; // 作用：检查是否有环
        visit[node]=1;
        s.insert(node);
        
        int cur=1,pre=node;
        int next=edges[node];
        while(next!=-1) // dfs
        {
            if(visit[next]>0) // 如果已经访问过
            {
                int size=s.size();
                s.insert(next);
                // 判断是否是环
                if(size==s.size())maxlen=max(maxlen,visit[pre]-visit[next]+1);
                return;
            }
            s.insert(next);
            visit[next]=++cur;
            pre=next;
            next=edges[next];
        }
        return;
    }
    int longestCycle(vector<int>& edges) {
        memset(visit,0,sizeof(visit));
        for(int i=0;i<edges.size();i++)
        {
            dfs(edges,i);
        }
        return maxlen;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

总结感想

这次也是最后都写完了，感觉相对来说不太很难，就是跟着题目的思路写就行了感觉也没太用到什么算法之类的，也可能就是自己思路没对应的算法。第三题因为题目看恍惚了写了半天才发现自己想错了，以后还是多注意，当时我都以为题目有问题。