周赛369（位运算、分类讨论、记忆化搜索==＞动态规划、树形DP）

文章目录

周赛369
- [2917. 找出数组中的 K-or 值](https://leetcode.cn/problems/find-the-k-or-of-an-array/)
- - 位运算模拟
- [2918. 数组的最小相等和](https://leetcode.cn/problems/minimum-equal-sum-of-two-arrays-after-replacing-zeros/)
- - 分类讨论
- [2919. 使数组变美的最小增量运算数](https://leetcode.cn/problems/minimum-increment-operations-to-make-array-beautiful/)
- - 记忆化搜索 ==> 动态规划
- [2920. 收集所有金币可获得的最大积分](https://leetcode.cn/problems/maximum-points-after-collecting-coins-from-all-nodes/)
- - 树形DP

周赛369

2917. 找出数组中的 K-or 值

简单

给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。

nums 中的 K-or 是一个满足以下条件的非负整数：

只有在 nums 中，至少存在 k 个元素的第 i 位值为 1 ，那么 K-or 中的第 i 位的值才是 1 。

返回 nums 的 K-or 值。

注意：对于整数 x ，如果 (2i AND x) == 2i ，则 x 中的第 i 位值为 1 ，其中 AND 为按位与运算符。

示例 1：

输入：nums = [7,12,9,8,9,15], k = 4
输出：9
解释：nums[0]、nums[2]、nums[4] 和 nums[5] 的第 0 位的值为 1 。
nums[0] 和 nums[5] 的第 1 位的值为 1 。
nums[0]、nums[1] 和 nums[5] 的第 2 位的值为 1 。
nums[1]、nums[2]、nums[3]、nums[4] 和 nums[5] 的第 3 位的值为 1 。
只有第 0 位和第 3 位满足数组中至少存在 k 个元素在对应位上的值为 1 。因此，答案为 2^0 + 2^3 = 9 。

示例 2：

输入：nums = [2,12,1,11,4,5], k = 6
输出：0
解释：因为 k == 6 == nums.length ，所以数组的 6-or 等于其中所有元素按位与运算的结果。因此，答案为 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0 。

示例 3：

输入：nums = [10,8,5,9,11,6,8], k = 1
输出：15
解释：因为 k == 1 ，数组的 1-or 等于其中所有元素按位或运算的结果。因此，答案为 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15 。

提示：

1 <= nums.length <= 50
0 <= nums[i] < 231
1 <= k <= nums.length

位运算模拟

class Solution {
    public int findKOr(int[] nums, int k) {
        int res = 0;
        for(int i = 0; i < 32; i++){
            int cnt = 0;
            for(int num : nums){
                if(((num >> i) & 1) == 1)
                    cnt += 1;
            }
            if(cnt >= k)
                res |= (1 << i);
        }
        return res;
    }
}

2918. 数组的最小相等和

中等

给你两个由正整数和 0 组成的数组 nums1 和 nums2 。

你必须将两个数组中的所有 0 替换为严格正整数，并且满足两个数组中所有元素的和相等。

返回最小相等和，如果无法使两数组相等，则返回 -1 。

示例 1：

输入：nums1 = [3,2,0,1,0], nums2 = [6,5,0]
输出：12
解释：可以按下述方式替换数组中的 0 ：
- 用 2 和 4 替换 nums1 中的两个 0 。得到 nums1 = [3,2,2,1,4] 。
- 用 1 替换 nums2 中的一个 0 。得到 nums2 = [6,5,1] 。
两个数组的元素和相等，都等于 12 。可以证明这是可以获得的最小相等和。

示例 2：

输入：nums1 = [2,0,2,0], nums2 = [1,4]
输出：-1
解释：无法使两个数组的和相等。

提示：

1 <= nums1.length, nums2.length <= 105
0 <= nums1[i], nums2[i] <= 106

分类讨论

class Solution {
    /**
    只有四种情况，依次分类讨论，注意无法相等的情况
     */
    public long minSum(int[] nums1, int[] nums2) {
        int cnt01 = 0, cnt02 = 0;
        long sum1 = 0, sum2 = 0;
        for(int num : nums1){
            if(num == 0) cnt01 += 1;
            sum1 += num;
        }
        for(int num : nums2){
            if(num == 0) cnt02 += 1;
            sum2 += num;
        }
        if(cnt01 > 0 && cnt02 > 0)
            return Math.max(cnt01 + sum1, cnt02 + sum2);
        else if(cnt01 == 0 && cnt02 == 0)
            return cnt01 + sum1 == cnt02 + sum2 ? cnt01 + sum1 : -1;
        else{
            if(cnt01 == 0){
                if(sum1 < cnt02 + sum2) return -1;
                return sum1;
            }else{
                if(sum2 < cnt01 + sum1) return -1;
                return sum2;
            }
        }
    }
}

2919. 使数组变美的最小增量运算数

中等

给你一个下标从 0 开始、长度为 n 的整数数组 nums ，和一个整数 k 。

你可以执行下述递增运算任意次（可以是 0 次）：

从范围 [0, n - 1] 中选择一个下标 i ，并将 nums[i] 的值加 1 。

如果数组中任何长度 大于或等于 3 的子数组，其最大元素都大于或等于 k ，则认为数组是一个 美丽数组 。

以整数形式返回使数组变为 美丽数组 需要执行的最小递增运算数。

子数组是数组中的一个连续非空元素序列。

示例 1：

输入：nums = [2,3,0,0,2], k = 4
输出：3
解释：可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 1 ，并且将 nums[1] 的值加 1 -> [2,4,0,0,2] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,3] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,4] 。
长度大于或等于 3 的子数组为 [2,4,0], [4,0,0], [0,0,4], [2,4,0,0], [4,0,0,4], [2,4,0,0,4] 。
在所有子数组中，最大元素都等于 k = 4 ，所以 nums 现在是美丽数组。
可以证明无法用少于 3 次递增运算使 nums 变为美丽数组。
因此，答案为 3 。

示例 2：

输入：nums = [0,1,3,3], k = 5
输出：2
解释：可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,4,3] 。
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,5,3] 。
长度大于或等于 3 的子数组为 [0,1,5]、[1,5,3]、[0,1,5,3] 。
在所有子数组中，最大元素都等于 k = 5 ，所以 nums 现在是美丽数组。
可以证明无法用少于 2 次递增运算使 nums 变为美丽数组。 
因此，答案为 2 。

