Skip to content

Commit 1fc76a7

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.2945~2947 (#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

+99-3
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

+99-3
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
### **...**

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/Solution.cpp

+21
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+
};

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/Solution.go

+16
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+
}

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/Solution.java

+18
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+
}

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/Solution.py

+12
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]

‎solution/2900-2999/2945.Find Maximum Non-decreasing Array Length/Solution.ts

+28
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)