Merge branch 'doocs:main' into main

Author: Nothing-avil

solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/README.md

@@ -64,99 +64,99 @@ nums = [1,3,4] 是美丽数组。
 
 ## 解法
 
-### 方法一：贪心 + 哈希表
+### 方法一：贪心 + 数学
 
-我们从正整数 $i=1$ 开始，依次判断 $i$ 是否可以加入数组中，如果可以加入，则将 $i$ 加入数组中，累加到答案中，然后将 $target-i$ 置为已访问，表示 $target-i$ 不能加入数组中。循环直到数组长度为 $n$。
+我们可以贪心地从 $x = 1$ 开始构造数组 $nums$，每次选择 $x$，并且排除 $target - x$。
 
-时间复杂度 $O(n + target)$，空间复杂度 $O(n + target)$。其中 $n$ 为数组长度。
+我们不妨记 $m = \left\lfloor \frac{target}{2} \right\rfloor$。
+
+如果 $x <= m$，那么我们可以选择的数有 $1, 2, \cdots, n$，所以数组的和为 $\left\lfloor \frac{(1+n)n}{2} \right\rfloor$。
+
+如果 $x > m$，那么我们可以选择的数有 $1, 2, \cdots, m$，共 $m$ 个数，以及 $n - m$ 个从 $target$ 开始的数，所以数组的和为 $\left\lfloor \frac{(1+m)m}{2} \right\rfloor + \left\lfloor \frac{(target + target + n - m - 1)(n-m)}{2} \right\rfloor$。
+
+注意，我们需要对结果取模 $10^9 + 7$。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def minimumPossibleSum(self, n: int, target: int) -> int:
-        vis = set()
-        ans = 0
-        i = 1
-        for _ in range(n):
-            while i in vis:
-                i += 1
-            ans += i
-            vis.add(target - i)
-            i += 1
-        return ans
+        mod = 10**9 + 7
+        m = target // 2
+        if n <= m:
+            return ((1 + n) * n // 2) % mod
+        return ((1 + m) * m // 2 + (target + target + n - m - 1) * (n - m) // 2) % mod
 ```
 
 ```java
 class Solution {
-    public long minimumPossibleSum(int n, int target) {
-        boolean[] vis = new boolean[n + target];
-        long ans = 0;
-        for (int i = 1; n > 0; --n, ++i) {
-            while (vis[i]) {
-                ++i;
-            }
-            ans += i;
-            if (target >= i) {
-                vis[target - i] = true;
-            }
+    public int minimumPossibleSum(int n, int target) {
+        final int mod = (int) 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (int) ((1L + n) * n / 2 % mod);
         }
-        return ans;
+        long a = (1L + m) * m / 2 % mod;
+        long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
+        return (int) ((a + b) % mod);
     }
 }
 ```
 
 ```cpp
 class Solution {
 public:
-    long long minimumPossibleSum(int n, int target) {
-        bool vis[n + target];
-        memset(vis, false, sizeof(vis));
-        long long ans = 0;
-        for (int i = 1; n; ++i, --n) {
-            while (vis[i]) {
-                ++i;
-            }
-            ans += i;
-            if (target >= i) {
-                vis[target - i] = true;
-            }
+    int minimumPossibleSum(int n, int target) {
+        const int mod = 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (1LL + n) * n / 2 % mod;
         }
-        return ans;
+        long long a = (1LL + m) * m / 2 % mod;
+        long long b = (1LL * target + target + n - m - 1) * (n - m) / 2 % mod;
+        return (a + b) % mod;
     }
 };
 ```
 
 ```go
-func minimumPossibleSum(n int, target int) (ans int64) {
-	vis := make([]bool, n+target)
-	for i := 1; n > 0; i, n = i+1, n-1 {
-		for vis[i] {
-			i++
-		}
-		ans += int64(i)
-		if target >= i {
-			vis[target-i] = true
-		}
+func minimumPossibleSum(n int, target int) int {
+	const mod int = 1e9 + 7
+	m := target / 2
+	if n <= m {
+		return (n + 1) * n / 2 % mod
 	}
-	return
+	a := (m + 1) * m / 2 % mod
+	b := (target + target + n - m - 1) * (n - m) / 2 % mod
+	return (a + b) % mod
 }
 ```
 
 ```ts
 function minimumPossibleSum(n: number, target: number): number {
-    const vis: boolean[] = Array(n + target).fill(false);
-    let ans = 0;
-    for (let i = 1; n; ++i, --n) {
-        while (vis[i]) {
-            ++i;
-        }
-        ans += i;
-        if (target >= i) {
-            vis[target - i] = true;
+    const mod = 10 ** 9 + 7;
+    const m = target >> 1;
+    if (n <= m) {
+        return (((1 + n) * n) / 2) % mod;
+    }
+    return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
+}
+```
+
+```cs
+public class Solution {
+    public int MinimumPossibleSum(int n, int target) {
+        const int mod = (int) 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (int) ((1L + n) * n / 2 % mod);
         }
+        long a = (1L + m) * m / 2 % mod;
+        long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
+        return (int) ((a + b) % mod);
     }
-    return ans;
 }
 ```
 

solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/README_EN.md

@@ -61,99 +61,99 @@ It can be proven that 8 is the minimum possible sum that a beautiful array could
 
 ## Solutions
 
-### Solution 1: Greedy + Hash Table
+### Solution 1: Greedy + Mathematics
 
-We start from the positive integer $i=1$, and judge whether $i$ can be added to the array in turn. If it can be added, we add $i$ to the array, accumulate it to the answer, and then mark $target-i$ as visited, indicating that $target-i$ cannot be added to the array. The loop continues until the length of the array is $n$.
+We can greedily construct the array `nums` starting from $x = 1$, choosing $x$ each time and excluding $target - x$.
 
-The time complexity is $O(n + target)$, and the space complexity is $O(n + target)$. Here, $n$ is the length of the array.
+Let's denote $m = \left\lfloor \frac{target}{2} \right\rfloor$.
+
+If $x <= m$, then the numbers we can choose are $1, 2, \cdots, n$, so the sum of the array is $\left\lfloor \frac{(1+n)n}{2} \right\rfloor$.
+
+If $x > m$, then the numbers we can choose are $1, 2, \cdots, m$, a total of $m$ numbers, and $n - m$ numbers starting from $target$, so the sum of the array is $\left\lfloor \frac{(1+m)m}{2} \right\rfloor + \left\lfloor \frac{(target + target + n - m - 1)(n-m)}{2} \right\rfloor$.
+
+Note that we need to take the modulus of $10^9 + 7$ for the result.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def minimumPossibleSum(self, n: int, target: int) -> int:
-        vis = set()
-        ans = 0
-        i = 1
-        for _ in range(n):
-            while i in vis:
-                i += 1
-            ans += i
-            vis.add(target - i)
-            i += 1
-        return ans
+        mod = 10**9 + 7
+        m = target // 2
+        if n <= m:
+            return ((1 + n) * n // 2) % mod
+        return ((1 + m) * m // 2 + (target + target + n - m - 1) * (n - m) // 2) % mod
 ```
 
 ```java
 class Solution {
-    public long minimumPossibleSum(int n, int target) {
-        boolean[] vis = new boolean[n + target];
-        long ans = 0;
-        for (int i = 1; n > 0; --n, ++i) {
-            while (vis[i]) {
-                ++i;
-            }
-            ans += i;
-            if (target >= i) {
-                vis[target - i] = true;
-            }
+    public int minimumPossibleSum(int n, int target) {
+        final int mod = (int) 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (int) ((1L + n) * n / 2 % mod);
         }
-        return ans;
+        long a = (1L + m) * m / 2 % mod;
+        long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
+        return (int) ((a + b) % mod);
     }
 }
 ```
 
 ```cpp
 class Solution {
 public:
-    long long minimumPossibleSum(int n, int target) {
-        bool vis[n + target];
-        memset(vis, false, sizeof(vis));
-        long long ans = 0;
-        for (int i = 1; n; ++i, --n) {
-            while (vis[i]) {
-                ++i;
-            }
-            ans += i;
-            if (target >= i) {
-                vis[target - i] = true;
-            }
+    int minimumPossibleSum(int n, int target) {
+        const int mod = 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (1LL + n) * n / 2 % mod;
         }
-        return ans;
+        long long a = (1LL + m) * m / 2 % mod;
+        long long b = (1LL * target + target + n - m - 1) * (n - m) / 2 % mod;
+        return (a + b) % mod;
     }
 };
 ```
 
 ```go
-func minimumPossibleSum(n int, target int) (ans int64) {
-	vis := make([]bool, n+target)
-	for i := 1; n > 0; i, n = i+1, n-1 {
-		for vis[i] {
-			i++
-		}
-		ans += int64(i)
-		if target >= i {
-			vis[target-i] = true
-		}
+func minimumPossibleSum(n int, target int) int {
+	const mod int = 1e9 + 7
+	m := target / 2
+	if n <= m {
+		return (n + 1) * n / 2 % mod
 	}
-	return
+	a := (m + 1) * m / 2 % mod
+	b := (target + target + n - m - 1) * (n - m) / 2 % mod
+	return (a + b) % mod
 }
 ```
 
 ```ts
 function minimumPossibleSum(n: number, target: number): number {
-    const vis: boolean[] = Array(n + target).fill(false);
-    let ans = 0;
-    for (let i = 1; n; ++i, --n) {
-        while (vis[i]) {
-            ++i;
-        }
-        ans += i;
-        if (target >= i) {
-            vis[target - i] = true;
+    const mod = 10 ** 9 + 7;
+    const m = target >> 1;
+    if (n <= m) {
+        return (((1 + n) * n) / 2) % mod;
+    }
+    return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
+}
+```
+
+```cs
+public class Solution {
+    public int MinimumPossibleSum(int n, int target) {
+        const int mod = (int) 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (int) ((1L + n) * n / 2 % mod);
         }
+        long a = (1L + m) * m / 2 % mod;
+        long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
+        return (int) ((a + b) % mod);
     }
-    return ans;
 }
 ```
 

solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.cpp

@@ -1,18 +1,13 @@
 class Solution {
 public:
-    long long minimumPossibleSum(int n, int target) {
-        bool vis[n + target];
-        memset(vis, false, sizeof(vis));
-        long long ans = 0;
-        for (int i = 1; n; ++i, --n) {
-            while (vis[i]) {
-                ++i;
-            }
-            ans += i;
-            if (target >= i) {
-                vis[target - i] = true;
-            }
+    int minimumPossibleSum(int n, int target) {
+        const int mod = 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (1LL + n) * n / 2 % mod;
         }
-        return ans;
+        long long a = (1LL + m) * m / 2 % mod;
+        long long b = (1LL * target + target + n - m - 1) * (n - m) / 2 % mod;
+        return (a + b) % mod;
     }
 };

solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.cs

@@ -0,0 +1,12 @@
+public class Solution {
+    public int MinimumPossibleSum(int n, int target) {
+        const int mod = (int) 1e9 + 7;
+        int m = target / 2;
+        if (n <= m) {
+            return (int) ((1L + n) * n / 2 % mod);
+        }
+        long a = (1L + m) * m / 2 % mod;
+        long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
+        return (int) ((a + b) % mod);
+    }
+}

solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.go

@@ -1,13 +1,10 @@
-func minimumPossibleSum(n int, target int) (ans int64) {
-	vis := make([]bool, n+target)
-	for i := 1; n > 0; i, n = i+1, n-1 {
-		for vis[i] {
-			i++
-		}
-		ans += int64(i)
-		if target >= i {
-			vis[target-i] = true
-		}
+func minimumPossibleSum(n int, target int) int {
+	const mod int = 1e9 + 7
+	m := target / 2
+	if n <= m {
+		return (n + 1) * n / 2 % mod
 	}
-	return
+	a := (m + 1) * m / 2 % mod
+	b := (target + target + n - m - 1) * (n - m) / 2 % mod
+	return (a + b) % mod
 }