LeetCode --- 154双周赛

题目列表

3512. 使数组和能被 K 整除的最少操作次数
3513. 不同 XOR 三元组的数目 I
3514. 不同 XOR 三元组的数目 II
3515. 带权树中的最短路径

一、使数组能被 k 整除的最小操作次数

本题就是问你数组元素和减去几才能成为 k 的倍数，用 取模运算 即可，代码如下

// C++
class Solution {
public:
    int minOperations(vector<int>& nums, int k) {
        return accumulate(nums.begin(), nums.end(), 0) % k;
    }
};

# Python
class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        return sum(nums) % k

二、不同 XOR 三元组的数目 I

本题，找规律（可以打个表看看）本题和给的数组的元素顺序并没有关系，只和选择哪三个数有关系

• 当 $n=1$ 时，只有 1，只能选 3个1，异或结果只有 1 个

• 当 $n=2$ 时，有 1和2，异或结果可以是 1、2，共 2 个

• 当 $n\ge 3$ 时， $[0,2^L)$ 中的任何数都能得到，共有 $2^L$ 个，其中 $L=\lfloor lo{g}_{2}n\rfloor +1$，即 $n$ 的二进制长度，解释如下

  • 可以选择 1、2、3 异或为 0

  • 可以选择 3 个相同的数，异或为它们本身，可以构成 [1,n] 中的任意一个数

  • 能组成多少个$\ge n$ 的数呢？

    • 异或的结果不可能超过 $2^L-1$
    • 对于 $[n+1,2^L-1]$ 中的任意一个数 $a$，我们可以将其拆分为 $2^{L-1}\oplus b$，再将 $b$ 拆分为 $c\oplus 1$，即 $a=2^{L-1}\oplus c\oplus 1$，特殊的，当 $a=2^{L-1}+1$ 时，此时 $c=0$，但是 $c\in [1,n]$，不能取 $0$，可以这样构造 $a=2^{L-1}\oplus 2\oplus 3$

代码如下

// C++
class Solution {
public:
    int uniqueXorTriplets(vector<int>& nums) {
        int n = nums.size();
        if(n <= 2) return n;
        return 1 << bit_width((unsigned)n);
    }
};

# Python
class Solution:
    def uniqueXorTriplets(self, nums: List[int]) -> int:
        n = len(nums)
        if n <= 2: return n
        return 1 << n.bit_length()

三、不同 XOR 三元组的数目 II

由于 1 <= nums[i] <= 1500，故异或的结果最多只有 $2^{\lfloor lo{g}_2(1500)\rfloor +1}=2048$，我们可以将暴力枚举的三重循环，变成两个两层循环，来进行模拟，代码如下

// C++
class Solution {
public:
    int uniqueXorTriplets(vector<int>& nums) {
        int n = nums.size();
        int mx = ranges::max(nums);
        int N = 1 << bit_width((unsigned)mx);
        vector<int> hash(N);
        // 计算两个数的异化
        for(int i = 0; i < n; i++){
            for(int j = i; j < n; j++){
                hash[nums[i] ^ nums[j]] = true;
            }
        }

        vector<int> hash3(N);
        // 计算3个数的异或
        for(int j = 0; j < N; j++){
            if(hash[j]){
                for(int i = 0; i < n; i++){
                    hash3[nums[i] ^ j] = true;
                }
            }
        }
        return reduce(hash3.begin(), hash3.end());
    }
};

#Python
class Solution:
    def uniqueXorTriplets(self, nums: List[int]) -> int:
        N = 1 << (max(nums).bit_length() + 1)
        a = [False] * N
        for x in nums:
            for y in nums:
                a[x ^ y] = True
        b = [0] * N
        for xy, flag in enumerate(a):
            if flag:
                for z in nums:
                    b[xy^z] = 1
        return sum(b)

四、带权树中的最短路径

