一、题目

给定一个长度为 n 的整数数组 nums 。

假设 arrk 是数组 nums 顺时针旋转 k 个位置后的数组，我们定义 nums 的旋转函数 F 为：

F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]

返回 F(0), F(1), ..., F(n-1)中的最大值。

生成的测试用例让答案符合 32 位整数。
示例 1:

输入: nums = [4,3,2,6]

输出: 26

解释:

F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25

F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16

F(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23

F(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26

所以 F(0), F(1), F(2), F(3) 中的最大值是 F(3) = 26 。

示例 2:

输入: nums = [100]

输出: 0
提示:

n == nums.length

1 <= n <= 105

-100 <= nums[i] <= 100

二、解决方法一

class Solution:
    def maxRotateFunction(self, nums: List[int]) -> int:
        n = len(nums)
        f = [0] * n
        for i in range(n):
            cur = nums[i]
            f[i] = cur * (i + 1)
        res = f[0]
        for i in range(1, n):
            res = max(res, f[i] + f[i - 1])
        return res

这段代码实现了一个函数 `maxRotateFunction`,用于计算给定整数数组 `nums` 顺时针旋转 `k` 个位置后，所有旋转后的数组元素之和的最大值。

具体实现过程如下：

首先定义一个长度为 `n` 的列表 `f`,其中 `f[i]` 表示将数组 `nums` 顺时针旋转 `i` 个位置后，所有元素之和。初始时，`f[i] = i * nums[i]`。

然后遍历整个数组 `nums`,依次计算出每个位置的旋转后元素之和，并将其保存到列表 `f` 中。

最后，从头开始遍历列表 `f`,找到其中的最大值即可。因为每次旋转都会使数组中的某个元素变为零，所以最大的旋转后元素之和就是第一个元素加上最后一个元素的值乘以数组长度减一。因此，最终返回的是 `f[0] + f[n-1]` 的最大值。

总的来说，这段代码的时间复杂度为 O(n),空间复杂度为 O(1)。

三、解决方法二

class Solution:
    def maxRotateFunction(self, nums: List[int]) -> int:
        n = len(nums)
        f = [0] * n
        for i in range(n):
            cur = nums[i]
            f[i] = cur * (i + 1)
        res = f[0]
        for i in range(1, n):
            # 将数组分为两部分，前半部分为递增序列，后半部分为递减序列
            left, right = 0, i - 1
            while left < right:
                # 如果当前元素小于它的下一个元素，说明它应该在后半部分
                if nums[left] <= nums[right]:
                    break
                # 否则将它移动到前半部分
                temp = nums[left]
                nums[left] = nums[right]
                nums[right] = temp
                left += 1
                right -= 1
            # 计算前半部分和后半部分的元素之和，并更新最大值
            res = max(res, f[i] + sum(f[:left]) + sum(f[right+1:]))
        return res

这段代码实现了一个函数 `maxRotateFunction`,用于计算给定整数数组 `nums` 顺时针旋转 `k` 个位置后，所有旋转后的数组元素之和的最大值。

具体实现过程如下：

首先定义一个长度为 `n` 的列表 `f`,其中 `f[i]` 表示将数组 `nums` 顺时针旋转 `i` 个位置后，所有元素之和。初始时，`f[i] = i * nums[i]`。

然后遍历整个数组 `nums`,依次计算出每个位置的旋转后元素之和，并将其保存到列表 `f` 中。

对于数组中的每个元素，我们可以将其分为两部分，前半部分为递增序列，后半部分为递减序列。具体来说，我们从数组的两端开始向中间扫描，如果当前元素小于它的下一个元素，说明它应该在后半部分；否则将它移动到前半部分。这个过程可以用双指针法实现。

将数组分为两部分后，我们可以计算出前半部分和后半部分的元素之和，并更新最大值 res。具体来说，我们可以将前半部分的元素之和求出来，然后加上后半部分的元素之和即可。

如果旋转次数 `k` 小于等于数组长度 `n`,则将问题转化为求解 F(k+1) 的最大值；否则，F(k) 就是最终答案。

总的来说，这段代码的时间复杂度为 O(n^2),空间复杂度为 O(1)。

打卡力扣题目十

一、题目

二、解决方法一

三、解决方法二