Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit 8153c9b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3351 (doocs#3749)
No.3351.Sum of Good Subsequences
1 parent c599399 commit 8153c9b

File tree

7 files changed

+344
-6
lines changed

7 files changed

+344
-6
lines changed

‎solution/3300-3399/3351.Sum of Good Subsequences/README.md

Lines changed: 116 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -79,25 +79,138 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3351.Su
7979
#### Python3
8080

8181
```python
82-
82+
class Solution:
83+
def sumOfGoodSubsequences(self, nums: List[int]) -> int:
84+
mod = 10**9 + 7
85+
f = defaultdict(int)
86+
g = defaultdict(int)
87+
for x in nums:
88+
f[x] += x
89+
g[x] += 1
90+
f[x] += f[x - 1] + g[x - 1] * x
91+
g[x] += g[x - 1]
92+
f[x] += f[x + 1] + g[x + 1] * x
93+
g[x] += g[x + 1]
94+
return sum(f.values()) % mod
8395
```
8496

8597
#### Java
8698

8799
```java
88-
100+
class Solution {
101+
public int sumOfGoodSubsequences(int[] nums) {
102+
final int mod = (int) 1e9 + 7;
103+
int mx = 0;
104+
for (int x : nums) {
105+
mx = Math.max(mx, x);
106+
}
107+
long[] f = new long[mx + 1];
108+
long[] g = new long[mx + 1];
109+
for (int x : nums) {
110+
f[x] += x;
111+
g[x] += 1;
112+
if (x > 0) {
113+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
114+
g[x] = (g[x] + g[x - 1]) % mod;
115+
}
116+
if (x + 1 <= mx) {
117+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
118+
g[x] = (g[x] + g[x + 1]) % mod;
119+
}
120+
}
121+
long ans = 0;
122+
for (long x : f) {
123+
ans = (ans + x) % mod;
124+
}
125+
return (int) ans;
126+
}
127+
}
89128
```
90129

91130
#### C++
92131

93132
```cpp
94-
133+
class Solution {
134+
public:
135+
int sumOfGoodSubsequences(vector<int>& nums) {
136+
const int mod = 1e9 + 7;
137+
int mx = ranges::max(nums);
138+
139+
vector<long long> f(mx + 1), g(mx + 1);
140+
for (int x : nums) {
141+
f[x] += x;
142+
g[x] += 1;
143+
144+
if (x > 0) {
145+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
146+
g[x] = (g[x] + g[x - 1]) % mod;
147+
}
148+
149+
if (x + 1 <= mx) {
150+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
151+
g[x] = (g[x] + g[x + 1]) % mod;
152+
}
153+
}
154+
155+
return accumulate(f.begin(), f.end(), 0LL) % mod;
156+
}
157+
};
95158
```
96159

97160
#### Go
98161

99162
```go
163+
func sumOfGoodSubsequences(nums []int) (ans int) {
164+
mod := int(1e9 + 7)
165+
mx := slices.Max(nums)
166+
167+
f := make([]int, mx+1)
168+
g := make([]int, mx+1)
169+
170+
for _, x := range nums {
171+
f[x] += x
172+
g[x] += 1
173+
174+
if x > 0 {
175+
f[x] = (f[x] + f[x-1] + g[x-1]*x%mod) % mod
176+
g[x] = (g[x] + g[x-1]) % mod
177+
}
178+
179+
if x+1 <= mx {
180+
f[x] = (f[x] + f[x+1] + g[x+1]*x%mod) % mod
181+
g[x] = (g[x] + g[x+1]) % mod
182+
}
183+
}
184+
185+
for _, x := range f {
186+
ans = (ans + x) % mod
187+
}
188+
return
189+
}
190+
```
100191

192+
#### TypeScript
193+
194+
```ts
195+
function sumOfGoodSubsequences(nums: number[]): number {
196+
const mod = 10 ** 9 + 7;
197+
const mx = Math.max(...nums);
198+
const f: number[] = Array(mx + 1).fill(0);
199+
const g: number[] = Array(mx + 1).fill(0);
200+
for (const x of nums) {
201+
f[x] += x;
202+
g[x] += 1;
203+
if (x > 0) {
204+
f[x] = (f[x] + f[x - 1] + ((g[x - 1] * x) % mod)) % mod;
205+
g[x] = (g[x] + g[x - 1]) % mod;
206+
}
207+
if (x + 1 <= mx) {
208+
f[x] = (f[x] + f[x + 1] + ((g[x + 1] * x) % mod)) % mod;
209+
g[x] = (g[x] + g[x + 1]) % mod;
210+
}
211+
}
212+
return f.reduce((acc, cur) => (acc + cur) % mod, 0);
213+
}
101214
```
102215

103216
<!-- tabs:end -->

‎solution/3300-3399/3351.Sum of Good Subsequences/README_EN.md

Lines changed: 116 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -74,25 +74,138 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3351.Su
7474
#### Python3
7575

7676
```python
77-
77+
class Solution:
78+
def sumOfGoodSubsequences(self, nums: List[int]) -> int:
79+
mod = 10**9 + 7
80+
f = defaultdict(int)
81+
g = defaultdict(int)
82+
for x in nums:
83+
f[x] += x
84+
g[x] += 1
85+
f[x] += f[x - 1] + g[x - 1] * x
86+
g[x] += g[x - 1]
87+
f[x] += f[x + 1] + g[x + 1] * x
88+
g[x] += g[x + 1]
89+
return sum(f.values()) % mod
7890
```
7991

8092
#### Java
8193

8294
```java
83-
95+
class Solution {
96+
public int sumOfGoodSubsequences(int[] nums) {
97+
final int mod = (int) 1e9 + 7;
98+
int mx = 0;
99+
for (int x : nums) {
100+
mx = Math.max(mx, x);
101+
}
102+
long[] f = new long[mx + 1];
103+
long[] g = new long[mx + 1];
104+
for (int x : nums) {
105+
f[x] += x;
106+
g[x] += 1;
107+
if (x > 0) {
108+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
109+
g[x] = (g[x] + g[x - 1]) % mod;
110+
}
111+
if (x + 1 <= mx) {
112+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
113+
g[x] = (g[x] + g[x + 1]) % mod;
114+
}
115+
}
116+
long ans = 0;
117+
for (long x : f) {
118+
ans = (ans + x) % mod;
119+
}
120+
return (int) ans;
121+
}
122+
}
84123
```
85124

86125
#### C++
87126

88127
```cpp
89-
128+
class Solution {
129+
public:
130+
int sumOfGoodSubsequences(vector<int>& nums) {
131+
const int mod = 1e9 + 7;
132+
int mx = ranges::max(nums);
133+
134+
vector<long long> f(mx + 1), g(mx + 1);
135+
for (int x : nums) {
136+
f[x] += x;
137+
g[x] += 1;
138+
139+
if (x > 0) {
140+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
141+
g[x] = (g[x] + g[x - 1]) % mod;
142+
}
143+
144+
if (x + 1 <= mx) {
145+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
146+
g[x] = (g[x] + g[x + 1]) % mod;
147+
}
148+
}
149+
150+
return accumulate(f.begin(), f.end(), 0LL) % mod;
151+
}
152+
};
90153
```
91154

92155
#### Go
93156

94157
```go
158+
func sumOfGoodSubsequences(nums []int) (ans int) {
159+
mod := int(1e9 + 7)
160+
mx := slices.Max(nums)
161+
162+
f := make([]int, mx+1)
163+
g := make([]int, mx+1)
164+
165+
for _, x := range nums {
166+
f[x] += x
167+
g[x] += 1
168+
169+
if x > 0 {
170+
f[x] = (f[x] + f[x-1] + g[x-1]*x%mod) % mod
171+
g[x] = (g[x] + g[x-1]) % mod
172+
}
173+
174+
if x+1 <= mx {
175+
f[x] = (f[x] + f[x+1] + g[x+1]*x%mod) % mod
176+
g[x] = (g[x] + g[x+1]) % mod
177+
}
178+
}
179+
180+
for _, x := range f {
181+
ans = (ans + x) % mod
182+
}
183+
return
184+
}
185+
```
95186

187+
#### TypeScript
188+
189+
```ts
190+
function sumOfGoodSubsequences(nums: number[]): number {
191+
const mod = 10 ** 9 + 7;
192+
const mx = Math.max(...nums);
193+
const f: number[] = Array(mx + 1).fill(0);
194+
const g: number[] = Array(mx + 1).fill(0);
195+
for (const x of nums) {
196+
f[x] += x;
197+
g[x] += 1;
198+
if (x > 0) {
199+
f[x] = (f[x] + f[x - 1] + ((g[x - 1] * x) % mod)) % mod;
200+
g[x] = (g[x] + g[x - 1]) % mod;
201+
}
202+
if (x + 1 <= mx) {
203+
f[x] = (f[x] + f[x + 1] + ((g[x + 1] * x) % mod)) % mod;
204+
g[x] = (g[x] + g[x + 1]) % mod;
205+
}
206+
}
207+
return f.reduce((acc, cur) => (acc + cur) % mod, 0);
208+
}
96209
```
97210

98211
<!-- tabs:end -->

‎solution/3300-3399/3351.Sum of Good Subsequences/Solution.cpp

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
int sumOfGoodSubsequences(vector<int>& nums) {
4+
const int mod = 1e9 + 7;
5+
int mx = ranges::max(nums);
6+
7+
vector<long long> f(mx + 1), g(mx + 1);
8+
for (int x : nums) {
9+
f[x] += x;
10+
g[x] += 1;
11+
12+
if (x > 0) {
13+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
14+
g[x] = (g[x] + g[x - 1]) % mod;
15+
}
16+
17+
if (x + 1 <= mx) {
18+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
19+
g[x] = (g[x] + g[x + 1]) % mod;
20+
}
21+
}
22+
23+
return accumulate(f.begin(), f.end(), 0LL) % mod;
24+
}
25+
};

