Leetcode 第 125 场双周赛题解

Leetcode 第 125 场双周赛题解

题目1：3065. 超过阈值的最少操作数 I

思路

排序，lower_bound(nums.begin(), nums.end(), k) - nums.begin() 即为答案。

代码

/*
 * @lc app=leetcode.cn id=3065 lang=cpp
 *
 * [3065] 超过阈值的最少操作数 I
 */

// @lc code=start
class Solution
{
public:
    int minOperations(vector<int> &nums, int k)
    {
        sort(nums.begin(), nums.end());
        return lower_bound(nums.begin(), nums.end(), k) - nums.begin();
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(nlogn)，其中 n 是数组 nums 的元素个数。

空间复杂度：O(1)。

题目2：3066. 超过阈值的最少操作数 II

思路

用一个最小堆模拟。

代码

typedef long long LL;

class Solution
{
public:
    int minOperations(vector<int> &nums, int k)
    {
        priority_queue<LL, vector<LL>, greater<>> pq;
        for (int &num : nums)
            pq.push((LL)num);

        int ans = 0;
        while (pq.top() < k)
        {
            LL x = pq.top();
            pq.pop();
            LL y = pq.top();
            pq.pop();
            pq.push(min(x, y) * 2 + max(x, y));
            ans++;
        }
        return ans;
    }
};

复杂度分析

时间复杂度：O(nlogn)，其中 n 是数组 nums 的元素个数。

空间复杂度：O(n)，其中 n 是数组 nums 的元素个数。

题目3：3067. 在带权树网络中统计可连接服务器对数目

思路

枚举每一个节点，计算通过该节点可连接的服务器对的数目。

举例，把 0 作为树根计算：

代码

/*
 * @lc app=leetcode.cn id=3067 lang=cpp
 *
 * [3067] 在带权树网络中统计可连接服务器对数目
 */

// @lc code=start
class Solution
{
public:
    vector<int> countPairsOfConnectableServers(vector<vector<int>> &edges, int signalSpeed)
    {
        // 对于树，节点数 = 边数 + 1
        int n = edges.size() + 1;
        // 建图
        vector<vector<pair<int, int>>> g(n);
        for (auto &edge : edges)
        {
            int x = edge[0], y = edge[1], weight = edge[2];
            g[x].push_back({y, weight});
            g[y].push_back({x, weight});
        }

        function<int(int, int, int)> dfs = [&](int x, int father, int pathSum) -> int
        {
            int cnt = pathSum % signalSpeed == 0;
            for (auto &[y, weight] : g[x])
            {
                if (y != father)
                    cnt += dfs(y, x, pathSum + weight);
            }
            return cnt;
        };

        vector<int> ans(n);
        for (int i = 0; i < n; i++)
        {
            int sum = 0; // 前面遍历的子树中符合要求的节点总数
            // 遍历子节点
            for (auto &[y, weight] : g[i])
            {
                int cnt = dfs(y, i, weight);
                // 乘法原理
                ans[i] += cnt * sum;
                sum += cnt;
            }
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n²)，其中 n 是树的节点个数。

空间复杂度：O(n)，其中 n 是树的节点个数。

题目4：3068. 最大节点价值之和

思路

树形 DP。

用「选或不选」思考。

对于以 x 为根的子树，考虑 x 和它的儿子 y 之间的边是否操作。

• 定义 f[x][0] 表示 x 操作偶数次时，子树 x 的除去 x 的最大价值和。
• 定义 f[x][1] 表示 x 操作奇数次时，子树 x 的除去 x 的最大价值和。

初始化 f[x][0]=0, f[x][1]=−∞。遍历并递归计算 x 的所有儿子，设当前遍历到的儿子为 y，

两种情况取最大值，有：

​

注意这两个转移是同时发生的。

最后答案为根节点对应的 r0。

代码

/*
 * @lc app=leetcode.cn id=3068 lang=cpp
 *
 * [3068] 最大节点价值之和
 */

// @lc code=start
class Solution
{
public:
    long long maximumValueSum(vector<int> &nums, int k, vector<vector<int>> &edges)
    {
        int n = nums.size();
        vector<vector<int>> g(n);
        for (auto &e : edges)
        {
            int x = e[0], y = e[1];
            g[x].push_back(y);
            g[y].push_back(x);
        }

        function<pair<long long, long long>(int, int)> dfs = [&](int x, int father) -> pair<long long, long long>
        {
            long long f0 = 0, f1 = LLONG_MIN; // f[x][0] 和 f[x][1]
            for (auto &y : g[x])
            {
                if (y != father)
                {
                    auto [r0, r1] = dfs(y, x);
                    long long t = max(f1 + r0, f0 + r1);
                    f0 = max(f0 + r0, f1 + r1);
                    f1 = t;
                }
            }
            return {max(f0 + nums[x], f1 + (nums[x] ^ k)), max(f1 + nums[x], f0 + (nums[x] ^ k))};
        };
        
        return dfs(0, -1).first;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n)，其中 n 为数组 nums 的长度。

空间复杂度：O(n)，其中 n 为数组 nums 的长度。