示例 3：

输入：nums = [1,1,2], k = 1
输出：0
解释：在这个示例中，只有一个长度大于或等于 3 的子数组 [1,1,2] 。
其最大元素 2 已经大于 k = 1 ，所以无需执行任何增量运算。
因此，答案为 0 。

提示：

3 <= n == nums.length <= 105
0 <= nums[i] <= 109
0 <= k <= 109

记忆化搜索 ==> 动态规划

https://leetcode.cn/problems/minimum-increment-operations-to-make-array-beautiful/solutions/2503157/qiao-miao-she-ji-zhuang-tai-xuan-huo-bu-8547u/

class Solution {
    int[] nums;
    long[][] cache;
    int k;
    public long minIncrementOperations(int[] nums, int k) {
        this.k = k;
        this.nums = nums;
        int n = nums.length;
        cache = new long[n][3];
        for(int i = 0; i < n; i++)
            Arrays.fill(cache[i], -1);
        return dfs(n-1, 0);
    }
    /**
        问题转换成：把每个长为 3 的子数组都需要包含至少一个k
        考虑最后一个元素选还是不选，即是否增大
            增大到k：那么对于左边的那个数来说，它右边就有一个k
            不增大：那么对于左边那个数来说，它右边有一个没有增大的数
        定义 dfs(i, j) 表示当前在i位置，右边有j个没有增大的数
            增大到k 即 dfs(i-1, 0) + max(k - nums[i], 0)
            如果 j < 2,即可以不增大，dfs(i-1, j+1)
        递归边界 当 i < 0 时返回0
        递归入口 dfs(n-1, 0)
     */ 
    public long dfs(int i, int j){
        if(i < 0) return 0;
        if(cache[i][j] >= 0) return cache[i][j];
        long res = dfs(i-1, 0) + Math.max(k - nums[i], 0);
        if(j < 2) res = Math.min(res, dfs(i-1, j+1));
        return cache[i][j] = res;
    }
}

