给你一个数组 nums，我们可以将它按一个非负整数 k 进行轮调，这样可以使数组变为 [nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]] 的形式。此后，任何值小于或等于其索引的项都可以记作一分。
- 例如，数组为
nums = [2,4,1,3,0]，我们按k = 2进行轮调后，它将变成[1,3,0,2,4]。这将记为3分，因为1 > 0[不计分]、3 > 1[不计分]、0 <= 2[计 1 分]、2 <= 3[计 1 分]，4 <= 4[计 1 分]。
在所有可能的轮调中，返回我们所能得到的最高分数对应的轮调下标 k 。如果有多个答案，返回满足条件的最小的下标 k 。
示例 1：
输入：nums = [2,3,1,4,0] 输出：3 解释： 下面列出了每个 k 的得分： k = 0, nums = [2,3,1,4,0], score 2 k = 1, nums = [3,1,4,0,2], score 3 k = 2, nums = [1,4,0,2,3], score 3 k = 3, nums = [4,0,2,3,1], score 4 k = 4, nums = [0,2,3,1,4], score 3 所以我们应当选择 k = 3，得分最高。
示例 2：
输入：nums = [1,3,0,2,4] 输出：0 解释： nums 无论怎么变化总是有 3 分。 所以我们将选择最小的 k，即 0。
提示：
1 <= nums.length <= 10^50 <= nums[i] < nums.length
解法1：差分数组
最简单的做法是遍历每个可能的 k，计算轮调 k 个位置之后的数组得分。假设数组的长度是 n，则有 n 种可能的轮调，对于每种轮调都需要 O(n) 的时间计算得分，总时间复杂度是 O(n^2)，对于 n≤10^5 的数据范围会超出时间限制，因此需要优化。
对于数组 nums 中的元素 x，当 x 所在下标大于或等于 x 时，元素 x 会记 1 分。因此元素 x 记 1 分的下标范围是 [x,n−1]，有 n−x 个下标，元素 x 不计分的下标范围是 [0,x−1]，有 x 个下标。
假设元素 x 的初始下标为 i，则当轮调下标为 k 时，元素 x 位于下标 (i−k+n) mod n。如果元素 x 记 1 分，则有 (i−k+n) mod n ≥ x，等价于 k ≤ (i−x+n) mod n。由于元素 x 记 1 分的下标有 n−x 个，因此有 k >= (i - x + n - (n - x) + 1) mod n 即 k ≥ (i+1) mod n。
将取模运算去掉之后，可以得到 k 的实际取值范围：
- 当 i < x 时，i+1 ≤ k ≤ i−x+n；
- 当 i ≥ x 时，k ≥ i+1 或 k ≤ i−x。
对于数组 nums 中的每个元素，都可以根据元素值与元素所在下标计算该元素记 1 分的轮调下标范围。
遍历所有元素之后，即可得到每个轮调下标对应的计 1 分的元素个数，计 1 分的元素个数最多的轮调下标即为得分最高的轮调下标。如果存在多个得分最高的轮调下标，则取其中最小的轮调下标。
创建长度为 n 的数组 points，其中 points[k] 表示轮调下标为 k 时的得分。对于数组 nums 中的每个元素，得到该元素记 1 分的轮调下标范围，然后将数组 points 的该下标范围内的所有元素加 1。当数组 points 中的元素值确定后，找到最大元素的最小下标。该做法的时间复杂度仍然是 O(n^2)，为了降低时间复杂度，需要利用差分数组。
假设元素 x 的初始下标为 i。
当 i<x 时应将 points 的下标范围 [i+1,i−x+n] 内的所有元素加 1；
当 i≥x 时应将 points 的下标范围 [0,i−x] 和 [i+1,n−1] 内的所有元素加 1。
由于是将一段或两段连续下标范围内的元素加 1，因此可以使用差分数组实现。
定义长度为 n 的差分数组 diff，其中 diff[k]=points[k]−points[k−1]（特别地，points[−1]=0），具体做法是：
令 下界 low=(i+1) mod n，上界 high=(i−x+n + 1) mod n，将 diff[low] 的值加 1，将 diff[high] 的值减 1，如果 low > high 则将 diff[0] 的值加 1。
k 范围是 [上界,下届) ,即 [low, high)
遍历数组 nums 的所有元素并更新差分数组之后，遍历数组 diff 并计算前缀和，则每个下标处的前缀和表示当前轮调下标处的得分。在遍历过程中维护最大得分和最大得分的最小轮调下标，遍历结束之后即可得到结果。
实现方面，不需要显性创建数组 points，只需要创建差分数组 diff，遍历数组 diff 时即可根据前缀和得到数组 points 中的每个元素值。
证明
差分数组做法的正确性证明需要考虑 low 和 high 的不同情况。
如果 low < high < n，更新 diff 等价于将数组 points 的下标范围 [low,high - 1] 内的所有元素加 1。
如果 0 == high ≤ low，更新 diff 等价于将数组 points 的下标范围 [low,n−1] 内的所有元素加 1，diffs[0] 先减 1 后加 1 因此 diffs[0] 没有变化，同第 1 种情况。
如果 low >= high != 0，则需要将 diffs[0] 加 1，更新 diff 等价于将数组 points 的下标范围 [low,n−1] 和 [0,high - 1] 内的所有元素加 1。
上述三种情况对应的更新数组 points 的效果都符合预期，因此差分数组的做法可以得到正确的结果。
[上界，下界) 写法:
Java版：
class Solution {
public int bestRotation(int[] nums) {
int n = nums.length;
int[] diff = new int[n];
for (int i = 0; i < n; i++) {
int low = (i + 1) % n;
int high = (i - nums[i] + n + 1) % n;
diff[low]++;
diff[high]--;
if (low >= high) {
diff[0]++;
}
}
int score = 0;
int maxscore = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
score += diff[i];
if (score > maxscore) {
maxscore = score;
ans = i;
}
}
return ans;
}
}Python3版：
class Solution:
def bestRotation(self, nums: List[int]) -> int:
n = len(nums)
diff = [0] * n
for i in range(n):
low = (i + 1) % n
high = (i - nums[i] + n + 1) % n
diff[low] += 1
diff[high] -= 1
if low >= high:
diff[0] += 1
ans = 0
score = 0
maxscore = 0
for i in range(n):
score += diff[i]
if score > maxscore:
maxscore = score
ans = i
return ans复杂度分析
- 时间复杂度：O(n)，其中 n 是数组 nums 的长度。需要遍历数组 nums 两次。
- 空间复杂度：O(n)，其中 n 是数组 nums 的长度。需要创建长度为 n 的数组 diff。
[上界，下界] 写法:
1.注意：差分数组是对k的差分数组，不是对数组原位置的差分数组！！！
2.设nums数组长度为n，容易看出：对于nums[i]，得分的下标范围在[nums[i], n - 1]，闭区间长度为(n - nums[i]) 。而若进行k轮调，则 i --> (i - k + n) % n ， 此时位于下标 (i - k + n) % n 的元素值仍为nums[i]，若希望轮调完依然得分， 则需要满足(i - k + n) % n >= nums[i]。
（注意差分数组是针对k的差分数组，因此化简不等式要将k单独放在不等号一侧）
化简得到 k <= (i - nums[i] + n) % n，将这一值记为 k 对于 nums[i] 的上界。 由于上述我们已经求得了 nums[i] 这一元素得分区间的长度，且得到了 k 对于 nums[i] 的上界， 那么 k 的下界即可由区间长度和上界求得，下界为 k >= (i - nums[i] + n - (n - nums[i]) + 1) % n, 即 k >= (i + 1) % n 。
因此可知针对原数组 i 下标的nums[i]而言，k 取值 [(i + 1) % n, (i - nums[i] + n) % n]时得分。
3.建立长度为 n 的前缀数组 diff ，求原数组的每个元素的上下界并且令 diff[下界]++， diff[上界 + 1]--，
4.进行从头开始的for循环累加即可得到k取值[0, n - 1]的得分情况， 取下标最小的最大得分作为最终函数的返回值。
5.注意：上述我们求出的上下界并未考虑大小，很可能由于取余使得 下界 > 上界， 此时得分区间不再是[下界，上界]，而是 [0,上界] 和 [下界，n - 1] 两个区间， 因此进行必须 diff[0]++ 的操作，否则会出现起点在终点后的情况，会没开始加分就先减分。 (分类讨论可以通过画图辅助理解，上下界两个位置将 [0, n - 1] 分为三段)
Java版：
class Solution {
public int bestRotation(int[] nums) {
int n = nums.length;
int[] diff = new int[n];
for (int i = 0; i < n; i++) {
int low = (i + 1) % n;
int high = (i - nums[i] + n) % n;
diff[low]++;
diff[(high + 1) % n]--;
if (low > high) {
diff[0]++;
}
}
int ans = 0;
int score = 0;
int maxscore = 0;
for (int i = 0; i < n; i++) {
score += diff[i];
if (score > maxscore) {
maxscore = score;
ans = i;
}
}
return ans;
}
}Python3版：
class Solution:
def bestRotation(self, nums: List[int]) -> int:
n = len(nums)
diff = [0] * n
for i in range(n):
low = (i + 1) % n
high = (i - nums[i] + n) % n
diff[low] += 1
diff[(high + 1) % n] -= 1
if low > high:
diff[0] += 1
ans = 0
score = 0
maxscore = 0
for i in range(n):
score += diff[i]
if score > maxscore:
maxscore = score
ans = i
return ans复杂度分析
- 时间复杂度：O(n)，其中 n 是数组 nums 的长度。需要遍历数组 nums 两次。
- 空间复杂度：O(n)，其中 n 是数组 nums 的长度。需要创建长度为 n 的数组 diff。
581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
