POTD Solutions | 23 Oct’ 23 | Maximum Sum Increasing Subsequence

POTD 23 October: Maximum sum increasing subsequence

Given an array of n positive integers. Find the sum of the maximum sum subsequence of the given array such that the integers in the subsequence are sorted in strictly increasing order i.e. a strictly increasing subsequence. 

Example 1:
Input: N = 5, arr[] = {1, 101, 2, 3, 100}
Output: 106
Explanation: The maximum sum of a increasing sequence is obtained from {1, 2, 3, 100}

Example 2:
Input: N = 4, arr[] = {4, 1, 2, 3}
Output: 6
Explanation: The maximum sum of a increasing sequence is obtained from {1, 2, 3}.

Maximum Sum Increasing Subsequence using Dynamic Programming:

This problem is a variation of the 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 a length of increasing subsequence.

Step-by-step algorithm:

• Maintain a msis[] array, such that msis[i] stores the maximum sum of the increasing subsequence having last element as arr[i].
• Initialize msis[i] with arr[i]
• Iterate from i = 1 to i = N-1
  • Check for all the indices j less than i such that (arr[i] > arr[j]) and update msis[i] is we can get greater sum using the subsequence ending at j.
• After iterating over the entire array, return the maximum element in msis.

Below is the implementation of above approach:

class Solution {
public:
    int maxSumIS(int arr[], int n)
    {
        // Your code goes here
        int i, j, max = 0;
        int msis[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];

        return max;
    }
};

class Solution {
    public int maxSumIS(int arr[], int n)
    {
        // code here
        int i, j, max = 0;
        int msis[] = new 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];

        return max;
    }
}

class Solution:
    def maxSumIS(self, Arr, n):
        max = 0
        msis = [0 for x in range(n)]

        # Initialize msis values
        # for all indexes
        for i in range(n):
            msis[i] = Arr[i]

        # Compute maximum sum
        # values in bottom up manner
        for i in range(1, n):
            for j in range(i):
                if (Arr[i] > Arr[j] and
                        msis[i] < msis[j] + Arr[i]):
                    msis[i] = msis[j] + Arr[i]

        # Pick maximum of
        # all msis values
        for i in range(n):
            if max < msis[i]:
                max = msis[i]

        return max

class Solution {
    maxSumIS(arr,n){
        //code here
        let i, j, max = 0;  
        let msis = new Array(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];  
      
        return max;  
    }
}