# Find maximum value of Sum( i*arr[i]) with only rotations on given array allowed

• Difficulty Level : Medium
• Last Updated : 22 Jul, 2022

Given an array arr[] of size N, the task is to find the maximum possible sum of i*arr[i] when the array can be rotated any number of times.

Examples :

Input: arr[] = {1, 20, 2, 10}
Output: 72.We can get 72 by rotating array twice.
{2, 10, 1, 20}
20*3 + 1*2 + 10*1 + 2*0 = 72

Input: arr[] = {10, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Output: 330
We can get 330 by rotating array 9 times.
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
0*1 + 1*2 + 2*3 … 9*10 = 330

Naive Approach: The basic idea of this approach is

Find all rotations one by one, check the sum of every rotation and return the maximum sum.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The idea is as follows:

Let Rj be value of i*arr[i] with j rotations.

• The idea is to calculate the next rotation value from the previous rotation, i.e., calculate Rj from Rj-1
• We can calculate the initial value of the result as R0, then keep calculating the next rotation values.

How to efficiently calculate Rj from Rj-1?

This can be done in O(1) time. Below are the details.

Let us calculate initial value of i*arr[i] with no rotation
R0 = 0*arr + 1*arr +…+ (n-1)*arr[n-1]

After 1 rotation arr[n-1], becomes first element of array,

• arr becomes second element, arr becomes third element and so on.
• R1 = 0*arr[n-1] + 1*arr +…+ (n-1)*arr[n-2]
• R1 – R0 = arr + arr + … + arr[n-2] – (n-1)*arr[n-1]

After 2 rotations arr[n-2], becomes first element of array,

• arr[n-1] becomes second element, arr becomes third element and so on.
• R2 = 0*arr[n-2] + 1*arr[n-1] +…+ (n-1)*arr[n-3]
• R2 – R1 = arr + arr + … + arr[n-3] – (n-1)*arr[n-2] + arr[n-1]

If we take a closer look at above values, we can observe below pattern
Rj – Rj-1 = arrSum – n * arr[n-j],
Where arrSum is sum of all array elements, i.e.,  arrSum = ∑ arr[i] , 0 ≤ i ≤ N-1

Follow the below illustration for a better understanding.

Illustration:

Given arr[]={10, 1, 2, 3, 4, 5, 6, 7, 8, 9},

arrSum = 55, currVal = summation of (i*arr[i]) =  285
In each iteration the currVal is currVal = currVal + arrSum-n*arr[n-j] ,

1st rotation: currVal = 285 + 55 –  (10 *  9) =  250

2nd rotation: currVal = 285 + 55 – (10 * 8) = 260

3rd rotation: currVal = 285 + 55 – (10 * 7) = 270
.
.
.
Last rotation: currVal = 285 + 55 – (10 * 1) = 330

Previous currVal was 285, now it becomes 330.
It’s the maximum value we can find hence return 330.

Follow the steps mentioned below to implement the above approach:

• Compute the sum of all array elements. Let this sum be ‘arrSum‘.
• Compute R0 for the given array. Let this value be currVal.
• Loop from j = 1 to N-1 to calculate the value for each rotation:
• Update the currVal using the formula mentioned above.
• Update the maximum sum accordingly in each step.
• Return the maximum value as the required answer.

Below is the implementation of the above idea.

## C++

 `// C++ program to find max value of i*arr[i]` `#include ` `using` `namespace` `std;`   `// Returns max possible value of i*arr[i]` `int` `maxSum(``int` `arr[], ``int` `n)` `{` `    ``// Find array sum and i*arr[i] with no rotation` `    ``int` `arrSum = 0; ``// Stores sum of arr[i]` `    ``int` `currVal = 0; ``// Stores sum of i*arr[i]` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``arrSum = arrSum + arr[i];` `        ``currVal = currVal + (i * arr[i]);` `    ``}`   `    ``// Initialize result as 0 rotation sum` `    ``int` `maxVal = currVal;`   `    ``// Try all rotations one by one and find` `    ``// the maximum rotation sum.` `    ``for` `(``int` `j = 1; j < n; j++) {` `        ``currVal = currVal + arrSum - n * arr[n - j];` `        ``if` `(currVal > maxVal)` `            ``maxVal = currVal;` `    ``}`   `    ``// Return result` `    ``return` `maxVal;` `}`   `// Driver program` `int` `main(``void``)` `{` `    ``int` `arr[] = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << ``"\nMax sum is "` `<< maxSum(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find max value of i*arr[i]`   `import` `java.util.Arrays;`   `class` `Test {` `    ``static` `int` `arr[]` `        ``= ``new` `int``[] { ``10``, ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9` `};`   `    ``// Returns max possible value of i*arr[i]` `    ``static` `int` `maxSum()` `    ``{` `        ``// Find array sum and i*arr[i] with no rotation` `        ``int` `arrSum = ``0``; ``// Stores sum of arr[i]` `        ``int` `currVal = ``0``; ``// Stores sum of i*arr[i]` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``arrSum = arrSum + arr[i];` `            ``currVal = currVal + (i * arr[i]);` `        ``}`   `        ``// Initialize result as 0 rotation sum` `        ``int` `maxVal = currVal;`   `        ``// Try all rotations one by one and find` `        ``// the maximum rotation sum.` `        ``for` `(``int` `j = ``1``; j < arr.length; j++) {` `            ``currVal = currVal + arrSum` `                      ``- arr.length * arr[arr.length - j];` `            ``if` `(currVal > maxVal)` `                ``maxVal = currVal;` `        ``}`   `        ``// Return result` `        ``return` `maxVal;` `    ``}`   `    ``// Driver method to test the above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``System.out.println(``"Max sum is "` `+ maxSum());` `    ``}` `}`

## Python

 `'''Python program to find maximum value of Sum(i*arr[i])'''`   `# returns max possible value of Sum(i*arr[i])`     `def` `maxSum(arr):`   `    ``# stores sum of arr[i]` `    ``arrSum ``=` `0`   `    ``# stores sum of i*arr[i]` `    ``currVal ``=` `0`   `    ``n ``=` `len``(arr)`   `    ``for` `i ``in` `range``(``0``, n):` `        ``arrSum ``=` `arrSum ``+` `arr[i]` `        ``currVal ``=` `currVal ``+` `(i``*``arr[i])`   `    ``# initialize result` `    ``maxVal ``=` `currVal`   `    ``# try all rotations one by one and find the maximum` `    ``# rotation sum` `    ``for` `j ``in` `range``(``1``, n):` `        ``currVal ``=` `currVal ``+` `arrSum``-``n``*``arr[n``-``j]` `        ``if` `currVal > maxVal:` `            ``maxVal ``=` `currVal`   `    ``# return result` `    ``return` `maxVal`     `# test maxsum(arr) function` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``10``, ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``]` `    ``print` `"Max sum is: "``, maxSum(arr)`

## C#

 `// C# program to find max value of i*arr[i]` `using` `System;`   `class` `Test {` `    ``static` `int``[] arr` `        ``= ``new` `int``[] { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9 };`   `    ``// Returns max possible value of i*arr[i]` `    ``static` `int` `maxSum()` `    ``{` `        ``// Find array sum and i*arr[i]` `        ``// with no rotation` `        ``int` `arrSum = 0; ``// Stores sum of arr[i]` `        ``int` `currVal = 0; ``// Stores sum of i*arr[i]`   `        ``for` `(``int` `i = 0; i < arr.Length; i++) {` `            ``arrSum = arrSum + arr[i];` `            ``currVal = currVal + (i * arr[i]);` `        ``}`   `        ``// Initialize result as 0 rotation sum` `        ``int` `maxVal = currVal;`   `        ``// Try all rotations one by one and find` `        ``// the maximum rotation sum.` `        ``for` `(``int` `j = 1; j < arr.Length; j++) {` `            ``currVal = currVal + arrSum` `                      ``- arr.Length * arr[arr.Length - j];` `            ``if` `(currVal > maxVal)` `                ``maxVal = currVal;` `        ``}`   `        ``// Return result` `        ``return` `maxVal;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``Console.WriteLine(``"Max sum is "` `+ maxSum());` `    ``}` `}`   `// This article is contributed by vt_m.`

## PHP

 ` ``\$maxVal``)` `            ``\$maxVal` `= ``\$currVal``;` `    ``}`   `    ``// Return result` `    ``return` `\$maxVal``;` `}`   `// Driver Code` `\$arr` `= ``array` `(10, 1, 2, 3, 4,` `              ``5, 6, 7, 8, 9);` `\$n` `= sizeof(``\$arr``);` `echo` `"Max sum is "` `,` `     ``maxSum(``\$arr``, ``\$n``);`   `// This code is contributed by m_kit` `?>`

## Javascript

 ``

Output

`Max sum is 330`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :