Instead of recalculating F(k) for each rotation, we use a formula to compute F(k) from F(k-1) efficiently. The difference between F(k) and F(k-1) is related to the sum of nums and the last element moved to the front.
classSolution {
public:int maxRotateFunction(vector<int>& nums) {
int n = nums.size();
long sum =0, f =0, ans = INT_MIN;
for (int i =0; i < n; ++i) {
sum += nums[i];
f += i * nums[i];
}
ans = f;
for (int k =1; k < n; ++k) {
f = f + sum - n * nums[n - k];
ans = max(ans, f);
}
return ans;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
funcmaxRotateFunction(nums []int) int {
n:= len(nums)
sum, f:=0, 0fori, x:=rangenums {
sum+=xf+=i*x }
ans:=ffork:=1; k < n; k++ {
f = f+sum-n*nums[n-k]
iff > ans {
ans = f }
}
returnans}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
classSolution {
publicintmaxRotateFunction(int[] nums) {
int n = nums.length;
long sum = 0, f = 0, ans;
for (int i = 0; i < n; ++i) {
sum += nums[i];
f += (long)i * nums[i];
}
ans = f;
for (int k = 1; k < n; ++k) {
f = f + sum - n * nums[n - k];
ans = Math.max(ans, f);
}
return (int)ans;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
classSolution {
funmaxRotateFunction(nums: IntArray): Int {
val n = nums.size
var sum = 0Lvar f = 0Lfor (i in nums.indices) {
sum += nums[i]
f += i * nums[i].toLong()
}
var ans = f
for (k in1 until n) {
f = f + sum - n * nums[n - k]
ans = maxOf(ans, f)
}
return ans.toInt()
}
}
1
2
3
4
5
6
7
8
9
10
classSolution:
defmaxRotateFunction(self, nums: list[int]) -> int:
n = len(nums)
s = sum(nums)
f = sum(i * x for i, x in enumerate(nums))
ans = f
for k in range(1, n):
f = f + s - n * nums[n - k]
ans = max(ans, f)
return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
impl Solution {
pubfnmax_rotate_function(nums: Vec<i32>) -> i32 {
let n = nums.len();
let sum: i32= nums.iter().sum();
letmut f: i32= nums.iter().enumerate().map(|(i, &x)| i asi32* x).sum();
letmut ans = f;
for k in1..n {
f = f + sum - n asi32* nums[n - k];
ans = ans.max(f);
}
ans
}
}