Dynamic Programming | Set 14 (Maximum Sum Increasing Subsequence)

Given an array of n positive integers. Write a program to find the sum of maximum sum subsequence of the given array such that the intgers in the subsequence are sorted in increasing order. For example, if input is {1, 101, 2, 3, 100, 4, 5}, then output should be 106 (1 + 2 + 3 + 100), if the input array is {3, 4, 5, 10}, then output should be 22 (3 + 4 + 5 + 10) and if the input array is {10, 5, 4, 3}, then output should be 10

Solution
This problem is a variation of standard Longest Increasing Subsequence (LIS) problem. We need a slight change in the Dynamic Programming solution of LIS problem. All we need to change is to use sum as a criteria instead of length of increasing subsequence.

Following is C implementation for Dynamic Programming solution of the problem.

 /* Dynamic Programming implementation of Maximum Sum Increasing Subsequence (MSIS) problem */ #include<stdio.h> /* maxSumIS() returns the maximum sum of increasing subsequence in arr[] of size n */ int maxSumIS( int arr[], int n ) { int *msis, i, j, max = 0; msis = (int*) malloc ( sizeof( int ) * n ); /* Initialize msis values for all indexes */ for ( i = 0; i < n; i++ ) msis[i] = arr[i]; /* Compute maximum sum values in bottom up manner */ for ( i = 1; i < n; i++ ) for ( j = 0; j < i; j++ ) if ( arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) msis[i] = msis[j] + arr[i]; /* Pick maximum of all msis values */ for ( i = 0; i < n; i++ ) if ( max < msis[i] ) max = msis[i]; /* Free memory to avoid memory leak */ free( msis ); return max; } /* Driver program to test above function */ int main() { int arr[] = {1, 101, 2, 3, 100, 4, 5}; int n = sizeof(arr)/sizeof(arr[0]); printf("Sum of maximum sum increasing subsequence is %d\n", maxSumIS( arr, n ) ); getchar(); return 0; }

Time Complexity: O(n^2)

Source: Maximum Sum Increasing Subsequence Problem

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Related Topics:

Writing code in comment? Please use ideone.com and share the link here.

Rohit
IMHO this is a better and easier solution requiring traversing the aarray only once.
https://ideone.com/HmaFuZ
- Pawan
  Failing for the following case :
  arr = {15, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9};
anonymous
I think you are computing some particular solutions again in this solution. Like each time you are adding the previous elements involved in the maximum sum for each solution.
My code for the same,
http://ideone.com/RUgwma
Mojo
How do I print the elements involved in the sequence?
prashant jha
#include
using namespace std;
int fun(int arr[],int h[],int low,int high)
{
int m,max=0,k;
if(h[low]!=-1)
return h[low];
if(low==high)
{
h[low]=arr[low];
return arr[low];
}
for(k=low+1;karr[low])
{
m=fun(arr,h,k,high);
if(m>=max)
max=m;
}
}
h[low]=arr[low]+max;
return h[low];
}
int main()
{
int arr[]={1,101,2,3,100,4,5};
int n=sizeof(arr)/sizeof(arr[0]);
int h[n];int s=n,m,max=0;
for(int i=0;i<n;i++)
{
h[i]=-1;
}
for(int i=0;imax)
max=m;
}
cout<<max<<" is the max sum increasing subsequence.n";
/*for(int i=0;i<n;i++)
{
cout<<h[i]<<" ";
}*/
return 0;
}
Krishna Sharma
/*
#include
using namespace std;
int calcMaxSumIncreasingSequence(int a[], int);
int main()
{
int a[] = {1, 101, 2, 3, 100, 4, 5};
int length = sizeof(a)/sizeof(a[0]);
cout << calcMaxSumIncreasingSequence(a, length) << endl;
return 0;
}
int calcMaxSumIncreasingSequence(int a[], int length)
{
int max = a[0];
int lastAdded = 0;
for(int i=0; i<length; i++) {
if(lastAdded<a[i] && max<a[i]+lastAdded) {
max = max+a[i];
lastAdded = a[i];
}
}
return max;
}*/
Yuvaraj Velmayil
Cant we use the same technique of finding the max sum in a array with O(n) complexity ??
maxSoFar = a[i];
maxOverall = a[i];
for( int i =1; i<n; i++)
if(a[i-1] < a[i] )
maxSoFar += a[i];
else
maxSoFar = a[i];
maxOverall = Math.max(maxOverall, maxSoFar);
return maxOverall;
Any comments ??
Asap
Can we extend O(nlogn) approach of lis http://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
for this questions?
anon_user
I’ve done this without using an extra array, i.e., space complexity is O(1). Please correct if wrong.
```
 #include<stdio.h> int main() { int i,j; int a[]={1,101,2,3,100,4,5}; int sum=0,maxSum=0; for(i=1;i<7;i++) { sum=0; for(j=0;j<i;j++) { if(a[i]>a[j]) { sum+=a[j]; } } sum+=a[i]; if(sum>maxSum) maxSum=sum; } printf("%d\n",maxSum); return 0; } 
```
- ashish
  please check for given input
  ary[]={1,101,2,29,3,100,4,5}
