第 392 场 LeetCode 周赛题解

最新推荐文章于 2024-08-21 10:11:50 发布

xhchen2024

最新推荐文章于 2024-08-21 10:11:50 发布

阅读量629

点赞数 29

分类专栏： LeetCode 文章标签： leetcode 算法模拟贪心排序并查集脑筋急转弯

本文链接：https://blog.csdn.net/weixin_40519680/article/details/137579916

版权

LeetCode 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

文章介绍了四个与IT技术相关的问题解决方案：1)使用贪心策略求最长严格递增或递减子数组；2)贪心法调整字符串以满足字典序和距离约束；3)通过排序和模拟操作找到使数组中位数等于给定值的最少操作数；4)利用并查集在带权图中计算旅途的最小代价。

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

A 最长的严格递增或递减子数组

在这里插入图片描述

模拟：实现可以只求最长严格递增子数组即可

class Solution {
  public:
    int longestIncrementsubarray(vector<int> &nums) {
        int n = nums.size();
        int res = 1;
        for (int i = 0, j = 0; i < n; i = ++j) {
            while (j + 1 < n && nums[j + 1] > nums[j])
                j++;
            res = max(res, j - i + 1);
        }
        return res;
    }
    int longestMonotonicSubarray(vector<int> &nums) {
        int res = longestIncrementsubarray(nums);
        reverse(nums.begin(), nums.end());
        res = max(res, longestIncrementsubarray(nums));
        return res;
    }
};

B 满足距离约束且字典序最小的字符串

在这里插入图片描述

贪心：尽可能将先前面的字符变小

class Solution {
  public:
    string getSmallestString(string s, int k) {
        for (int i = 0; i < s.size() && k; i++) {
            if (s[i] != 'a') {//s[i]可以变小
                int d = min(k, min(s[i] - 'a', 26 - (s[i] - 'a')));//s[i]的操作数
                k -= d;
                s[i] = min(s[i] - d, 'a' + (s[i] - 'a' + d) % 26);
            }
        }
        return s;
    }
};

C 使数组中位数等于 K 的最少操作数

在这里插入图片描述

排序+模拟：先将数组排序，设中位数的下标为 $mi d$ ， $n u m s [mi d]$ 需要 $∣ k - n u m s [mi d] ∣$ 次操作变为 $k$ 。顺序枚举 $n u m s [mi d + 1, n u m . s i ze () - 1]$ ，若 $n u m s [i]$ 比 $n u m s [i - 1]$ 小，则将 $n u m s [i]$ 变为 $n u m s [i - 1]$ 。逆序枚举 $n u m s [0, mi d - 1]$ ，若 $n u m s [i]$ 比 $n u m s [i + 1]$ 大，则将 $n u m s [i]$ 变为 $n u m s [i + 1]$ 。

class Solution {
  public:
    long long minOperationsToMakeMedianK(vector<int> &nums, int k) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        int mid = n / 2;
        long long res = abs(nums[mid] - k);
        nums[mid] = k;
        for (int i = mid + 1; i < n; i++) {
            if (nums[i] < nums[i - 1]) {
                res += nums[i - 1] - nums[i];
                nums[i] = nums[i - 1];
            }
        }
        for (int i = mid - 1; i >= 0; --i) {
            if (nums[i] > nums[i + 1]) {
                res += nums[i] - nums[i + 1];
                nums[i] = nums[i + 1];
            }
        }
        return res;
    }
};

D 带权图里旅途的最小代价

在这里插入图片描述

脑筋急转弯+并查集：先用并查集维护哪些节点在同一个连通分支，在同一分支的 $s_i$ 和 $t_i$ 的最小代价即为所在连通分支上所有边的按位与。

class Solution {
  public:
    vector<int> p;
    vector<int> cost;
    int find(int x) {//查找x所在分支的根节点
        if (p[x] == x)
            return x;
        return p[x] = find(p[x]);
    }
    void comb(int x, int y) {//合并x和y所在的分支
        int xx = find(x);
        int yy = find(y);
        if (xx != yy)
            p[yy] = xx;
    }
    vector<int> minimumCost(int n, vector<vector<int>> &edges, vector<vector<int>> &query) {
        p.resize(n);
        iota(p.begin(), p.end(), 0);//初始化：每个节点为一个分支
        for (auto &edge : edges)
            comb(edge[0], edge[1]);
        cost = vector<int>(n, (1 << 30) - 1);
        for (auto &edge : edges) {
            int root = find(edge[0]);
            cost[root] = cost[root] & edge[2];
        }
        vector<int> res;
        for (auto &q : query) {
            int r1 = find(q[0]), r2 = find(q[1]);
            if (r1 != r2)
                res.push_back(-1);
            else
                res.push_back(cost[r1]);
        }
        return res;
    }
};