Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 1fc76a7

Browse files
feat: add solutions to lc problems: No.2945~2947 (doocs#2024)
* No.2945.Find Maximum Non-decreasing Array Length * No.2946.Matrix Similarity After Cyclic Shifts * No.2947.Count Beautiful Substrings I
1 parent ed9518c commit 1fc76a7

File tree

21 files changed

+819
-18
lines changed

21 files changed

+819
-18
lines changed

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/README.md‎

Lines changed: 99 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -66,27 +66,123 @@
6666
<!-- 这里可写当前语言的特殊实现逻辑 -->
6767

6868
```python
69-
69+
class Solution:
70+
def findMaximumLength(self, nums: List[int]) -> int:
71+
n = len(nums)
72+
s = list(accumulate(nums, initial=0))
73+
f = [0] * (n + 1)
74+
pre = [0] * (n + 2)
75+
for i in range(1, n + 1):
76+
pre[i] = max(pre[i], pre[i - 1])
77+
f[i] = f[pre[i]] + 1
78+
j = bisect_left(s, s[i] * 2 - s[pre[i]])
79+
pre[j] = i
80+
return f[n]
7081
```
7182

7283
### **Java**
7384

7485
<!-- 这里可写当前语言的特殊实现逻辑 -->
7586

7687
```java
77-
88+
class Solution {
89+
public int findMaximumLength(int[] nums) {
90+
int n = nums.length;
91+
long[] s = new long[n + 1];
92+
for (int i = 0; i < n; ++i) {
93+
s[i + 1] = s[i] + nums[i];
94+
}
95+
int[] f = new int[n + 1];
96+
int[] pre = new int[n + 2];
97+
for (int i = 1; i <= n; ++i) {
98+
pre[i] = Math.max(pre[i], pre[i - 1]);
99+
f[i] = f[pre[i]] + 1;
100+
int j = Arrays.binarySearch(s, s[i] * 2 - s[pre[i]]);
101+
pre[j < 0 ? -j - 1 : j] = i;
102+
}
103+
return f[n];
104+
}
105+
}
78106
```
79107

80108
### **C++**
81109

82110
```cpp
83-
111+
class Solution {
112+
public:
113+
int findMaximumLength(vector<int>& nums) {
114+
int n = nums.size();
115+
int f[n + 1];
116+
int pre[n + 2];
117+
long long s[n + 1];
118+
for (int i = 0; i < n; ++i) {
119+
s[i + 1] = s[i] + nums[i];
120+
}
121+
memset(f, 0, sizeof(f));
122+
memset(pre, 0, sizeof(pre));
123+
for (int i = 1; i <= n; ++i) {
124+
pre[i] = max(pre[i], pre[i - 1]);
125+
f[i] = f[pre[i]] + 1;
126+
int j = lower_bound(s, s + n + 1, s[i] * 2 - s[pre[i]]) - s;
127+
pre[j] = i;
128+
}
129+
return f[n];
130+
}
131+
};
84132
```
85133
86134
### **Go**
87135
88136
```go
137+
func findMaximumLength(nums []int) int {
138+
n := len(nums)
139+
f := make([]int, n+1)
140+
pre := make([]int, n+2)
141+
s := make([]int, n+1)
142+
for i, x := range nums {
143+
s[i+1] = s[i] + x
144+
}
145+
for i := 1; i <= n; i++ {
146+
pre[i] = max(pre[i], pre[i-1])
147+
f[i] = f[pre[i]] + 1
148+
j := sort.SearchInts(s, s[i]*2-s[pre[i]])
149+
pre[j] = max(pre[j], i)
150+
}
151+
return f[n]
152+
}
153+
```
89154

155+
### **TypeScript**
156+
157+
```ts
158+
function findMaximumLength(nums: number[]): number {
159+
const n = nums.length;
160+
const f: number[] = Array(n + 1).fill(0);
161+
const pre: number[] = Array(n + 2).fill(0);
162+
const s: number[] = Array(n + 1).fill(0);
163+
for (let i = 1; i <= n; ++i) {
164+
s[i] = s[i - 1] + nums[i - 1];
165+
}
166+
const search = (nums: number[], x: number): number => {
167+
let [l, r] = [0, nums.length];
168+
while (l < r) {
169+
const mid = (l + r) >> 1;
170+
if (nums[mid] >= x) {
171+
r = mid;
172+
} else {
173+
l = mid + 1;
174+
}
175+
}
176+
return l;
177+
};
178+
for (let i = 1; i <= n; ++i) {
179+
pre[i] = Math.max(pre[i], pre[i - 1]);
180+
f[i] = f[pre[i]] + 1;
181+
const j = search(s, s[i] * 2 - s[pre[i]]);
182+
pre[j] = i;
183+
}
184+
return f[n];
185+
}
90186
```
91187

92188
### **...**

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/README_EN.md‎

Lines changed: 99 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -58,25 +58,121 @@ Because the given array is not non-decreasing, the maximum<!-- notionvc: 3447a50
5858
### **Python3**
5959

6060
```python
61-
61+
class Solution:
62+
def findMaximumLength(self, nums: List[int]) -> int:
63+
n = len(nums)
64+
s = list(accumulate(nums, initial=0))
65+
f = [0] * (n + 1)
66+
pre = [0] * (n + 2)
67+
for i in range(1, n + 1):
68+
pre[i] = max(pre[i], pre[i - 1])
69+
f[i] = f[pre[i]] + 1
70+
j = bisect_left(s, s[i] * 2 - s[pre[i]])
71+
pre[j] = i
72+
return f[n]
6273
```
6374

6475
### **Java**
6576

6677
```java
67-
78+
class Solution {
79+
public int findMaximumLength(int[] nums) {
80+
int n = nums.length;
81+
long[] s = new long[n + 1];
82+
for (int i = 0; i < n; ++i) {
83+
s[i + 1] = s[i] + nums[i];
84+
}
85+
int[] f = new int[n + 1];
86+
int[] pre = new int[n + 2];
87+
for (int i = 1; i <= n; ++i) {
88+
pre[i] = Math.max(pre[i], pre[i - 1]);
89+
f[i] = f[pre[i]] + 1;
90+
int j = Arrays.binarySearch(s, s[i] * 2 - s[pre[i]]);
91+
pre[j < 0 ? -j - 1 : j] = i;
92+
}
93+
return f[n];
94+
}
95+
}
6896
```
6997

7098
### **C++**
7199

72100
```cpp
73-
101+
class Solution {
102+
public:
103+
int findMaximumLength(vector<int>& nums) {
104+
int n = nums.size();
105+
int f[n + 1];
106+
int pre[n + 2];
107+
long long s[n + 1];
108+
for (int i = 0; i < n; ++i) {
109+
s[i + 1] = s[i] + nums[i];
110+
}
111+
memset(f, 0, sizeof(f));
112+
memset(pre, 0, sizeof(pre));
113+
for (int i = 1; i <= n; ++i) {
114+
pre[i] = max(pre[i], pre[i - 1]);
115+
f[i] = f[pre[i]] + 1;
116+
int j = lower_bound(s, s + n + 1, s[i] * 2 - s[pre[i]]) - s;
117+
pre[j] = i;
118+
}
119+
return f[n];
120+
}
121+
};
74122
```
75123
76124
### **Go**
77125
78126
```go
127+
func findMaximumLength(nums []int) int {
128+
n := len(nums)
129+
f := make([]int, n+1)
130+
pre := make([]int, n+2)
131+
s := make([]int, n+1)
132+
for i, x := range nums {
133+
s[i+1] = s[i] + x
134+
}
135+
for i := 1; i <= n; i++ {
136+
pre[i] = max(pre[i], pre[i-1])
137+
f[i] = f[pre[i]] + 1
138+
j := sort.SearchInts(s, s[i]*2-s[pre[i]])
139+
pre[j] = max(pre[j], i)
140+
}
141+
return f[n]
142+
}
143+
```
79144

145+
### **TypeScript**
146+
147+
```ts
148+
function findMaximumLength(nums: number[]): number {
149+
const n = nums.length;
150+
const f: number[] = Array(n + 1).fill(0);
151+
const pre: number[] = Array(n + 2).fill(0);
152+
const s: number[] = Array(n + 1).fill(0);
153+
for (let i = 1; i <= n; ++i) {
154+
s[i] = s[i - 1] + nums[i - 1];
155+
}
156+
const search = (nums: number[], x: number): number => {
157+
let [l, r] = [0, nums.length];
158+
while (l < r) {
159+
const mid = (l + r) >> 1;
160+
if (nums[mid] >= x) {
161+
r = mid;
162+
} else {
163+
l = mid + 1;
164+
}
165+
}
166+
return l;
167+
};
168+
for (let i = 1; i <= n; ++i) {
169+
pre[i] = Math.max(pre[i], pre[i - 1]);
170+
f[i] = f[pre[i]] + 1;
171+
const j = search(s, s[i] * 2 - s[pre[i]]);
172+
pre[j] = i;
173+
}
174+
return f[n];
175+
}
80176
```
81177

82178
### **...**
Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution {
2+
public:
3+
int findMaximumLength(vector<int>& nums) {
4+
int n = nums.size();
5+
int f[n + 1];
6+
int pre[n + 2];
7+
long long s[n + 1];
8+
for (int i = 0; i < n; ++i) {
9+
s[i + 1] = s[i] + nums[i];
10+
}
11+
memset(f, 0, sizeof(f));
12+
memset(pre, 0, sizeof(pre));
13+
for (int i = 1; i <= n; ++i) {
14+
pre[i] = max(pre[i], pre[i - 1]);
15+
f[i] = f[pre[i]] + 1;
16+
int j = lower_bound(s, s + n + 1, s[i] * 2 - s[pre[i]]) - s;
17+
pre[j] = i;
18+
}
19+
return f[n];
20+
}
21+
};
Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
func findMaximumLength(nums []int) int {
2+
n := len(nums)
3+
f := make([]int, n+1)
4+
pre := make([]int, n+2)
5+
s := make([]int, n+1)
6+
for i, x := range nums {
7+
s[i+1] = s[i] + x
8+
}
9+
for i := 1; i <= n; i++ {
10+
pre[i] = max(pre[i], pre[i-1])
11+
f[i] = f[pre[i]] + 1
12+
j := sort.SearchInts(s, s[i]*2-s[pre[i]])
13+
pre[j] = max(pre[j], i)
14+
}
15+
return f[n]
16+
}
Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution {
2+
public int findMaximumLength(int[] nums) {
3+
int n = nums.length;
4+
long[] s = new long[n + 1];
5+
for (int i = 0; i < n; ++i) {
6+
s[i + 1] = s[i] + nums[i];
7+
}
8+
int[] f = new int[n + 1];
9+
int[] pre = new int[n + 2];
10+
for (int i = 1; i <= n; ++i) {
11+
pre[i] = Math.max(pre[i], pre[i - 1]);
12+
f[i] = f[pre[i]] + 1;
13+
int j = Arrays.binarySearch(s, s[i] * 2 - s[pre[i]]);
14+
pre[j < 0 ? -j - 1 : j] = i;
15+
}
16+
return f[n];
17+
}
18+
}
Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
class Solution:
2+
def findMaximumLength(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
s = list(accumulate(nums, initial=0))
5+
f = [0] * (n + 1)
6+
pre = [0] * (n + 2)
7+
for i in range(1, n + 1):
8+
pre[i] = max(pre[i], pre[i - 1])
9+
f[i] = f[pre[i]] + 1
10+
j = bisect_left(s, s[i] * 2 - s[pre[i]])
11+
pre[j] = i
12+
return f[n]
Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
function findMaximumLength(nums: number[]): number {
2+
const n = nums.length;
3+
const f: number[] = Array(n + 1).fill(0);
4+
const pre: number[] = Array(n + 2).fill(0);
5+
const s: number[] = Array(n + 1).fill(0);
6+
for (let i = 1; i <= n; ++i) {
7+
s[i] = s[i - 1] + nums[i - 1];
8+
}
9+
const search = (nums: number[], x: number): number => {
10+
let [l, r] = [0, nums.length];
11+
while (l < r) {
12+
const mid = (l + r) >> 1;
13+
if (nums[mid] >= x) {
14+
r = mid;
15+
} else {
16+
l = mid + 1;
17+
}
18+
}
19+
return l;
20+
};
21+
for (let i = 1; i <= n; ++i) {
22+
pre[i] = Math.max(pre[i], pre[i - 1]);
23+
f[i] = f[pre[i]] + 1;
24+
const j = search(s, s[i] * 2 - s[pre[i]]);
25+
pre[j] = i;
26+
}
27+
return f[n];
28+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /