Skip to content

Commit fd3315d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0798
No.0798.Smallest Rotation with Highest Score
1 parent 4927623 commit fd3315d

File tree

6 files changed

+271
-2
lines changed

6 files changed

+271
-2
lines changed

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/README.md

+96-1
Original file line numberDiff line numberDiff line change
@@ -49,22 +49,117 @@ A 无论怎么变化总是有 3 分。
4949

5050
<!-- 这里可写通用的实现逻辑 -->
5151

52+
差分数组。
53+
54+
对于每个数，都有一个固定的 k 生效区间。我们先利用差分，预处理每个数的 k 生效区间。有最多个数能覆盖到的 k 即是答案。
55+
5256
<!-- tabs:start -->
5357

5458
### **Python3**
5559

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

5862
```python
59-
63+
class Solution:
64+
def bestRotation(self, nums: List[int]) -> int:
65+
n = len(nums)
66+
mx, ans = -1, n
67+
d = [0] * n
68+
for i, v in enumerate(nums):
69+
l, r = (i + 1) % n, (n + i + 1 - v) % n
70+
d[l] += 1
71+
d[r] -= 1
72+
s = 0
73+
for k, t in enumerate(d):
74+
s += t
75+
if s > mx:
76+
mx = s
77+
ans = k
78+
return ans
6079
```
6180

6281
### **Java**
6382

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

6685
```java
86+
class Solution {
87+
public int bestRotation(int[] nums) {
88+
int n = nums.length;
89+
int[] d = new int[n];
90+
for (int i = 0; i < n; ++i) {
91+
int l = (i + 1) % n;
92+
int r = (n + i + 1 - nums[i]) % n;
93+
++d[l];
94+
--d[r];
95+
}
96+
int mx = -1;
97+
int s = 0;
98+
int ans = n;
99+
for (int k = 0; k < n; ++k) {
100+
s += d[k];
101+
if (s > mx) {
102+
mx = s;
103+
ans = k;
104+
}
105+
}
106+
return ans;
107+
}
108+
}
109+
```
110+
111+
### **C++**
112+
113+
```cpp
114+
class Solution {
115+
public:
116+
int bestRotation(vector<int>& nums) {
117+
int n = nums.size();
118+
int mx = -1, ans = n;
119+
vector<int> d(n);
120+
for (int i = 0; i < n; ++i)
121+
{
122+
int l = (i + 1) % n;
123+
int r = (n + i + 1 - nums[i]) % n;
124+
++d[l];
125+
--d[r];
126+
}
127+
int s = 0;
128+
for (int k = 0; k < n; ++k)
129+
{
130+
s += d[k];
131+
if (s > mx)
132+
{
133+
mx = s;
134+
ans = k;
135+
}
136+
}
137+
return ans;
138+
}
139+
};
140+
```
67141
142+
### **Go**
143+
144+
```go
145+
func bestRotation(nums []int) int {
146+
n := len(nums)
147+
d := make([]int, n)
148+
for i, v := range nums {
149+
l, r := (i+1)%n, (n+i+1-v)%n
150+
d[l]++
151+
d[r]--
152+
}
153+
mx, ans, s := -1, n, 0
154+
for k, t := range d {
155+
s += t
156+
if s > mx {
157+
mx = s
158+
ans = k
159+
}
160+
}
161+
return ans
162+
}
68163
```
69164

70165
### **...**

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/README_EN.md

+92-1
Original file line numberDiff line numberDiff line change
@@ -66,13 +66,104 @@ So we will choose the smallest K, which is 0.
6666
### **Python3**
6767

6868
```python
69-
69+
class Solution:
70+
def bestRotation(self, nums: List[int]) -> int:
71+
n = len(nums)
72+
mx, ans = -1, n
73+
d = [0] * n
74+
for i, v in enumerate(nums):
75+
l, r = (i + 1) % n, (n + i + 1 - v) % n
76+
d[l] += 1
77+
d[r] -= 1
78+
s = 0
79+
for k, t in enumerate(d):
80+
s += t
81+
if s > mx:
82+
mx = s
83+
ans = k
84+
return ans
7085
```
7186

7287
### **Java**
7388