‎solution/3300-3399/3351.Sum of Good Subsequences/Solution.go

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
func sumOfGoodSubsequences(nums []int) (ans int) {
2+
mod := int(1e9 + 7)
3+
mx := slices.Max(nums)
4+
5+
f := make([]int, mx+1)
6+
g := make([]int, mx+1)
7+
8+
for _, x := range nums {
9+
f[x] += x
10+
g[x] += 1
11+
12+
if x > 0 {
13+
f[x] = (f[x] + f[x-1] + g[x-1]*x%mod) % mod
14+
g[x] = (g[x] + g[x-1]) % mod
15+
}
16+
17+
if x+1 <= mx {
18+
f[x] = (f[x] + f[x+1] + g[x+1]*x%mod) % mod
19+
g[x] = (g[x] + g[x+1]) % mod
20+
}
21+
}
22+
23+
for _, x := range f {
24+
ans = (ans + x) % mod
25+
}
26+
return
27+
}

‎solution/3300-3399/3351.Sum of Good Subsequences/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public int sumOfGoodSubsequences(int[] nums) {
3+
final int mod = (int) 1e9 + 7;
4+
int mx = 0;
5+
for (int x : nums) {
6+
mx = Math.max(mx, x);
7+
}
8+
long[] f = new long[mx + 1];
9+
long[] g = new long[mx + 1];
10+
for (int x : nums) {
11+
f[x] += x;
12+
g[x] += 1;
13+
if (x > 0) {
14+
f[x] = (f[x] + f[x - 1] + g[x - 1] * x % mod) % mod;
15+
g[x] = (g[x] + g[x - 1]) % mod;
16+
}
17+
if (x + 1 <= mx) {
18+
f[x] = (f[x] + f[x + 1] + g[x + 1] * x % mod) % mod;
19+
g[x] = (g[x] + g[x + 1]) % mod;
20+
}
21+
}
22+
long ans = 0;
23+
for (long x : f) {
24+
ans = (ans + x) % mod;
25+
}
26+
return (int) ans;
27+
}
28+
}

‎solution/3300-3399/3351.Sum of Good Subsequences/Solution.py

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
class Solution:
2+
def sumOfGoodSubsequences(self, nums: List[int]) -> int:
3+
mod = 10**9 + 7
4+
f = defaultdict(int)
5+
g = defaultdict(int)
6+
for x in nums:
7+
f[x] += x
8+
g[x] += 1
9+
f[x] += f[x - 1] + g[x - 1] * x
10+
g[x] += g[x - 1]
11+
f[x] += f[x + 1] + g[x + 1] * x
12+
g[x] += g[x + 1]
13+
return sum(f.values()) % mod

0 commit comments

Comments
 (0)