Skip to content

Commit ad3e569

Browse files
yanglbmeyanglbme
authored
feat: add solutions for lc No.3833,3834 (#5021)
1 parent 5844478 commit ad3e569

File tree

14 files changed

+424
-16
lines changed

14 files changed

+424
-16
lines changed

‎solution/3800-3899/3833.Count Dominant Indices/README.md‎

Lines changed: 72 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -73,32 +73,100 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3833.Co
7373

7474
<!-- solution:start -->
7575

76-
### 方法一
76+
### 方法一：逆序遍历
77+
78+
我们可以从后向前遍历数组，维护一个后缀和 $\text{suf}$，表示当前元素右侧所有元素的和。对于每个元素，判断其是否大于右侧元素的平均值 $\frac{\text{suf}}{n - i - 1}$，如果是，则将答案加一。最后返回答案即可。
79+
80+
时间复杂度 $O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。空间复杂度 $O(1)$。
7781

7882
<!-- tabs:start -->
7983

8084
#### Python3
8185

8286
```python
83-
87+
class Solution:
88+
def dominantIndices(self, nums: List[int]) -> int:
89+
n = len(nums)
90+
ans = 0
91+
suf = nums[-1]
92+
for i in range(n - 2, -1, -1):
93+
if nums[i] > suf / (n - i - 1):
94+
ans += 1
95+
suf += nums[i]
96+
return ans
8497
```
8598

8699
#### Java
87100

88101
```java
89-
102+
class Solution {
103+
public int dominantIndices(int[] nums) {
104+
int n = nums.length;
105+
int ans = 0;
106+
int suf = nums[n - 1];
107+
for (int i = n - 2; i >= 0; --i) {
108+
if (nums[i] * (n - i - 1) > suf) {
109+
ans++;
110+
}
111+
suf += nums[i];
112+
}
113+
return ans;
114+
}
115+
}
90116
```
91117

92118
#### C++
93119

94120
```cpp
95-
121+
class Solution {
122+
public:
123+
int dominantIndices(vector<int>& nums) {
124+
int n = nums.size();
125+
int ans = 0;
126+
int suf = nums[n - 1];
127+
for (int i = n - 2; i >= 0; --i) {
128+
if (nums[i] * (n - i - 1) > suf) {
129+
ans++;
130+
}
131+
suf += nums[i];
132+
}
133+
return ans;
134+
}
135+
};
96136
```
97137
98138
#### Go
99139
100140
```go
141+
func dominantIndices(nums []int) int {
142+
n := len(nums)
143+
ans := 0
144+
suf := nums[n-1]
145+
for i := n - 2; i >= 0; i-- {
146+
if nums[i]*(n-i-1) > suf {
147+
ans++
148+
}
149+
suf += nums[i]
150+
}
151+
return ans
152+
}
153+
```
101154

155+
#### TypeScript
156+
157+
```ts
158+
function dominantIndices(nums: number[]): number {
159+
const n = nums.length;
160+
let ans = 0;
161+
let suf = nums[n - 1];
162+
for (let i = n - 2; i >= 0; --i) {
163+
if (nums[i] * (n - i - 1) > suf) {
164+
ans++;
165+
}
166+
suf += nums[i];
167+
}
168+
return ans;
169+
}
102170
```
103171

104172
<!-- tabs:end -->

‎solution/3800-3899/3833.Count Dominant Indices/README_EN.md‎

Lines changed: 72 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -71,32 +71,100 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3833.Co
7171

7272
<!-- solution:start -->
7373

74-
### Solution 1
74+
### Solution 1: Reverse Traversal
75+
76+
We can traverse the array from back to front, maintaining a suffix sum $\text{suf}$, which represents the sum of all elements to the right of the current element. For each element, we check if it is greater than the average value of the elements to its right $\frac{\text{suf}}{n - i - 1}$. If so, we increment the answer by one. Finally, we return the answer.
77+
78+
The time complexity is $O(n)$, where $n$ is the length of the array $\text{nums}$. The space complexity is $O(1)$.
7579

7680
<!-- tabs:start -->
7781

7882
#### Python3
7983

8084
```python
81-
85+
class Solution:
86+
def dominantIndices(self, nums: List[int]) -> int:
87+
n = len(nums)
88+
ans = 0
89+
suf = nums[-1]
90+
for i in range(n - 2, -1, -1):
91+
if nums[i] > suf / (n - i - 1):
92+
ans += 1
93+
suf += nums[i]
94+
return ans
8295
```
8396

8497
#### Java
8598

8699
```java
87-
100+
class Solution {
101+
public int dominantIndices(int[] nums) {
102+
int n = nums.length;
103+
int ans = 0;
104+
int suf = nums[n - 1];
105+
for (int i = n - 2; i >= 0; --i) {
106+
if (nums[i] * (n - i - 1) > suf) {
107+
ans++;
108+
}
109+
suf += nums[i];
110+
}
111+
return ans;
112+
}
113+
}
88114
```
89115

90116
#### C++
91117

92118
```cpp
93-
119+
class Solution {
120+
public:
121+
int dominantIndices(vector<int>& nums) {
122+
int n = nums.size();
123+
int ans = 0;
124+
int suf = nums[n - 1];
125+
for (int i = n - 2; i >= 0; --i) {
126+
if (nums[i] * (n - i - 1) > suf) {
127+
ans++;
128+
}
129+
suf += nums[i];
130+
}
131+
return ans;
132+
}
133+
};
94134
```
95135
96136
#### Go
97137
98138
```go
139+
func dominantIndices(nums []int) int {
140+
n := len(nums)
141+
ans := 0
142+
suf := nums[n-1]
143+
for i := n - 2; i >= 0; i-- {
144+
if nums[i]*(n-i-1) > suf {
145+
ans++
146+
}
147+
suf += nums[i]
148+
}
149+
return ans
150+
}
151+
```
99152

153+
#### TypeScript
154+
155+
```ts
156+
function dominantIndices(nums: number[]): number {
157+
const n = nums.length;
158+
let ans = 0;
159+
let suf = nums[n - 1];
160+
for (let i = n - 2; i >= 0; --i) {
161+
if (nums[i] * (n - i - 1) > suf) {
162+
ans++;
163+
}
164+
suf += nums[i];
165+
}
166+
return ans;
167+
}
100168
```
101169

102170
<!-- tabs:end -->

‎solution/3800-3899/3833.Count Dominant Indices/Solution.cpp‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public:
3+
int dominantIndices(vector<int>& nums) {
4+
int n = nums.size();
5+
int ans = 0;
6+
int suf = nums[n - 1];
7+
for (int i = n - 2; i >= 0; --i) {
8+
if (nums[i] * (n - i - 1) > suf) {
9+
ans++;
10+
}
11+
suf += nums[i];
12+
}
13+
return ans;
14+
}
15+
};

