Given an array of n positive integers, write a program to find the maximum sum of increasing subsequence from prefix till i-th index and also including a given kth element which is after i, i.e., k > i .

Examples:

Input : arr[] = {1, 101, 2, 3, 100, 4, 5}

i-th index = 4 (Element at 4th index is 100)

K-th index = 6 (Element at 6th index is 5.)

Output : 11

So we need to calculate the maximum sum of subsequence (1 101 2 3 100 5) such that 5 is necessarily included in the subsequence, so answer is 11 by subsequence (1 2 3 5).Input : arr[] = {1, 101, 2, 3, 100, 4, 5}

i-th index = 2 (Element at 2nd index is 2)

K-th index = 5 (Element at 5th index is 4.)

Output : 7

So we need to calculate the maximum sum of subsequence (1 101 2 4) such that 4 is necessarily included in the subsequence, so answer is 7 by subsequence (1 2 4).

**Prerequisite :** Maximum Sum Increasing Subsequence

**Simple Approach:**

- Construct a new array containing elements till ith index and the kth element.
- Recursively calculate all the increasing subsequences.
- Discard all the subsequences not having kth element included.
- Calculate the maximum sum from the left over subsequences and display it.

Time Complexity: O(2^{n})

**Efficient Approach:** Use a dynamic approach to maintain a table dp[][]. The value of dp[i][k] stores the maximum sum of increasing subsequence till ith index and containing the kth element.

[sourcecode language=”CPP”]

// CPP program to find maximum sum increasing

// subsequence till i-th index and including

// k-th index.

#include <bits/stdc++.h>

#define ll long long int

using namespace std;

ll pre_compute(ll a[], ll n, ll index, ll k)

{

ll dp[n][n] = { 0 };

// Initializing the first row of the dp[][].

for (int i = 0; i < n; i++) {

if (a[i] > a[0])

dp[0][i] = a[i] + a[0];

else

dp[0][i] = a[i];

}

// Creating the dp[][] matrix.

for (int i = 1; i < n; i++) {

for (int j = 0; j < n; j++) {

if (a[j] > a[i] && j > i) {

if (dp[i – 1][i] + a[j] > dp[i – 1][j])

dp[i][j] = dp[i – 1][i] + a[j];

else

dp[i][j] = dp[i – 1][j];

}

else

dp[i][j] = dp[i – 1][j];

}

}

// To calculate for i=4 and k=6.

return dp[index][k];

}

int main()

{

ll a[] = { 1, 101, 2, 3, 100, 4, 5 };

ll n = sizeof(a) / sizeof(a[0]);

ll index = 4, k = 6;

printf("%lld", pre_compute(a, n, index, k));

return 0;

}

[/sourcecode]

**Output:**

11

Time Complexity: O(n^{2})

**Note:** This approach is very useful if you have to answer multiple such queries of i and k because using the pre calculated dp matrix you can answer such query in O(1) time.

To try similar problem, give this article a read: Maximum product of an increasing subsequence

## Recommended Posts:

- Maximum subarray sum in O(n) using prefix sum
- Maximum Sum Increasing Subsequence | DP-14
- Printing Maximum Sum Increasing Subsequence
- Maximum product of an increasing subsequence
- Prefix Sum of Matrix (Or 2D Array)
- Prefix Sum Array - Implementation and Applications in Competitive Programming
- Longest Increasing Subsequence | DP-3
- Longest Increasing Odd Even Subsequence
- Longest Common Increasing Subsequence (LCS + LIS)
- Longest Increasing consecutive subsequence
- Construction of Longest Increasing Subsequence (N log N)
- C++ Program for Longest Increasing Subsequence
- C/C++ Program for Longest Increasing Subsequence
- Longest Increasing Subsequence Size (N log N)
- Java Program for Longest Increasing Subsequence

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.