本题既需要修改边的权重，同时又要计算结点到根的路径长度。一旦我们修改一条边的权重，那么这条边连接的子树的所有结点，到根结点的距离都会有相同的变化，但是放在一棵树上我们很难去维护，如何做？

• 观察一棵树的先序遍历结果，我们会发现，同一个子树的结点在先序遍历中是连续的，如下图
  

• 对一个连续区间的加减操作，我们可以用 差分数组 来维护，同时由于题目还要求能快速查询结点到根节点的距离，我们可以将 差分数组 和 树状数组 进行结合，就能快速进行修改和查询的工作了
  

代码如下

// C++
class BIT{
public:
    BIT(int n): t(n + 1){}
    void update(int i, int val){
        while(i < t.size()){
            t[i] += val;
            i += i & -i;
        }
    }
    long long pre_sum(int i){
        long long res = 0;
        while(i){
            res += t[i];
            i -= i & -i;
        }
        return res;
    }
private:
    vector<long long> t;
};
class Solution {
public:
    vector<int> treeQueries(int n, vector<vector<int>>& edges, vector<vector<int>>& queries) {
        vector<vector<int>> g(n + 1);
        for(auto& e : edges){
            g[e[0]].push_back(e[1]);
            g[e[1]].push_back(e[0]);
        }
        // 用 [in[i], out[i]] 标记子树在先序遍历中的区间范围 
        vector<int> in(n + 1), out(n + 1);
        int clock = 0;
        auto dfs = [&](this auto&& dfs, int x, int fa)->void{
            in[x] = ++clock;
            for(int y : g[x]){
                if(y == fa) continue;
                dfs(y, x);
            }
            out[x] = clock;
        };
        dfs(1, 0);
        vector<int> w(n + 1);
        BIT t(n);
        auto update = [&](int x, int y, int val){
            if(in[x] < in[y]) swap(x, y); // 确认子树的根节点
            int d = val - w[x]; // 计算变化量
            w[x] = val; // 记录修改之后的值，方便后面计算变化量
            // 差分数组的维护方法
            t.update(in[x], d);
            t.update(out[x] + 1, -d);
        };
        for(auto & e : edges){
            update(e[0], e[1], e[2]);
        }
        vector<int> ans;
        for(auto& q : queries){
            if(q[0] == 1){
                update(q[1], q[2], q[3]);
            }else{
                ans.push_back(t.pre_sum(in[q[1]]));
            }
        }
        return ans;
    }
};

#Python
class BIT:
    def __init__(self, n:int):
        self.t = [0] * (n + 1)
    
    def update(self, i:int, val:int):
        while i < len(self.t):
            self.t[i] += val
            i += i & -i
    
    def per_sum(self, i:int)->int:
        res = 0
        while i > 0:
            res += self.t[i]
            i -= i & -i
        return res
class Solution:
    def treeQueries(self, n: int, edges: List[List[int]], queries: List[List[int]]) -> List[int]:
        g = [[] for _ in range(n + 1)]
        for x, y, _ in edges:
            g[x].append(y)
            g[y].append(x)
        
        in_ = [0] * (n + 1)
        out = [0] * (n + 1)
        clock = 0
        def dfs(x:int, fa:int)->None:
            nonlocal clock
            clock += 1
            in_[x] = clock
            for y in g[x]:
                if y != fa:
                    dfs(y, x)
            out[x] = clock
        dfs(1, 0)

        t = BIT(n)
        weight = [0] * (n + 1)
        def update(x:int, y:int, val:int)->None:
            if in_[x] < in_[y]:
                x, y = y, x
            d = val - weight[x]
            weight[x] = val
            t.update(in_[x], d)
            t.update(out[x] + 1, -d)
        
        for x, y, w in edges:
            update(x, y, w)
        ans = []
        for q in queries:
            if q[0] == 1:
                update(q[1], q[2], q[3])
            else:
                ans.append(t.per_sum(in_[q[1]]))
        return ans