数组题目：得分最高的最小轮调

题目

标题和出处

标题：得分最高的最小轮调

出处：798. 得分最高的最小轮调

难度

8 级

题目描述

要求

给定一个数组 $\text{nums}$，我们可以将它按一个非负整数 $\text{k}$ 进行轮调，这样可以使数组变为 $\text{nums[k], nums[k + 1], nums[k + 2], …, nums[nums.length - 1], nums[0], nums[1], …, nums[k - 1]}$ 的形式。此后，任何值小于或等于其索引的项都可以计 $\text{1}$ 分。

• 例如，如果数组为 $\text{[2, 4, 1, 3, 0]}$，我们按 $\text{k = 2}$ 进行轮调后，它将变成 $\text{[1, 3, 0, 2, 4]}$。这将计 $\text{3}$ 分，因为 $\text{1}>\text{0}$（$\text{0}$ 分），$\text{3}>\text{1}$（$\text{0}$ 分），$\text{0}\le \text{2}$（$\text{1}$ 分），$\text{2}\le \text{3}$（$\text{1}$ 分），$\text{4}\le \text{4}$（$\text{1}$ 分）。

在所有可能的轮调中，返回我们所能得到的最高分数对应的轮调索引 $\text{k}$。如果有多个答案，返回满足条件的最小的索引 $\text{k}$。

示例

示例 1：

输入：$\text{nums = [2,3,1,4,0]}$
输出：$\text{3}$
解释：
下面列出了每个 $\text{k}$ 的得分：
$\text{k = 0}$，$\text{nums = [2,3,1,4,0]}$，$\text{2}$ 分
$\text{k = 1}$，$\text{nums = [3,1,4,0,2]}$，$\text{3}$ 分
$\text{k = 2}$，$\text{nums = [1,4,0,2,3]}$，$\text{3}$ 分
$\text{k = 3}$，$\text{nums = [4,0,2,3,1]}$，$\text{4}$ 分
$\text{k = 4}$，$\text{nums = [0,2,3,1,4]}$，$\text{3}$ 分
所以我们应当选择 $\text{k = 3}$，得分最高。

示例 2：

输入：$\text{nums = [1,3,0,2,4]}$
输出：$\text{0}$
解释：$\text{nums}$ 无论怎么变化总是有 $\text{3}$ 分。所以我们将选择最小的 $\text{k}$，即 $\text{0}$。

数据范围

• $\text{1}\le \text{nums.length}\le {\text{10}}^{\text{5}}$
• $\text{0}\le \text{nums[i]}<\text{nums.length}$

解法

思路和算法

最直观的做法是对所有可能的轮调分别计算得分，记录最高得分和最高得分对应的轮调索引。当数组 $\text{nums}$ 的长度为 $n$ 时，共有 $n$ 种可能的轮调，对于每种轮调计算得分需要 $O(n)$ 的时间，因此总时间复杂度为 $O(n^2)$，会超出时间限制，因此必须优化。

对于数组 $\text{nums}$ 中的元素 $x$，只有当 $x$ 的索引大于或等于 $x$ 时，$x$ 才会计 $1$ 分，因此 $x$ 的索引在 $[x,n-1]$ 范围内时会计 $1$ 分，该范围的长度为 $n-x$，即有 $n-x$ 个轮调使得 $x$ 计 $1$ 分，其余 $x$ 个轮调使得 $x$ 不计分。

如果初始时，$x$ 位于索引 $i$，即 $\text{nums}[i]=x$，则当轮调索引为 $k$ 时，$x$ 将位于索引 $(i-k+n)\mathrm{m}\mathrm{o}\mathrm{d}n$。当 $(i-k+n)\mathrm{m}\mathrm{o}\mathrm{d}n\ge x$ 时，$x$ 将会计 $1$ 分。

将上述不等式进行转换可以得到：当 $x$ 计 $1$ 分时，轮调索引 $k$ 应满足 $k\le (i-x+n)\mathrm{m}\mathrm{o}\mathrm{d}n$。又由于使得 $x$ 计 $1$ 分的 $k$ 有 $n-x$ 个取值，因此当 $x$ 计 $1$ 分时，有 $k\ge (i+1)\mathrm{m}\mathrm{o}\mathrm{d}n$。