7489
```java
90+
class Solution {
91+
public int bestRotation(int[] nums) {
92+
int n = nums.length;
93+
int[] d = new int[n];
94+
for (int i = 0; i < n; ++i) {
95+
int l = (i + 1) % n;
96+
int r = (n + i + 1 - nums[i]) % n;
97+
++d[l];
98+
--d[r];
99+
}
100+
int mx = -1;
101+
int s = 0;
102+
int ans = n;
103+
for (int k = 0; k < n; ++k) {
104+
s += d[k];
105+
if (s > mx) {
106+
mx = s;
107+
ans = k;
108+
}
109+
}
110+
return ans;
111+
}
112+
}
113+
```
114+
115+
### **C++**
116+
117+
```cpp
118+
class Solution {
119+
public:
120+
int bestRotation(vector<int>& nums) {
121+
int n = nums.size();
122+
int mx = -1, ans = n;
123+
vector<int> d(n);
124+
for (int i = 0; i < n; ++i)
125+
{
126+
int l = (i + 1) % n;
127+
int r = (n + i + 1 - nums[i]) % n;
128+
++d[l];
129+
--d[r];
130+
}
131+
int s = 0;
132+
for (int k = 0; k < n; ++k)
133+
{
134+
s += d[k];
135+
if (s > mx)
136+
{
137+
mx = s;
138+
ans = k;
139+
}
140+
}
141+
return ans;
142+
}
143+
};
144+
```
75145
146+
### **Go**
147+
148+
```go
149+
func bestRotation(nums []int) int {
150+
n := len(nums)
151+
d := make([]int, n)
152+
for i, v := range nums {
153+
l, r := (i+1)%n, (n+i+1-v)%n
154+
d[l]++
155+
d[r]--
156+
}
157+
mx, ans, s := -1, n, 0
158+
for k, t := range d {
159+
s += t
160+
if s > mx {
161+
mx = s
162+
ans = k
163+
}
164+
}
165+
return ans
166+
}
76167
```
77168

78169
### **...**

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int bestRotation(vector<int>& nums) {
4+
int n = nums.size();
5+
int mx = -1, ans = n;
6+
vector<int> d(n);
7+
for (int i = 0; i < n; ++i)
8+
{
9+
int l = (i + 1) % n;
10+
int r = (n + i + 1 - nums[i]) % n;
11+
++d[l];
12+
--d[r];
13+
}
14+
int s = 0;
15+
for (int k = 0; k < n; ++k)
16+
{
17+
s += d[k];
18+
if (s > mx)
19+
{
20+
mx = s;
21+
ans = k;
22+
}
23+
}
24+
return ans;
25+
}
26+
};

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/Solution.go

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
func bestRotation(nums []int) int {
2+
n := len(nums)
3+
d := make([]int, n)
4+
for i, v := range nums {
5+
l, r := (i+1)%n, (n+i+1-v)%n
6+
d[l]++
7+
d[r]--
8+
}
9+
mx, ans, s := -1, n, 0
10+
for k, t := range d {
11+
s += t
12+
if s > mx {
13+
mx = s
14+
ans = k
15+
}
16+
}
17+
return ans
18+
}

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/Solution.java

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public int bestRotation(int[] nums) {
3+
int n = nums.length;
4+
int[] d = new int[n];
5+
for (int i = 0; i < n; ++i) {
6+
int l = (i + 1) % n;
7+
int r = (n + i + 1 - nums[i]) % n;
8+
++d[l];
9+
--d[r];
10+
}
11+
int mx = -1;
12+
int s = 0;
13+
int ans = n;
14+
for (int k = 0; k < n; ++k) {
15+
s += d[k];
16+
if (s > mx) {
17+
mx = s;
18+
ans = k;
19+
}
20+
}
21+
return ans;
22+
}
23+
}

Diff for: ‎solution/0700-0799/0798.Smallest Rotation with Highest Score/Solution.py

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution:
2+
def bestRotation(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
mx, ans = -1, n
5+
d = [0] * n
6+
for i, v in enumerate(nums):
7+
l, r = (i + 1) % n, (n + i + 1 - v) % n
8+
d[l] += 1
9+
d[r] -= 1
10+
s = 0
11+
for k, t in enumerate(d):
12+
s += t
13+
if s > mx:
14+
mx = s
15+
ans = k
16+
return ans

0 commit comments

Comments
 (0)