LeetCode 305 场单周赛 和 84 场双周赛总结反思

一、LeetCode 305

1、2367.算术三元组的数目

（1）原题链接：力扣https://leetcode.cn/problems/number-of-arithmetic-triplets/

（2）解题思路：

        由于题目的数据范围比较小，所以我们可以直接暴力找满足条件的三元组。

（3）代码：

class Solution {
public:
    int arithmeticTriplets(vector<int>& nums, int diff) {
        int cnt = 0;
        int n = nums.size();
        for(int i = 0; i < n - 2; i ++ ) {
            for(int j = i + 1; j < n - 1; j ++) {
                for(int k = j + 1; k < n; k ++) {
                    if(nums[j] - nums[i] != diff) continue;
                    else {
                        if(nums[k] - nums[j] == diff) cnt ++;
                    }
                }
            }
        }
        
        return cnt;
    }
};

2、2368.首先条件下可到达节点的数目

（1）原题链接：力扣https://leetcode.cn/problems/reachable-nodes-with-restrictions/

（2）解题思路：

        首先用哈希表neibor记录每个结点的邻居结点；

        然后用集合visited记录访问过的结点，一开始就把受限的结点全部放入visited中；

        然后把第0个结点压入队列进行正常的广度优先搜索，每次都将该结点的未被访问的邻居压入队列，统计个数即可。

（3）代码：

class Solution {
public:
    unordered_map<int, vector<int>> neibor;
    unordered_set<int> visited;  
    int reachableNodes(int n, vector<vector<int>>& edges, vector<int>& restricted) {
        for(vector<int> vec : edges){
            neibor[vec[0]].push_back(vec[1]);
            neibor[vec[1]].push_back(vec[0]);
        }

        for(int restri : restricted){
            visited.insert(restri);
        }

        queue<int> bfs;
        bfs.push(0);
        int res = 0;

        while(!bfs.empty()){
            int nowVisit = bfs.front();
            visited.insert(nowVisit);
            bfs.pop();
            res ++;

            for(int next : neibor[nowVisit]){
                if(!visited.count(next)){
                    bfs.push(next);
                }
            }
        }

        return res;
    }
};

二、LeetCode 84

1、2363.合并相似的物品

（1）原题链接：力扣https://leetcode.cn/problems/merge-similar-items/

（2）解题思路：

        用哈希表计数后，然后再存入到数组中，由于map是有序的，所以直接输出结果即可。

（3）代码：

class Solution {
public:
    vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
        vector<vector<int>> ret;

        map<int, int> mp;
        for(auto& it: items1) {
            mp[it[0]] += it[1];
        }
        for(auto& it: items2) {
            mp[it[0]] += it[1];
        }

        for(auto& [k, v]: mp) {
            ret.push_back({k, v});
        }
        return ret;
    }
};

2、2364.统计坏数对的数目

（1）原题链接：力扣https://leetcode.cn/problems/count-number-of-bad-pairs/

（2）解题思路：

        首先，坏数对的数目就是所有数对的数目减去满足 i < j && j - i == nums[j] - nums[i] 的数对的数目。移项后变为 nums[i] - i == nums[j] - j ，因此我们是需要用哈希表去存有多少个满足条件的 i ,然后再减去满足条件的 j 的数目即可。

（3）代码：

class Solution {
public:
    long long countBadPairs(vector<int>& nums) {
        int n = nums.size();
        long long ans = 1LL * n * (n - 1) / 2;
        unordered_map<int, int> mp;

        for (int i = 0; i < n; i ++ ) {
            int tmp = nums[i] - i;
            ans -= mp[tmp];
            mp[tmp] ++;
        }

        return ans;
    }
};

 

3、2365.任务调度器II

（1）原题链接：力扣https://leetcode.cn/problems/task-scheduler-ii/

（2）解题思路：

        首先，用哈希表记录某个任务下次可以开始的最早时间。然后，当前任务不在哈希表中则表示从来没有做过该任务，time++增长一天，同时将该任务下次最早开始时间time + space + 1加入到哈希表中。最后，当前任务在哈希表中时，时间满足当前任务最早开始时间的时间增长一天，将哈希表该任务最早开始时间更新为time + space + 1 ；时间不满足当前任务最早开始时间时，此时我们需要将时间推进至该任务最早开始时间; 同时将哈希表该任务最早开始时间更新为time +space + 1。

（3）代码：

class Solution {
public:
    long long taskSchedulerII(vector<int>& tasks, int space) {
        int n = tasks.size();
        long long time = 0;
        unordered_map<long long, long long> last;

        for (int i = 0; i < n; ++i) {
            int cur = tasks[i];
            if (last.count(cur) == 0 || last[cur] == 0) {
                time++;
                last[cur] = time + space + 1;
            } 
            else {
                if (time >= last[cur]) 
                    ++time;
                else 
                    time = last[cur];
                    
                last[cur] = time + space + 1; 
            }
        }

        return time;
    }
};