题目要求

在这里插入图片描述

思路一：数学规律

把每一轮函数表达式写出来，找规律：【 $s u m$ 为数组 $n u m s$ 中所有元素之和】

$F(0)=0\times nums[0]+1\times nums[1]+\dots+(n-2)\times nums[n-2]+(n-1)\times nums[n-1]$
$F(1)=1\times nums[0]+2\times nums[1]+\dots+(n-1)\times nums[n-2]+0\times nums[n-1]$
$\qquad \,\,= F(0)+sum-((n-1)+1)\times nums[n-1]$
$F(2)=2\times nums[0] + 3\times nums[1]+\dots+0\times nums[n - 2]+1\times nums[n-1]$
$\qquad \,\,=F(1)+sum-((n-1)+1)\times nums[n-2]$
……

那就可以找到规律了，第 $k$ 轮结果中除了第 $n ? k$ 个元素，每一个元素都比上一轮中多加一个，而 $n ? k$ 元素少加了 $n ? 1$ 个，所以就直接给上一轮加上所有元素的和（每个元素都多加一个），然后把多余的 $n ? k$ 减掉，即 $F(k)=F(k-1)+sum-n\times nums[n-k]$ 。

带着这个公式不停迭代更新结果就好了。

Java

class Solution {
    public int maxRotateFunction(int[] nums) {
        int n = nums.length, res = 0;
        int sum = Arrays.stream(nums).sum();
        for(int i = 0; i < n; i++)
            res += i * nums[i];
            
        for(int i = n - 1, cur = res; i > 0; i--){
            cur += sum - n * nums[i];
            if(cur > res)
                res = cur;
        }        
        return res;
    }
}

时间复杂度： $O (n)$
空间复杂度： $O (1)$

C++

class Solution {
public:
    int maxRotateFunction(vector<int>& nums) {
        int n = nums.size(), res = 0;
        int sum = accumulate(nums.begin(), nums.end(), 0);
        for(int i = 0; i < n; i++)
            res += i * nums[i];

        for(int i = n - 1, cur = res; i > 0; i--) {
            cur += sum - n * nums[i];
            if(cur > res)
                res = cur;
        }
        return res;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (1)$

思路二：前缀和+滑动窗口

旋转数组这种概念想到之前做过的旋转字符串，把两个自己拼接在一起放一个 $n$ 的滑动窗口就可以找到每一个结果。【注意滑动窗口运行方向和函数运行方向不一样，也就是得到结果过程中顺序不同，但结果相同。】

当前窗口： $cur=0\times nums[i]+1\times nums[i+1]+\dots+(n-1)\times nums[i+n-1]$
下一个窗口： $nxt=0\times nums[i+1]+1\times nums[i+2]+\dots+(n-2)\times nums[i+n-1]+(n-1)\times nums[i]$
可以看到除第 $i$ 个元素之外，每个元素都比上一轮少一个，而第 $i$ 个元素则反而多了 $n ? 1$ 个。此时有两种方法：
- 上面用的，减去所有元素之和再加回来所有的元素 $n u m s [i]$ ，即 $n x t = c u r ? s u m + n ? n u m s [i]$ ；
- 前缀和（下面使用），统计元素前缀和，即当前元素（不含）之前所有元素的和，减去除当前元素外的所有元素之和，再加上 $n ? 1$ 个 $n u m s [i]$ ，即 $n x t = c u r ? (p r e [i ? 1] ? p r e (i ? n)) + (n ? 1) ? n u m s [i]$ 。
按思路迭代，更新更大的结果作为答案即可。

Java

class Solution {
    public int maxRotateFunction(int[] nums) {
        int n = nums.length;
        int[] pre = new int[n * 2 + 1]; // 前缀和
        for(int i = 1; i <= 2 * n; i++)
            pre[i] = pre[i - 1] + nums[(i - 1) % n];

        int res = 0;
        for(int i = 1; i <= n; i++)
            res += nums[i - 1] * (i - 1);
        for(int i = n + 1, cur = res; i < 2 * n; i++) { //滑动窗口
            cur += nums[(i - 1) % n] * (n - 1);
            cur -= pre[i - 1] - pre[i - n];
            if(cur > res)
                res = cur;
        }
        return res;
    }
}

时间复杂度： $O (n)$
空间复杂度： $O (n)$

C++

class Solution {
public:
    int maxRotateFunction(vector<int>& nums) {
        int n = nums.size();
        int pre[n * 2 + 1]; // 前缀和
        for(int i = 1; i <= 2 * n; i++)
            pre[i] = pre[i - 1] + nums[(i - 1) % n];

        int res = 0;
        for(int i = 1; i <= n; i++)
            res += nums[i - 1] * (i - 1);
        for(int i = n + 1, cur = res; i < 2 * n; i++) { // 滑动窗口
            cur += nums[(i - 1) % n] * (n - 1);
            cur -= pre[i - 1] - pre[i - n];
            if(cur > res)
                res = cur;
        }
        return res;
    }
};