Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: update solutions to lc problem: No.2834 #2414

Merged
merged 1 commit into from
Mar 8, 2024
Merged

feat: update solutions to lc problem: No.2834 #2414

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
101 changes: 41 additions & 60 deletions ...ion/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -64,99 +64,80 @@ 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$ 为数组长度。
如果 $x <= \left\lfloor \frac{target}{2} \right\rfloor$，那么我们可以选择的数字分别为 $1, 2, \cdots, n$，因此，数组的和为 $\left\lfloor \frac{n(n+1)}{2} \right\rfloor$。

如果 $x > \left\lfloor \frac{target}{2} \right\rfloor$，那么我们可以选择的数字分别为 $1, 2, \cdots, \left\lfloor \frac{target}{2} \right\rfloor$，共 $\left\lfloor \frac{target}{2} \right\rfloor$ 个数，以及从 $target$ 开始的 $n - \left\lfloor \frac{target}{2} \right\rfloor$ 个数字，因此，数组的和为 $\left\lfloor \frac{\left\lfloor \frac{target}{2} \right\rfloor \left(\left\lfloor \frac{target}{2} \right\rfloor + 1\right)}{2} \right\rfloor + \left\lfloor \frac{target + target + n - \left\lfloor \frac{target}{2} \right\rfloor - 1}{2} \right\rfloor$。

时间复杂度 $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 ans;
return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
}
```

Expand Down
101 changes: 41 additions & 60 deletions .../2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/README_EN.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -61,99 +61,80 @@ 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.
If $x <= \left\lfloor \frac{target}{2} \right\rfloor$, then the numbers we can choose are $1, 2, \cdots, n$, so the sum of the array is $\left\lfloor \frac{n(n+1)}{2} \right\rfloor$.

If $x > \left\lfloor \frac{target}{2} \right\rfloor$, then the numbers we can choose are $1, 2, \cdots, \left\lfloor \frac{target}{2} \right\rfloor$, a total of $\left\lfloor \frac{target}{2} \right\rfloor$ numbers, and $n - \left\lfloor \frac{target}{2} \right\rfloor$ numbers starting from $target$, so the sum of the array is $\left\lfloor \frac{\left\lfloor \frac{target}{2} \right\rfloor \left(\left\lfloor \frac{target}{2} \right\rfloor + 1\right)}{2} \right\rfloor + \left\lfloor \frac{target + target + n - \left\lfloor \frac{target}{2} \right\rfloor - 1}{2} \right\rfloor$.

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 ans;
return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
}
```

Expand Down
21 changes: 8 additions & 13 deletions solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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;
}
};
19 changes: 8 additions & 11 deletions solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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
}
20 changes: 8 additions & 12 deletions solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,16 +1,12 @@
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);
}
}
15 changes: 5 additions & 10 deletions solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,7 @@
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
16 changes: 5 additions & 11 deletions solution/2800-2899/2834.Find the Minimum Possible Sum of a Beautiful Array/Solution.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,14 +1,8 @@
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 ans;
return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
}
Loading