- Sriharsha g.r.v
  hi….it works but i didnt understand use of this one
  //sum+=a[i];
  and by ur method can we retrieve the series if asked..i am not sure?

abhishek08aug

Intelligent

 /* Paste your code here (You may delete these lines if not writing code) */

Amit

 /* Paste your code here (You may delete these lines if not writing code) */ #include<stdio.h> int maxSumIS(int a[],int n){ int temp[n],i,j,sum,max = 0; memset(temp,-1,n); for(i=n-1;i>=0;i--){ sum = 0; for(j=0;j<=i;j++){ if(a[i]>=a[j]){ sum = sum + a[j]; } } temp[i] = sum; } for(i =0;i<n;i++){ if(temp[i]>max){ max = temp[i]; } } return max; } int main() { int arr[] = {1, 101, 2, 3, 100, 4, 5}; int n = sizeof(arr)/sizeof(arr[0]); printf("Sum of maximum sum increasing subsequence is %d\n", maxSumIS( arr, n ) ); getchar(); return 0; }

Mrityunjoy Saha

** Solution in previous post won’t work for input { 1, 11, 2, 3, 15 } and corrected here **
This is much cleaner solution.
Concept:
1. Take an auxiliary array of equal size.
2. At each index compute sum till that point considering only ascending values.

