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 nreturn 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] * Nfor x in nums:for y in nums:a[x ^ y] = Trueb = [0] * Nfor xy, flag in enumerate(a):if flag:for z in nums:b[xy^z] = 1return 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] += vali += i & -idef per_sum(self, i:int)->int:res = 0while i > 0:res += self.t[i]i -= i & -ireturn 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 = 0def dfs(x:int, fa:int)->None:nonlocal clockclock += 1in_[x] = clockfor y in g[x]:if y != fa:dfs(y, x)out[x] = clockdfs(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, xd = val - weight[x]weight[x] = valt.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