# Maximum subsequence sum possible by multiplying each element by its index

Given an array arr[] consisting of N integers, the task is to find the maximum subsequence sum by multiplying each element of the resultant subsequence by its index(1-based indexing).
Examples:

Input: arr[] = {-1, 2, -10, 4, -20}
Output: 15
Explanation:
For the subsequence {-1, 2, 4}, sum of the given subsequence after performing the given operations = 1*(-1) + 2*2 + 3*4 = 15, which is maximum possible.

Input: arr[] = {1, 0, -1, 2}
Output:
Explanation:
For the subsequence {1, 0, 2}, sum of the given subsequence after performing the given operations = 1*1 + 2*0 + 3*2 = 7, which is maximum possible.

Naive Approach: The idea is to generate all possible subsequences from the array using recursion and calculate the required sum for each subsequence and print the maximum sum.
Time Complexity: O(2N
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized using Dynamic Programming as the problem contains many overlapping subproblems. Below are the steps:

• Initialize an auxiliary matrix dp[][], where dp[i][j] stores the maximum value of the subsequence of length j up to index i.
• Traverse the given array and for each element, there are 2 possibilities:
• Either to include the current element into the subsequence sum and increment the number of elements in subsequence.
• Or exclude the current element from the subsequence and proceed to the next element.
• Therefore, the recurrence relation is given by the following equation:

dp[i][j] = max(a[i] * j + maximumSum(j + 1, i + 1), maximumSum(j, i + 1))

• Keep updating the dp[][] table by using the above recurrence relation for every index and return the maximum sum possible from the entire array.
• Print the maximum value after the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Intialize dp array` `int` `dp;`   `// Function to find the maximum` `// sum of the subsequence formed` `int` `maximumSumUtil(``int` `a[], ``int` `index,` `                   ``int` `count, ``int` `n)` `{` `    ``// Base Case` `    ``if` `(index > n || count > n + 1) {` `        ``return` `0;` `    ``}`   `    ``// If already calculated` `    ``// state occurs` `    ``if` `(dp[index][count] != -1)` `        ``return` `dp[index][count];`   `    ``// Include the current element` `    ``int` `ans1 = maximumSumUtil(a, index + 1,` `                              ``count + 1, n)` `               ``+ a[index] * count;`   `    ``// Exclude the current element` `    ``int` `ans2 = maximumSumUtil(a, index + 1,` `                              ``count, n);`   `    ``// Update the maximum ans` `    ``return` `(dp[index][count]` `            ``= max(ans1, ans2));` `}`   `// Function to calculate maximum sum` `// of the subsequence obtained` `int` `maximumSum(``int` `arr[], ``int` `N)` `{` `    ``// Intialise the dp array with -1` `    ``memset``(dp, -1, ``sizeof``(dp));`   `    ``// Print the maximum sum possible` `    ``cout << maximumSumUtil(arr, 0, 1,` `                           ``N - 1);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array` `    ``int` `arr[] = { -1, 2, -10, 4, -20 };`   `    ``// Size of the array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``maximumSum(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for ` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Intialize dp array` `static` `int` `[][]dp = ``new` `int``[``1005``][``1005``];`   `// Function to find the maximum` `// sum of the subsequence formed` `static` `int` `maximumSumUtil(``int` `a[], ``int` `index,` `                          ``int` `count, ``int` `n)` `{` `  ``// Base Case` `  ``if` `(index > n || count > n + ``1``) ` `  ``{` `    ``return` `0``;` `  ``}`   `  ``// If already calculated` `  ``// state occurs` `  ``if` `(dp[index][count] != -``1``)` `    ``return` `dp[index][count];`   `  ``// Include the current element` `  ``int` `ans1 = maximumSumUtil(a, index + ``1``,` `                            ``count + ``1``, n) + ` `                            ``a[index] * count;`   `  ``// Exclude the current element` `  ``int` `ans2 = maximumSumUtil(a, index + ``1``,` `                            ``count, n);`   `  ``// Update the maximum ans` `  ``return` `(dp[index][count] = ` `          ``Math.max(ans1, ans2));` `}`   `// Function to calculate maximum sum` `// of the subsequence obtained` `static` `void` `maximumSum(``int` `arr[], ``int` `N)` `{` `  ``// Intialise the dp array with -1` `  ``for``(``int` `i = ``0``; i < ``1005``; i++)` `  ``{` `    ``for` `(``int` `j = ``0``; j < ``1005``; j++) ` `    ``{` `      ``dp[i][j] = -``1``;` `    ``}` `  ``}`   `  ``// Print the maximum sum possible` `  ``System.out.print(maximumSumUtil(arr, ``0``, ` `                                  ``1``, N - ``1``));` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given array` `  ``int` `arr[] = {-``1``, ``2``, -``10``, ``4``, -``20``};`   `  ``// Size of the array` `  ``int` `N = arr.length;`   `  ``// Function Call` `  ``maximumSum(arr, N);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach `   `# Intialize dp array` `dp ``=` `[[``-``1` `for` `x ``in` `range``(``1005``)]` `          ``for` `y ``in` `range``(``1005``)]`   `# Function to find the maximum` `# sum of the subsequence formed` `def` `maximumSumUtil(a, index, count, n):`   `    ``# Base Case` `    ``if` `(index > n ``or` `count > n ``+` `1``):` `        ``return` `0`   `    ``# If already calculated` `    ``# state occurs` `    ``if` `(dp[index][count] !``=` `-``1``):` `        ``return` `dp[index][count]`   `    ``# Include the current element` `    ``ans1 ``=` `(maximumSumUtil(a, index ``+` `1``,` `                              ``count ``+` `1``, n) ``+` `                           ``a[index] ``*` `count)`   `    ``# Exclude the current element` `    ``ans2 ``=` `maximumSumUtil(a, index ``+` `1``,` `                          ``count, n)`   `    ``# Update the maximum ans` `    ``dp[index][count] ``=` `max``(ans1, ans2)`   `    ``return` `dp[index][count]`   `# Function to calculate maximum sum` `# of the subsequence obtained ` `def` `maximumSum(arr, N):`   `    ``# Print the maximum sum possible` `    ``print``(maximumSumUtil(arr, ``0``, ``1``,` `                             ``N ``-` `1``))`   `# Driver Code`   `# Given array` `arr ``=` `[ ``-``1``, ``2``, ``-``10``, ``4``, ``-``20` `]`   `# Size of the array` `N ``=` `len``(arr)`   `# Function call` `maximumSum(arr, N)`   `# This code is contributed by Shivam Singh`

## C#

 `// C# program for ` `// the above approach` `using` `System;` `class` `GFG{`   `// Intialize dp array` `static` `int` `[,]dp = ``new` `int``[1005, 1005];`   `// Function to find the maximum` `// sum of the subsequence formed` `static` `int` `maximumSumUtil(``int` `[]a, ``int` `index,` `                          ``int` `count, ``int` `n)` `{` `  ``// Base Case` `  ``if` `(index > n || count > n + 1) ` `  ``{` `    ``return` `0;` `  ``}`   `  ``// If already calculated` `  ``// state occurs` `  ``if` `(dp[index, count] != -1)` `    ``return` `dp[index, count];`   `  ``// Include the current element` `  ``int` `ans1 = maximumSumUtil(a, index + 1,` `                            ``count + 1, n) + ` `                            ``a[index] * count;`   `  ``// Exclude the current element` `  ``int` `ans2 = maximumSumUtil(a, index + 1,` `                            ``count, n);`   `  ``// Update the maximum ans` `  ``return` `(dp[index, count] = ` `          ``Math.Max(ans1, ans2));` `}`   `// Function to calculate maximum sum` `// of the subsequence obtained` `static` `void` `maximumSum(``int` `[]arr, ``int` `N)` `{` `  ``// Intialise the dp array with -1` `  ``for``(``int` `i = 0; i < 1005; i++)` `  ``{` `    ``for` `(``int` `j = 0; j < 1005; j++) ` `    ``{` `      ``dp[i, j] = -1;` `    ``}` `  ``}`   `  ``// Print the maximum sum possible` `  ``Console.Write(maximumSumUtil(arr, 0, ` `                               ``1, N - 1));` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given array` `  ``int` `[]arr = {-1, 2, -10, 4, -20};`   `  ``// Size of the array` `  ``int` `N = arr.Length;`   `  ``// Function Call` `  ``maximumSum(arr, N);` `}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```15

```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.