LeetCode第269场周赛题解

最新推荐文章于 2022-06-12 01:41:38 发布

Meet.

最新推荐文章于 2022-06-12 01:41:38 发布

阅读量330

点赞数

分类专栏： LeetCode 文章标签： leetcode c++ 算法

本文链接：https://blog.csdn.net/qq_44867112/article/details/121595207

版权

LeetCode 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

本文介绍了三道LeetCode周赛题目，包括数组排序后查找目标下标、计算半径为k的子数组平均值以及移除数组中的最大值和最小值。每道题都提供了思路和代码实现，涉及动态维护区间和、双指针以及搜索算法等技巧。

摘要由CSDN通过智能技术生成

2021.11.28LeetCode第269场周赛

2089.找出数组排序后的目标下标

思路

首先将数组从小到大排序，然后遍历一遍找到值为target的下标即可。

代码

class Solution {
public:
    vector<int> targetIndices(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<int> ans;
        for (int i = 0; i < nums.size(); i ++ )
            if (nums[i] == target)
                ans.push_back(i);
        return ans;
    }
};

2090.半径为 k 的子数组平均值

思路

动态维护区间和
类似快慢指针的思想让快指针先走k步
然后枚举到当前数时需要加上nums[i + k] 减去nums[i - k -1] 即是半径为k的区间和再除以长度即可

代码

class Solution {
public:
    vector<int> getAverages(vector<int>& nums, int k) {
        vector<int> ans;
        int n = nums.size();
        long long sum = 0;
        for (int i = 0; i < min(k, n); i ++ )
            sum += nums[i];
        for (int i = 0; i < n; i ++ ) {
            if (i + k < n)
                sum += nums[i + k];
            if (i - k - 1 >= 0)
                sum -= nums[i - k - 1];
            if (i < k || i + k >= n)
                ans.push_back(-1);
            else 
                ans.push_back(sum / (k * 2 + 1));
        }
        return ans;
    }
};

2091.从数组中移除最大值和最小值

思路

找出最小值与最大值所在的下标
共有三种方式移除这两个数

全部从左边出
全部从右边出
分别从左右出

取三种情况的最小值即可

代码

class Solution {
public:
    int minimumDeletions(vector<int>& nums) {
        int a, b;
        int ma = -1e6, mi = 1e6;
        int n = nums.size();
        for (int i = 0; i < n; i ++ ) {
            if (nums[i] > ma) {
                a = i;
                ma = nums[i];
            }
            if (nums[i] < mi) {
                b = i;
                mi = nums[i];
            }
        }
        if (a > b)
            swap(a, b);
        int ans = b + 1;
        ans = min(ans, n - a);
        ans = min(ans, a + 1 + n - b);
        return ans;
    }
};

2092.找出知晓秘密的所有专家

思路

双指针+BFS
将所有知晓秘密的专家编号放在集合中
先按时间顺序对meetings排序
用双指针找出时间相同的所有会议
有会议的专家用领接矩阵存储
再将当前所有会议中知晓秘密的专家压入队列更新所有被传播的专家即可

代码

class Solution {
public:
    vector<int> findAllPeople(int n, vector<vector<int>>& meetings, int firstPerson) {
        unordered_set<int> se;
        se.insert(0);
        se.insert(firstPerson);
        sort(meetings.begin(), meetings.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[2] < b[2];
        });

        int m = meetings.size();
        for (int i = 0; i < m;) {
            int j = i + 1;
            while (j < m && meetings[i][2] == meetings[j][2]) j ++ ;
            queue<int> q;
            unordered_set<int> s;
            unordered_map<int, vector<int>> mp;
            for (int k = i; k < j; k ++ ) {
                int x = meetings[k][0], y = meetings[k][1];
                mp[x].push_back(y);
                mp[y].push_back(x);
                if (se.count(x) && !s.count(x)) {
                    s.insert(x);
                    q.push(x);
                }
                if (se.count(y) && !s.count(y)) {
                    s.insert(y);
                    q.push(y);
                }
            }
            while (q.size()) {
                auto t = q.front();
                q.pop();
                for (int x : mp[t]) {
                    se.insert(x);
                    if (!s.count(x)) {
                        q.push(x);
                        s.insert(x);
                    }
                }
            }
            i = j;
        }
        
        vector<int> ans;
        for (auto i : se)
            ans.push_back(i);
        return ans;
    }
};