【798. 得分最高的最小轮调】

798. 得分最高的最小轮调

题目描述

给你一个数组 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 。

最简单的做法是遍历每个可能的$k$，计算轮调 $k$ 个位置之后的数组得分。假设数组的长度是 $n$，则有 $n$ 种可能的轮调，对于每种轮调都需要 $O(n)$ 的时间计算得分，总时间复杂度是$O(n^2)$，对于 $n\le 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)\text{mod}n$。如果元素 xxx 记 111 分，则有$(i-k+n)\text{mod}n\ge x$，等价于 $k\le (i-x+n)\text{mod}n$。下面分两种情况来讨论：

• $i<x$

  • 若$k<=i$，因为$k\ge 0$，而下标$k$的元素被轮调到下标$0$处，那么由轮调定义，原来在下标$i$的$x$被轮调到下标$i-k$处，易得$(i-k)\in [0,i]$，此时元素$x$的得分是0。所以要求元素$x$的得分是$1$的轮调$k$必须满足$k\ge i+1$。
  • $k\le (i-x+n)\text{mod}n$ 等价于 $k\le (i-x+n)$。

  由上述得，当$i<x$时，使得元素$x$得分为$1$的$k$的取值范围为$i+1\le k\le i-x+n$。

  

• $i\ge x$

  在$i$的元素$x$有两种移动方式，都能使得元素$x$的得分为$1$

  • 当元素$x$向右移动，此时$x$能达到的最远位置为$n-1$，且在$k$轮调时，这个位置是原始位置$k-1$处的元素占据，那么容易有$k-1=i$，那么$k=i+1$,当$k>i+1$时，元素$x$仍然会在$[i,n-2]$的某个位置，所以$k\ge i+1$都会是使得元素$x$的得分为$1$的合法位置。
  • 当元素$x$向左移动，元素$x$的新位置必须在$[x,i]$之间。$k$轮调时，在位置$0$的元素原来所在位置为$k$，那么要满足元素$x$的新位置必须在$[x,i]$之间，对于原来的位置来说，$i-k\ge x$，即$k\le i-x$必须被满足。

  当$i\ge x$时，使得元素$x$得分为$1$的$k$的取值范围为$k\ge i+1$或$k\le i-x$。

  

计算得分

对于数组的每个元素，都可以计算得分为$1$的轮调$k$的范围。在这个范围内的每个轮调下标$k$加1，这样遍历完所有元素后，找到值最大的最小轮调下标。

创建长度为 $n$ 的数组 $points$，其中$points[k]$ 表示轮调下标为 $k$ 时的得分。对于数组 $nums$ 中的每个元素，得到该元素记 $1$ 分的轮调下标范围，然后将数组 $points$的该下标范围内的所有元素加$1$。当数组 $points$ 中的元素值确定后，找到最大元素的最小下标。该做法的时间复杂度仍然是 $O(n^2)$，为了降低时间复杂度，需要利用差分数组。

差分数组优化

在使用$points$数组时，当$i<x$我们需要把$points$的下标范围$[i+1,i-x+n]$内的所有元素加$1$，当$i\ge x$时应该将$points$的下标范围$[0,i-x]$和$[i+1,n-1]$内的所有元素都加$1$。由于是将一段或两段连续下标范围内的元素加 $1$，因此可以使用差分数组实现。

定义长度为$n$ 的差分数组$diffs$，其中 $diffs[k]=points[k]-points[k-1]$（特别地，$points[-1]=0$），具体做法是：令$low=(i+1)\text{mod}n,high=(i-x+n+1)\text{mod}n$，将$diffs[low]$ 的值加 $1$，将 $diffs[high]$ 的值减 $1$，如果 $low\ge high$ 则将 $diffs[0]$ 的值加 $1$。

遍历数组 $nums$ 的所有元素并更新差分数组之后，遍历数组 $diffs$并计算前缀和，则每个下标处的前缀和表示当前轮调下标处的得分。在遍历过程中维护最大得分和最大得分的最小轮调下标，遍历结束之后即可得到结果。

首先证明，为什么前缀和就是轮调为$k$时的得分。因为由$diffs$的定义，$diffs[k]=points[k]-points[k-1]$，所以下标为$k$的前缀和$presum[k]$最终可以通过式$(1)$化简，这就证明了前缀和确实是轮调下标为$k$时的得分。