由于上述 $k$ 的表示有取余运算，因此 $k$ 的实际取值范围由 $x$、$i$ 和 $n$ 决定：

• 当 $i<x$ 时，$i+1\le k\le i+n-x$；

• 当 $i\ge x$ 时，$k\ge i+1$ 或 $k\le i-x$。

对于数组 $\text{nums}$ 中的任意元素 $x$，都可以得到 $x$ 计 $1$ 分的轮调索引范围。只要找到数组 $\text{nums}$ 中的每一个元素对应的计 $1$ 分的轮调索引范围，然后在所有轮调索引中找到计 $1$ 分的次数最多的轮调索引，即为得分最高的轮调索引。如果存在多个得分最高的轮调索引，则取其中的最小轮调索引。

创建长度为 $n$ 的数组 $\text{points}$，其中 $\text{points}[k]$ 表示轮调索引为 $k$ 时的得分。为了优化时间复杂度，可以使用差分数组的做法计算 $\text{points}$ 的每个元素值，具体做法如下：

1. 遍历数组 $\text{nums}$，对于 $\text{nums}[i]=x$，令 $\text{low}=(i+1)\mathrm{m}\mathrm{o}\mathrm{d}n$，$\text{high}=(i+n-x+1)\mathrm{m}\mathrm{o}\mathrm{d}n$，然后将 $\text{points}[\text{low}]$ 的值加 $1$，将 $\text{points}[\text{high}]$ 的值减 $1$，如果 $\text{low}\ge \text{high}$，则再将 $\text{points}[0]$ 的值加 $1$；

2. 维护最高得分和最高得分下标，初始值都是 $0$，遍历数组 $\text{points}$ 并计算其前缀和，使用前缀和更新最高得分和最高得分下标。遍历结束时即可得到最高得分，此时的最高得分下标即为得分最高的最小轮调索引。

上述差分数组的做法的正确性说明如下：

• 对于数组 $\text{nums}$ 中的任意元素 $x$，如果 $x$ 计 $1$ 分的轮调索引范围是连续的，则该范围是 $[i+1,i+n-x]$，等价于 $[\text{low},\text{high}-1]$（当 $\text{high}\ne 0$ 时）或 $[\text{low},n-1]$（当 $\text{high}=0$ 时），将 $\text{points}[\text{low}]$ 的值加 $1$，当 $\text{high}>\text{low}$ 时将 $\text{points}[\text{high}]$ 的值减 $1$，然后更新前缀和，该范围内的得分都会加 $1$，该范围外的得分都不变；

• 对于数组 $\text{nums}$ 中的任意元素 $x$，如果 $x$ 计 $1$ 分的轮调索引范围是不连续的，则该范围是 $[0,i-x]\cup [i+1,n-1]$，等价于 $[0,\text{high}-1]\cup [\text{low},n-1]$，将 $\text{points}[0]$ 和 $\text{points}[\text{low}]$ 的值分别加 $1$，将 $\text{points}[\text{high}]$ 的值减 $1$，然后更新前缀和，该范围内的得分都会加 $1$，该范围外的得分都不变。

代码

class Solution {
    public int bestRotation(int[] nums) {
        int length = nums.length;
        int[] points = new int[length];
        for (int i = 0; i < length; i++) {
            int low = (i + 1) % length;
            int high = (i + length - nums[i] + 1) % length;
            points[low]++;
            points[high]--;
            if (low >= high) {
                points[0]++;
            }
        }
        int maxIndex = 0;
        int maxScore = 0;
        int curScore = 0;
        for (int i = 0; i < length; i++) {
            curScore += points[i];
            if (curScore > maxScore) {
                maxIndex = i;
                maxScore = curScore;
            }
        }
        return maxIndex;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。整个过程需要遍历数组 $\text{nums}$ 两次。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要创建一个长度为 $n$ 的数组 $\text{points}$。