Algorithm:
1. Sum at 0 index is the element value.
2. For subsequent elements compute the sum by adding current element with sum at index whose element
value is smaller and sum is maximum.

 public class MaxSumAscendingSubArray { private void findMaxSum(int[] a) { // initialize sum. this array contains sum at each index considering // only ascending // order values int[] sum = new int[a.length]; int n = a.length - 1; sum[0] = a[0]; for (int i = 1; i <= n; i++) { // let's say sum is the value of the element sum[i] = a[i]; int j = i - 1; // now find the last smaller element and then take sum till that // point and // add to current sum int lastMaxSum = 0; while (j >= 0) { if (a[i] > a[j]) { if (sum[j] > lastMaxSum) { lastMaxSum = sum[j]; } } j--; } sum[i] = sum[i] + lastMaxSum; } // find the max sum from sum auxiliary array int max = 0; for (int i = 0; i <= n; i++) { if (sum[i] > max) { max = sum[i]; } } System.out.println("max sum: " + max); } public static void main(String[] args) { MaxSumAscendingSubArray ms = new MaxSumAscendingSubArray(); ms.findMaxSum(new int[] { 1, 101, 2, 3, 100, 4, 5 }); ms.findMaxSum(new int[] { 3, 4, 5, 10 }); ms.findMaxSum(new int[] { 10, 5, 4, 3 }); ms.findMaxSum(new int[] { 1, 11, 2, 3, 15 }); } }

Mrityunjoy Saha

This is much cleaner solution.
Concept:
1. Take an auxiliary array of equal size.
2. At each index compute sum till that point considering only ascending values.

Algorithm:
1. Sum at 0 index is the element value.
2. For subsequent elements compute the sum by adding current element with sum at last index whose element
value is smaller.

 public class MaxSumAscendingSubArray { private void findMaxSum(int[] a) { // initialize sum. this array contains sum at each index considering // only ascending // order values int[] sum = new int[a.length]; int n = a.length - 1; sum[0] = a[0]; for (int i = 1; i <= n; i++) { // let's say sum is the value of the element sum[i] = a[i]; int j = i - 1; // now find the last smaller element and then take sum till that // point and // add to current sum while (j >= 0) { if (a[i] > a[j]) { sum[i] = sum[i] + sum[j]; break; } j--; } } // find the max sum from sum auxiliary array int max = 0; for (int i = 0; i <= n; i++) { if (sum[i] > max) { max = sum[i]; } } System.out.println("max sum: " + max); } public static void main(String[] args) { MaxSumAscendingSubArray ms = new MaxSumAscendingSubArray(); ms.findMaxSum(new int[] { 1, 101, 2, 3, 100, 4, 5 }); ms.findMaxSum(new int[] { 3, 4, 5, 10 }); ms.findMaxSum(new int[] { 10, 5, 4, 3 }); } }

amit
Hey friends,
Why cant we use stack for finding the max contiguous sum.
- we can insert in stack as we go from left to right
- check if element is less than top of stack
- if the current element is > top of stack , pop it and push current element
- if current element is less than top, push it on stack
- if the current element is < top of stack and after popping stack becomes empty , we dont pop the stack
Does something like above work ?
/* Paste your code here (You may delete these lines if not writing code) */

shanky

can this problem be solved in O(nlogn) as the lis problem???

 /* Paste your code here (You may delete these lines if not writing code) */

ajay
Is it increasing sequence or increasing subsequence?
- zeus
  increasing subsequence
```
 /* Paste your code here (You may delete these lines if not writing code) */ 
```
http://facebook.com/sourabh.mehrotra Sourabh mehrotra
the code is not working for input[1,11,2,3,15] the output should be 2+3+15=20… But its showing 27 …… please explain why this is happening….
Thanks in advance
- kartik
  Take a closer look at the problem statement and given examples. 27(1+11+15) is the correct answer for your input array.

lohith

 import java.util.HashMap; public class MaximumSumIncreasingSubSequence { public static CalculatedValues cv = new CalculatedValues(); public static void main(String[] args) { int array[] = { 104, 101, 2, 3, 100, 4, 5 }; IncreasingSubSequenceObject iso = IncreasingSubSequence(array, 0, array.length - 1); System.out.println(iso); } private static IncreasingSubSequenceObject IncreasingSubSequence( int[] array, int low, int high) { if (low == high) { IncreasingSubSequenceObject returnObj = new IncreasingSubSequenceObject(); returnObj.sum = array[low]; returnObj.minPos = low; return returnObj; } int curr = array[low]; IncreasingSubSequenceObject maxIso = new IncreasingSubSequenceObject(); maxIso.sum = curr; maxIso.minPos = low; for (int i = low + 1; i <= high; i++) { IncreasingSubSequenceObject iso1 = null; if (!cv.containsKey(i)) { iso1 = IncreasingSubSequence(array, i, high); if (curr < array[i]) { iso1.sum += curr; iso1.minPos = low; } cv.put(i, iso1); } else { iso1 = cv.get(i); } if (maxIso.sum < iso1.sum) { maxIso = iso1; } } return maxIso; } } class IncreasingSubSequenceObject { int sum = 0; int length = -1; int minPos = -1; int maxPos = -1; public String toString() { return "Sum" + " " + sum + " " + "minPos" + " " + minPos; } } class CalculatedValues extends HashMap<Integer, IncreasingSubSequenceObject> { }

Bhavesh
First read this post
http://www.geeksforgeeks.org/archives/9591
in which LIS is calculate in O(nlogn) and use that approach to obtain MSIS .
Take another array of length n sum[i] which stores the maximum sum that can be obtained for a particular length of subsequence
1. If A[i] is smallest among all end candidates of active lists, we will start new active list of length 1 and sum[0]=max{a[0],sum[0]}.
2. If A[i] is largest among all end candidates of active lists, we will clone the largest active list, and extend it by A[i] and update sum[len] for extended list
3. If A[i] is in between, we will find a list with largest end element that is smaller than A[i]. Clone and extend this list by A[i]. We will discard all other lists of same length as that of this modified list and also update sum[len] .
and in the end search for maximum sum in the sum[] and that is the required ans thus obtained .
joker
just a problem based on this algo.
http://www.spoj.pl/problems/HOTELS/
- joker
  oh sry this problem is about subarrays while algo is about LIS .

Mukul

Instead of using the loops as given in the upper code, we can optimize it further as:

 /* for ( i = 1; i < n; i++ ) { for ( j = i-1; j >= 0; j-- ) if ( arr[i] > arr[j] && msis[i] < msis[j] + arr[i]) { msis[i] = msis[j] + arr[i]; break; } printf("%d \n",msis[i]); } */

hari

well this works fine !!

 /* Paste your code here (You may delete these lines if not writing code) */

atul
algorithm is correct. but i can see in maxSumIS() function is returning local variable i.e “max” . if you are freeing m/m at the end of the function then i guess returning local variable is not a good practice as it may result in returning some garbage value.
```
 /* Paste your code here (You may delete these lines if not writing code) */ 
```
- kartik
  I think you are getting confused here. Returning pointer to local variable is not good practice. But, returning a local variable is always fine.
Mukul
INSTEAD OF USING THIS FORM OF SECOND LOOP
for ( i = 1; i < n; i++ )
for ( j = 0; j arr[j] && msis[i] < msis[j] + arr[i])
msis[i] = msis[j] + arr[i];
WE CAN USE
for ( i = 1; i = 0; j– )
if ( arr[i] > arr[j] && msis[i] < msis[j] + arr[i])
{
msis[i] = msis[j] + arr[i];
break;
}
- kartik
  @Mukul: Please take a closer look at the problem and examples. This optimization is not possible as we may not got optimal value for many cases.

Jul	SEP	Feb
	18
2013	2014	2015

GeeksforGeeks

GeeksQuiz

Dynamic Programming | Set 14 (Maximum Sum Increasing Subsequence)

Related Topics:

Popular Posts

Recent Comments