$$\begin{array}{c}\begin{array}{rl}presum[k]& =diffs[k]+diffs[k-1]+\cdots +diffs[1]+diffs[0]\\ & =points[k]-points[k-1]+points[k-1]-points[k-2]+\cdots +points[1]-points[0]+points[0]-points[-1]\\ & =points[k]-points[-1]\\ & =poins[k]\end{array}\end{array}$$

接下来说明使用差分数组时，给$points$数组中$[low,high-1]$范围加$1$可以通过$diffs[low]=diffs[low]+1$和$diffs[high]=diffs[high]-1$来完成。此时，当求前缀和在$low$的位置时，我们的和加$1$了，然后当$high$位置时，和减$1$，在这之间和没有变化，这说明我们的差分数组是有用的。

证明

差分数组做法的正确性证明需要考虑$low$和$high$ 的不同情况。以$i$和$x$的关系分情况讨论。

• $i<x$

  这种情况下，$i+1\le k\le i-x+n$，此时$high$的最大值在$i=x$时取得为$n$，这样对$n$进行取模后，$high=0$，于是$diffs[0]=diffs[0]-1$，但是实际上，加一的范围在$[low,n-1]$，和位置$0$没有关系，$high$取$0$是由于取模的关系，此时也满足$low\ge high$，所以要把位置$0$多减的$1$给加回来，$diffs[0]=diffs[0]+1$。

• $i\ge x$

  此情况下，由两段区域组成。

  • 当元素$x$向右移动，此时$x$能达到的最远位置为$n-1$，且在$k$轮调时，这个位置是原始位置$k-1$处的元素占据，那么容易有$k-1=i$，那么$k=i+1$,当$k>i+1$时，元素$x$仍然会在$[i,n-2]$的某个位置，所以$k\ge i+1$都会是使得元素$x$的得分为$1$的合法位置。

    这种情况下的$high$将是定值$n$，对$n$取模后为$0$，有$i<x$的论述可知，需要$diffs[0]=diffs[0]+1$。

  • 当元素$x$向左移动，元素$x$的新位置必须在$[x,i]$之间。$k$轮调时，在位置$0$的元素原来所在位置为$k$，那么要满足元素$x$的新位置必须在$[x,i]$之间，对于原来的位置来说，$i-k\ge x$，即$k\le i-x$必须被满足。

    这一段需要将$diffs[0]=diffs[0]+1$，我们可以这么看，其实是因为这一段并没有$low$，但是和元素$x$向右移动，隐含了那一段区域的$high=n$一样，这里也隐含了这一段区域的$low=0$，所以$diffs[0]=diffs[0]+1$需要被执行。

  这两段区域的分析整体来看，那就是执行如下代码：

  ++diffs[low];
  --diffs[high];
  ++diffs[0];
  

总结上面两种情况，是否需要执行$diffs[0]=diffs[0]+1$都可以根据$low\ge high$这个条件来判断。

class Solution {
public:
    int bestRotation(vector<int>& nums) {
        int n = nums.size();
        vector<int> diffs(n);
        for(int i = 0; i < n; ++i) {
            int x = nums[i];
            if (i < x) {
                int low = (i + 1) % n;
                int high = (i - x + n + 1) % n;
                ++diffs[low];
                --diffs[high];
                if (low >= high) {
                    // 此时high其实只能为0
                    // if (high != 0) {
                    //     return 0;       // 做一个测试，实际代码中可以去除
                    // }
                    ++diffs[0];
                }
            } else {
                // x往左移的这一段
                int low = 0, high = (i - x + 1) % n;
                ++diffs[low];
                if (high != 0) {
                    --diffs[high];
                }
                // x往右移的这一段
                low = (i + 1) % n;
                high = 0;
                ++diffs[low];    
                // ++diffs[high];   // 反正加了又要减
            }
        }
        int ans = 0;
        int score = 0;
        int maxScore = -1;
        for(int i = 0; i < n; ++i) {
            score += diffs[i];
            if (score > maxScore) {
                maxScore = score;
                ans = i;
            }
        }
        return ans;
    }
};