节点 0 处现有一棵由 n 个节点组成的无向树，节点编号从 0 到 n - 1 。给你一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示在树上的节点 ai 和 bi 之间存在一条边。另给你一个下标从 0 开始、长度为 n 的数组 coins 和一个整数 k ，其中 coins[i] 表示节点 i 处的金币数量。

从根节点开始，你必须收集所有金币。要想收集节点上的金币，必须先收集该节点的祖先节点上的金币。

节点 i 上的金币可以用下述方法之一进行收集：

收集所有金币，得到共计 coins[i] - k 点积分。如果 coins[i] - k 是负数，你将会失去 abs(coins[i] - k) 点积分。
收集所有金币，得到共计 floor(coins[i] / 2) 点积分。如果采用这种方法，节点 i 子树中所有节点 j 的金币数 coins[j] 将会减少至 floor(coins[j] / 2) 。

返回收集所有树节点的金币之后可以获得的最大积分。

示例 1：

输入：edges = [[0,1],[1,2],[2,3]], coins = [10,10,3,3], k = 5
输出：11                        
解释：
使用第一种方法收集节点 0 上的所有金币。总积分 = 10 - 5 = 5 。
使用第一种方法收集节点 1 上的所有金币。总积分 = 5 + (10 - 5) = 10 。
使用第二种方法收集节点 2 上的所有金币。所以节点 3 上的金币将会变为 floor(3 / 2) = 1 ，总积分 = 10 + floor(3 / 2) = 11 。
使用第二种方法收集节点 3 上的所有金币。总积分 =  11 + floor(1 / 2) = 11.
可以证明收集所有节点上的金币能获得的最大积分是 11 。

示例 2：

输入：edges = [[0,1],[0,2]], coins = [8,4,4], k = 0
输出：16
解释：
使用第一种方法收集所有节点上的金币，因此，总积分 = (8 - 0) + (4 - 0) + (4 - 0) = 16 。

提示：

n == coins.length
2 <= n <= 105
0 <= coins[i] <= 104
edges.length == n - 1
0 <= edges[i][0], edges[i][1] < n
0 <= k <= 104

树形DP

https://leetcode.cn/problems/maximum-points-after-collecting-coins-from-all-nodes/solutions/2503152/shu-xing-dp-ji-yi-hua-sou-suo-by-endless-phzx/

class Solution {
    /**
    把 floor(coins[i]/2) 看成右移操作，右移操作是可以叠加的，
            我们可以记录子树节点右移了多少次
    10^4 = 14次，本题最多右移14次就成为了0
    定义dfs(i, j) 表示子树 i 在已经右移了j次的前提下，最多可以获得多少积分
    用 选或者不选 来思考
    右移 答案为 coins[i] >> (j+1) 加上每个子树 ch 的dfs(ch, j+1)
    不右移 答案为 (coins[i]>>j)-k 加上每个子树 ch 的dfs(ch, j)
     */
    public int maximumPoints(int[][] edges, int[] coins, int k) {
        int n = coins.length;
        List<Integer>[] g = new ArrayList[n];
        Arrays.setAll(g, e -> new ArrayList<>());
        for(int[] e : edges){
            int x = e[0], y = e[1];
            g[x].add(y);
            g[y].add(x);
        }
        int[][] cache = new int[n][14];
        for(int[] m : cache)
            Arrays.fill(m, -1);
        return dfs(0, 0, -1, cache, g, coins, k);
    }

    public int dfs(int i, int j, int fa, int[][] memo, List<Integer>[] g, int[] coins, int k){
        if(memo[i][j] != -1)
            return memo[i][j];
        int res1 = (coins[i] >> j) - k;
        int res2 = coins[i] >> (j+1);
        for(int ch : g[i]){
            if(ch == fa) continue;
            // 不右移
            res1 += dfs(ch, j, i, memo, g, coins, k);
            // 右移
            if(j < 13){
                res2 += dfs(ch, j + 1, i, memo, g, coins, k);
            }
        }
        return memo[i][j] = Math.max(res1, res2);
    }
}