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

• Difficulty Level : Hard
• Last Updated : 19 Nov, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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;` `// Initialize 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)``{``    ``// Initialise 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{` `// Initialize 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)``{``  ``// Initialise 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` `# Initialize 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{` `// Initialize 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)``{``  ``// Initialise 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`

## Javascript

 ``
Output:
`15`

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

My Personal Notes arrow_drop_up