Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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. 

Algorithm

  • Start by initializing max_sum to INT_MIN
  • Loop say i,from 0 to n-1:
    • a. Initialize sum to 0
    • b. Loop j from 0 to n-1:
      • i. Calculate the index of the j-th element after rotation: (i+j) % n
      • ii. Add the product of the element and its index to sum: j * arr[(i+j) % n]
    • c. If sum is greater than max_sum, update max_sum to sum
  • Return max_sum

C++




#include <climits>
#include <iostream>
 
using namespace std;
 
int max_sum_rotation(int arr[], int n)
{
    int max_sum = INT_MIN; // set the maximum sum to the
                           // minimum possible value
    for (int i = 0; i < n;
         i++) { // loop through all possible rotations
        int sum = 0; // set the current sum to zero
        for (int j = 0; j < n;
             j++) { // loop through all elements in the
                    // array
            int index
                = (i + j)
                  % n; // calculate the index of the current
                       // element after rotation
            sum += j * arr[index]; // add the product of the
                                   // element with its index
                                   // to the sum
        }
        max_sum = max(
            max_sum,
            sum); // update the maximum sum if necessary
    }
    return max_sum; // return the maximum sum obtained over
                    // all rotations
}
 
int main()
{
    int arr[] = {
        10, 1, 2, 3, 4, 5, 6, 7, 8, 9
    }; // define an array
    int n = sizeof(arr)
            / sizeof(
                arr[0]); // calculate the size of the array
    cout << max_sum_rotation(arr, n)
         << endl; // call the function and print the result
    return 0; // indicate successful program completion
}


Java




/*package whatever //do not write package name here */
 
import java.io.*;
public class MaxSumRotation {
    public static int maxSumRotation(int[] arr, int n) {
        // Set the maximum sum to the minimum possible value
        int maxSum = Integer.MIN_VALUE;
 
        // Loop through all possible rotations
        for (int i = 0; i < n; i++) {
            // Set the current sum to zero
            int sum = 0;
 
            // Loop through all elements in the array
            for (int j = 0; j < n; j++) {
                // Calculate the index of the current element after rotation
                int index = (i + j) % n;
 
                // Add the product of the element with its index to the sum
                sum += j * arr[index];
            }
 
            // Update the maximum sum if necessary
            maxSum = Math.max(maxSum, sum);
        }
 
        // Return the maximum sum obtained over all rotations
        return maxSum;
    }
 
    public static void main(String[] args) {
        int[] arr = {10, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        int n = arr.length;
        System.out.println(maxSumRotation(arr, n));
    }
}


Python3




def max_sum_rotation(arr, n):
    # set the maximum sum to the
    # minimum possible value
    max_sum = float('-inf')
     
     
    # loop through all possible rotations
    for i in range(n):
       
        # set the current sum to zero
        sum = 0
         
        # loop through all elements in the array
        for j in range(n):
            # calculate the index of the current element after rotation
            index = (i + j) % n
             
            # add the product of the element with its index to the sum
            sum += j * arr[index]
         
        # update the maximum sum if necessary
        max_sum = max(max_sum, sum)
     
    # return the maximum sum obtained over all rotations
    return max_sum
# Test case
arr = [10, 1, 2, 3, 4, 5, 6, 7, 8, 9]
n = len(arr)
print(max_sum_rotation(arr, n))


C#




using System;
 
class Program
{
    static int MaxSumRotation(int[] arr, int n)
    {
        int maxSum = int.MinValue; // set the maximum sum to the minimum possible value
 
        for (int i = 0; i < n; i++)
        {
            int sum = 0; // set the current sum to zero
 
            for (int j = 0; j < n; j++)
            {
                int index = (i + j) % n; // calculate the index of the current element after rotation
                sum += j * arr[index]; // add the product of the element with its index to the sum
            }
 
            maxSum = Math.Max(maxSum, sum); // update the maximum sum if necessary
        }
 
        return maxSum; // return the maximum sum obtained over all rotations
    }
 
    static void Main(string[] args)
    {
        int[] arr = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // define an array
        int n = arr.Length; // calculate the size of the array
 
        Console.WriteLine(MaxSumRotation(arr, n)); // call the function and print the result
    }
}


Javascript




function maxSumRotation(arr) {
    const n = arr.length;
    let maxSum = Number.MIN_SAFE_INTEGER;
 
    for (let i = 0; i < n; i++) {
        let sum = 0;
 
        for (let j = 0; j < n; j++) {
            const index = (i + j) % n;
            sum += j * arr[index];
        }
 
        maxSum = Math.max(maxSum, sum);
    }
    return maxSum;
}
const arr = [10, 1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(maxSumRotation(arr));


Output

330









Time Complexity: O(N2), where n is the size of the input array. 
Auxiliary Space: O(1), because it uses a constant amount of extra space to store the variables max_sum, sum, i, and j. 

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[0] + 1*arr[1] +…+ (n-1)*arr[n-1]

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

  • arr[0] becomes second element, arr[1] becomes third element and so on.
  • R1 = 0*arr[n-1] + 1*arr[0] +…+ (n-1)*arr[n-2]
  • R1 – R0 = arr[0] + arr[1] + … + 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[0] becomes third element and so on.
  • R2 = 0*arr[n-2] + 1*arr[n-1] +…+ (n-1)*arr[n-3]
  • R2 – R1 = arr[0] + arr[1] + … + 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 = 250 + 55 – (10 * 8) = 225

3rd rotation: currVal = 225 + 55 – (10 * 7) = 210
.
.
.
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 <iostream>
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[0]);
    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.


Javascript




<script>
// JavaScript program to find max value of i*arr[i]
 
// Returns max possible value of i*arr[i]
function maxSum(arr, n)
{
    // Find array sum and i*arr[i] with no rotation
    let arrSum = 0; // Stores sum of arr[i]
    let currVal = 0; // Stores sum of i*arr[i]
    for (let i=0; i<n; i++)
    {
        arrSum = arrSum + arr[i];
        currVal = currVal+(i*arr[i]);
    }
 
    // Initialize result as 0 rotation sum
    let maxVal = currVal;
 
    // Try all rotations one by one and find
    // the maximum rotation sum.
    for (let j=1; j<n; j++)
    {
        currVal = currVal + arrSum-n*arr[n-j];
        if (currVal > maxVal)
            maxVal = currVal;
    }
 
    // Return result
    return maxVal;
}
 
// Driver program
    let arr = [10, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let n = arr.length;
    document.write("Max sum is " + maxSum(arr, n));
 
 
 
 
 
 
// This code is contributed by Surbhi Tyagi.
</script>


PHP




<?php
// PHP program to find max
// value of i*arr[i]
 
// Returns max possible
// value of i*arr[i]
function maxSum($arr, $n)
{
    // Find array sum and
    // i*arr[i] with no rotation
     
    // Stores sum of arr[i]
    $arrSum = 0;
     
    // Stores sum of i*arr[i]
    $currVal = 0;
    for ($i = 0; $i < $n; $i++)
    {
        $arrSum = $arrSum + $arr[$i];
        $currVal = $currVal +
                  ($i * $arr[$i]);
    }
 
    // Initialize result as
    // 0 rotation sum
    $maxVal = $currVal;
 
    // Try all rotations one
    // by one and find the
    // maximum rotation sum.
    for ($j = 1; $j < $n; $j++)
    {
        $currVal = $currVal + $arrSum -
                   $n * $arr[$n - $j];
        if ($currVal > $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
?>


Output

Max sum is 330









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



Last Updated : 28 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads