feat: add solutions to lc problem: No.3599 (#4536)

No.3599.Partition Array to Minimize XOR

Author: yanglbme

solution/3500-3599/3599.Partition Array to Minimize XOR/README.md

@@ -98,32 +98,162 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3599.Pa
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：动态规划
+
+我们定义 $f[i][j]$ 表示将前 $i$ 个元素划分成 $j$ 个子数组的最大 XOR 的最小值。初始时 $f[0][0] = 0$，其余 $f[i][j] = +\infty$。
+
+为了快速计算子数组的 XOR，我们可以使用前缀 XOR 数组 $g$，其中 $g[i]$ 表示前 $i$ 个元素的 XOR 值，那么对于子数组 $[h + 1...i]$（下标从 $1$ 开始），其 XOR 值为 $g[i] \oplus g[h]$。
+
+接下来，我们在 $[1, n]$ 的范围内遍历 $i$，在 $[1, \min(i, k)]$ 的范围内遍历 $j$，并在 $[j - 1, i - 1]$ 的范围内遍历 $h$，其中 $h$ 表示上一个子数组的结束位置（下标从 $1$ 开始）。我们可以通过以下状态转移方程来更新 $f[i][j]$：
+
+$$
+f[i][j] = \min_{h \in [j - 1, i - 1]} \max(f[h][j - 1], g[i] \oplus g[h])
+$$
+
+最后，我们返回 $f[n][k]$，即将整个数组划分成 $k$ 个子数组的最大 XOR 的最小值。
+
+时间复杂度 $O(n^2 \times k)$，空间复杂度 $O(n \times k)$，其中 $n$ 是数组的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+min = lambda a, b: a if a < b else b
+max = lambda a, b: a if a > b else b
+
+
+class Solution:
+    def minXor(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        g = [0] * (n + 1)
+        for i, x in enumerate(nums, 1):
+            g[i] = g[i - 1] ^ x
+
+        f = [[inf] * (k + 1) for _ in range(n + 1)]
+        f[0][0] = 0
+        for i in range(1, n + 1):
+            for j in range(1, min(i, k) + 1):
+                for h in range(j - 1, i):
+                    f[i][j] = min(f[i][j], max(f[h][j - 1], g[i] ^ g[h]))
+        return f[n][k]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minXor(int[] nums, int k) {
+        int n = nums.length;
+        int[] g = new int[n + 1];
+        for (int i = 1; i <= n; ++i) {
+            g[i] = g[i - 1] ^ nums[i - 1];
+        }
+
+        int[][] f = new int[n + 1][k + 1];
+        for (int i = 0; i <= n; ++i) {
+            Arrays.fill(f[i], Integer.MAX_VALUE);
+        }
+        f[0][0] = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= Math.min(i, k); ++j) {
+                for (int h = j - 1; h < i; ++h) {
+                    f[i][j] = Math.min(f[i][j], Math.max(f[h][j - 1], g[i] ^ g[h]));
+                }
+            }
+        }
+
+        return f[n][k];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minXor(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<int> g(n + 1);
+        for (int i = 1; i <= n; ++i) {
+            g[i] = g[i - 1] ^ nums[i - 1];
+        }
+
+        const int inf = numeric_limits<int>::max();
+        vector f(n + 1, vector(k + 1, inf));
+        f[0][0] = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= min(i, k); ++j) {
+                for (int h = j - 1; h < i; ++h) {
+                    f[i][j] = min(f[i][j], max(f[h][j - 1], g[i] ^ g[h]));
+                }
+            }
+        }
+
+        return f[n][k];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minXor(nums []int, k int) int {
+	n := len(nums)
+	g := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		g[i] = g[i-1] ^ nums[i-1]
+	}
+
+	const inf = math.MaxInt32
+	f := make([][]int, n+1)
+	for i := range f {
+		f[i] = make([]int, k+1)
+		for j := range f[i] {
+			f[i][j] = inf
+		}
+	}
+	f[0][0] = 0
+
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= min(i, k); j++ {
+			for h := j - 1; h < i; h++ {
+				f[i][j] = min(f[i][j], max(f[h][j-1], g[i]^g[h]))
+			}
+		}
+	}
+
+	return f[n][k]
+}
+```
 
+#### TypeScript
+
+```ts
+function minXor(nums: number[], k: number): number {
+    const n = nums.length;
+    const g: number[] = Array(n + 1).fill(0);
+    for (let i = 1; i <= n; ++i) {
+        g[i] = g[i - 1] ^ nums[i - 1];
+    }
+
+    const inf = Number.MAX_SAFE_INTEGER;
+    const f: number[][] = Array.from({ length: n + 1 }, () => Array(k + 1).fill(inf));
+    f[0][0] = 0;
+
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= Math.min(i, k); ++j) {
+            for (let h = j - 1; h < i; ++h) {
+                f[i][j] = Math.min(f[i][j], Math.max(f[h][j - 1], g[i] ^ g[h]));
+            }
+        }
+    }
+
+    return f[n][k];
+}
 ```
 
 <!-- tabs:end -->

solution/3500-3599/3599.Partition Array to Minimize XOR/README_EN.md

@@ -95,32 +95,162 @@ A <strong>subarray</strong> is a contiguous <b>non-empty</b> sequence of element
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i][j]$ as the minimum possible value of the maximum XOR among all ways to partition the first $i$ elements into $j$ subarrays. Initially, set $f[0][0] = 0$, and all other $f[i][j] = +\infty$.
+
+To quickly compute the XOR of a subarray, we can use a prefix XOR array $g$, where $g[i]$ represents the XOR of the first $i$ elements. For the subarray $[h + 1...i]$ (with indices starting from $1$), its XOR value is $g[i] \oplus g[h]$.
+
+Next, we iterate $i$ from $1$ to $n$, $j$ from $1$ to $\min(i, k)$, and $h$ from $j - 1$ to $i - 1$, where $h$ represents the end position of the previous subarray (indices starting from $1$). We update $f[i][j]$ using the following state transition equation:
+
+$$
+f[i][j] = \min_{h \in [j - 1, i - 1]} \max(f[h][j - 1], g[i] \oplus g[h])
+$$
+
+Finally, we return $f[n][k]$, which is the minimum possible value of the maximum XOR when partitioning the entire array into $k$ subarrays.
+
+The time complexity is $O(n^2 \times k)$, and the space complexity is $O(n \times k)$, where $n$ is the length of the array.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+min = lambda a, b: a if a < b else b
+max = lambda a, b: a if a > b else b
+
+
+class Solution:
+    def minXor(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        g = [0] * (n + 1)
+        for i, x in enumerate(nums, 1):
+            g[i] = g[i - 1] ^ x
+
+        f = [[inf] * (k + 1) for _ in range(n + 1)]
+        f[0][0] = 0
+        for i in range(1, n + 1):
+            for j in range(1, min(i, k) + 1):
+                for h in range(j - 1, i):
+                    f[i][j] = min(f[i][j], max(f[h][j - 1], g[i] ^ g[h]))
+        return f[n][k]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minXor(int[] nums, int k) {
+        int n = nums.length;
+        int[] g = new int[n + 1];
+        for (int i = 1; i <= n; ++i) {
+            g[i] = g[i - 1] ^ nums[i - 1];
+        }
+
+        int[][] f = new int[n + 1][k + 1];
+        for (int i = 0; i <= n; ++i) {
+            Arrays.fill(f[i], Integer.MAX_VALUE);
+        }
+        f[0][0] = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= Math.min(i, k); ++j) {
+                for (int h = j - 1; h < i; ++h) {
+                    f[i][j] = Math.min(f[i][j], Math.max(f[h][j - 1], g[i] ^ g[h]));
+                }
+            }
+        }
+
+        return f[n][k];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minXor(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<int> g(n + 1);
+        for (int i = 1; i <= n; ++i) {
+            g[i] = g[i - 1] ^ nums[i - 1];
+        }
+
+        const int inf = numeric_limits<int>::max();
+        vector f(n + 1, vector(k + 1, inf));
+        f[0][0] = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= min(i, k); ++j) {
+                for (int h = j - 1; h < i; ++h) {
+                    f[i][j] = min(f[i][j], max(f[h][j - 1], g[i] ^ g[h]));
+                }
+            }
+        }
+
+        return f[n][k];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minXor(nums []int, k int) int {
+	n := len(nums)
+	g := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		g[i] = g[i-1] ^ nums[i-1]
+	}
+
+	const inf = math.MaxInt32
+	f := make([][]int, n+1)
+	for i := range f {
+		f[i] = make([]int, k+1)
+		for j := range f[i] {
+			f[i][j] = inf
+		}
+	}
+	f[0][0] = 0
+
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= min(i, k); j++ {
+			for h := j - 1; h < i; h++ {
+				f[i][j] = min(f[i][j], max(f[h][j-1], g[i]^g[h]))
+			}
+		}
+	}
+
+	return f[n][k]
+}
+```
 
+#### TypeScript
+
+```ts
+function minXor(nums: number[], k: number): number {
+    const n = nums.length;
+    const g: number[] = Array(n + 1).fill(0);
+    for (let i = 1; i <= n; ++i) {
+        g[i] = g[i - 1] ^ nums[i - 1];
+    }
+
+    const inf = Number.MAX_SAFE_INTEGER;
+    const f: number[][] = Array.from({ length: n + 1 }, () => Array(k + 1).fill(inf));
+    f[0][0] = 0;
+
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= Math.min(i, k); ++j) {
+            for (let h = j - 1; h < i; ++h) {
+                f[i][j] = Math.min(f[i][j], Math.max(f[h][j - 1], g[i] ^ g[h]));
+            }
+        }
+    }
+
+    return f[n][k];
+}
 ```
 
 <!-- tabs:end -->

solution/3500-3599/3599.Partition Array to Minimize XOR/Solution.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int minXor(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<int> g(n + 1);
+        for (int i = 1; i <= n; ++i) {
+            g[i] = g[i - 1] ^ nums[i - 1];
+        }
+
+        const int inf = numeric_limits<int>::max();
+        vector f(n + 1, vector(k + 1, inf));
+        f[0][0] = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= min(i, k); ++j) {
+                for (int h = j - 1; h < i; ++h) {
+                    f[i][j] = min(f[i][j], max(f[h][j - 1], g[i] ^ g[h]));
+                }
+            }
+        }
+
+        return f[n][k];
+    }
+};

solution/3500-3599/3599.Partition Array to Minimize XOR/Solution.go

@@ -0,0 +1,27 @@
+func minXor(nums []int, k int) int {
+	n := len(nums)
+	g := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		g[i] = g[i-1] ^ nums[i-1]
+	}
+
+	const inf = math.MaxInt32
+	f := make([][]int, n+1)
+	for i := range f {
+		f[i] = make([]int, k+1)
+		for j := range f[i] {
+			f[i][j] = inf
+		}
+	}
+	f[0][0] = 0
+
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= min(i, k); j++ {
+			for h := j - 1; h < i; h++ {
+				f[i][j] = min(f[i][j], max(f[h][j-1], g[i]^g[h]))
+			}
+		}
+	}
+
+	return f[n][k]
+}