‎solution/3800-3899/3833.Count Dominant Indices/Solution.go‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
func dominantIndices(nums []int) int {
2+
n := len(nums)
3+
ans := 0
4+
suf := nums[n-1]
5+
for i := n - 2; i >= 0; i-- {
6+
if nums[i]*(n-i-1) > suf {
7+
ans++
8+
}
9+
suf += nums[i]
10+
}
11+
return ans
12+
}

‎solution/3800-3899/3833.Count Dominant Indices/Solution.java‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public int dominantIndices(int[] nums) {
3+
int n = nums.length;
4+
int ans = 0;
5+
int suf = nums[n - 1];
6+
for (int i = n - 2; i >= 0; --i) {
7+
if (nums[i] * (n - i - 1) > suf) {
8+
ans++;
9+
}
10+
suf += nums[i];
11+
}
12+
return ans;
13+
}
14+
}

‎solution/3800-3899/3833.Count Dominant Indices/Solution.py‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def dominantIndices(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
ans = 0
5+
suf = nums[-1]
6+
for i in range(n - 2, -1, -1):
7+
if nums[i] > suf / (n - i - 1):
8+
ans += 1
9+
suf += nums[i]
10+
return ans

‎solution/3800-3899/3833.Count Dominant Indices/Solution.ts‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
function dominantIndices(nums: number[]): number {
2+
const n = nums.length;
3+
let ans = 0;
4+
let suf = nums[n - 1];
5+
for (let i = n - 2; i >= 0; --i) {
6+
if (nums[i] * (n - i - 1) > suf) {
7+
ans++;
8+
}
9+
suf += nums[i];
10+
}
11+
return ans;
12+
}

‎solution/3800-3899/3834.Merge Adjacent Equal Elements/README.md‎

Lines changed: 76 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -87,32 +87,104 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3834.Me
8787

8888
<!-- solution:start -->
8989

90-
### 方法一
90+
### 方法一：栈
91+
92+
我们可以使用栈来模拟合并相邻且相等元素的过程。
93+
94+
定义一个栈 $\textit{stk}$，用于存储当前处理后的数组元素。遍历输入数组 $\textit{nums}$ 的每个元素 $x$，将其压入栈中。然后检查栈顶的两个元素是否相等，如果相等，则将它们弹出并将它们的和重新压入栈中。重复此过程，直到栈顶的两个元素不再相等。最后，栈中的元素即为合并后的最终数组。
95+
96+
时间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。空间复杂度 $O(n)$，用于存储栈中的元素。
9197

9298
<!-- tabs:start -->
9399

94100
#### Python3
95101

96102
```python
97-
103+
class Solution:
104+
def mergeAdjacent(self, nums: List[int]) -> List[int]:
105+
stk = []
106+
for x in nums:
107+
stk.append(x)
108+
while len(stk) > 1 and stk[-1] == stk[-2]:
109+
stk.append(stk.pop() + stk.pop())
110+
return stk
98111
```
99112

100113
#### Java
101114

102115
```java
103-
116+
class Solution {
117+
public List<Long> mergeAdjacent(int[] nums) {
118+
List<Long> stk = new ArrayList<>();
119+
for (int x : nums) {
120+
stk.add((long) x);
121+
while (stk.size() > 1 && stk.get(stk.size() - 1).equals(stk.get(stk.size() - 2))) {
122+
long a = stk.remove(stk.size() - 1);
123+
long b = stk.remove(stk.size() - 1);
124+
stk.add(a + b);
125+
}
126+
}
127+
return stk;
128+
}
129+
}
104130
```
105131

106132
#### C++
107133

108134
```cpp
109-
135+
class Solution {
136+
public:
137+
vector<long long> mergeAdjacent(vector<int>& nums) {
138+
vector<long long> stk;
139+
for (int x : nums) {
140+
stk.push_back(x);
141+
while (stk.size() > 1 && stk.back() == stk[stk.size() - 2]) {
142+
long long a = stk.back();
143+
stk.pop_back();
144+
long long b = stk.back();
145+
stk.pop_back();
146+
stk.push_back(a + b);
147+
}
148+
}
149+
return stk;
150+
}
151+
};
110152
```
111153
112154
#### Go
113155
114156
```go
157+
func mergeAdjacent(nums []int) []int64 {
158+
stk := []int64{}
159+
for _, x := range nums {
160+
stk = append(stk, int64(x))
161+
for len(stk) > 1 && stk[len(stk)-1] == stk[len(stk)-2] {
162+
a := stk[len(stk)-1]
163+
stk = stk[:len(stk)-1]
164+
b := stk[len(stk)-1]
165+
stk = stk[:len(stk)-1]
166+
stk = append(stk, a+b)
167+
}
168+
}
169+
return stk
170+
}
171+
```
115172

173+
#### TypeScript
174+
175+
```ts
176+
function mergeAdjacent(nums: number[]): number[] {
177+
const stk: number[] = [];
178+
for (const x of nums) {
179+
stk.push(x);
180+
while (stk.length > 1 && stk.at(-1)! === stk.at(-2)!) {
181+
const a = stk.pop()!;
182+
const b = stk.pop()!;
183+
stk.push(a + b);
184+
}
185+
}
186+
return stk;
187+
}
116188
```
117189

118190
<!-- tabs:end -->

0 commit comments

Comments
 (0)