Maximum sum subsequence of length K | Set 2

Last Updated : 15 Feb, 2022

Given an array sequence arr[] i.e [A₁, A₂ …A_n] and an integer k, the task is to find the maximum possible sum of increasing subsequence S of length k such that S₁<=S₂<=S₃………<=S_k.

Examples:

Input: arr[] = {-1, 3, 4, 2, 5}, K = 3
Output: 3 4 5
Explanation: Subsequence 3 4 5 with sum 12 is the subsequence with maximum possible sum.

Input: arr[] = {6, 3, 4, 1, 1, 8, 7, -4, 2}
Output: 6 3 4 8 7

Approach: The task can be solved using Greedy Approach. The idea is to take the maximum possible elements from arr[] in the subsequence. Follow the steps below to solve the problem.

Declare a vector of pairs container say, use[] to store elements with their indices.
Traverse arr[] and push all the elements in use[] with their indices.
Sort use[] in non-decreasing order.
Declare a vector ans[] to store the final subsequence.
Traverse use[] with i and Take the last K element from use and push their indices(use[i].second) into ans[].
Sort ans[] in non-decreasing order so that indices should be in increasing order.
Now Traverse ans[] with i and replace each element with arr[ans[i]].
Return ans[] as the final maximum sum subsequence.

Below is the implementation of the above approach.

C++

// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the subsequence
// with maximum sum of length K
vector<int> maxSumSubsequence(vector<int>& arr, int N,
                              int K)
{

    // Use an extra array to keep
    // track of indices while sorting
    vector<pair<int, int> > use;

    for (int i = 0; i < N; i++) {
        use.push_back({ arr[i], i });
    }

    // Sorting in non-decreasing order
    sort(use.begin(), use.end());

    // To store the final subsequence
    vector<int> ans;

    // Pushing last K elements in ans
    for (int i = N - 1; i >= N - K; i--) {

        // Pushing indices of elements
        // which are part of final subsequence
        ans.push_back(use[i].second);
    }

    // Sorting the indices
    sort(ans.begin(), ans.end());

    // Storing elements corresponding to each indices
    for (int i = 0; i < int(ans.size()); i++)
        ans[i] = arr[ans[i]];

    // Return ans as the final result
    return ans;
}

// Driver Code
int main()
{

    int N = 9;
    vector<int> arr = { 6, 3, 4, 1, 1, 8, 7, -4, 2 };

    int K = 5;

    // Storing answer in res
    vector<int> res = maxSumSubsequence(arr, N, K);

    // Printing the result
    for (auto i : res)
        cout << i << ' ';

    return 0;
}

Java

// Java program for above approach
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class GFG {

    static class Pair {
        int first;
        int second;

        Pair(int i, int j) {
            this.first = i;
            this.second = j;
        }
    }

    // Function to find the subsequence
    // with maximum sum of length K
    static ArrayList<Integer> maxSumSubsequence(int[] arr, int N, int K) {

        // Use an extra array to keep
        // track of indices while sorting
        ArrayList<Pair> use = new ArrayList<Pair>();

        for (int i = 0; i < N; i++) {
            use.add(new Pair(arr[i], i));
        }

        // Sorting in non-decreasing order
        Collections.sort(use, new Comparator<Pair>() {
            @Override
            public int compare(Pair i, Pair j) {
                return i.first - j.first;
            }
        });

        // To store the final subsequence
        ArrayList<Integer> ans = new ArrayList<Integer>();

        // Pushing last K elements in ans
        for (int i = N - 1; i >= N - K; i--) {

            // Pushing indices of elements
            // which are part of final subsequence
            ans.add(use.get(i).second);
        }

        // Sorting the indices
        Collections.sort(ans);

        // Storing elements corresponding to each indices
        for (int i = 0; i < ans.size(); i++)
            ans.set(i, arr[ans.get(i)]);

        // Return ans as the final result
        return ans;
    }

    // Driver Code
    public static void main(String args[]) {

        int N = 9;
        int[] arr = { 6, 3, 4, 1, 1, 8, 7, -4, 2 };

        int K = 5;

        // Storing answer in res
        ArrayList<Integer> res = maxSumSubsequence(arr, N, K);

        // Printing the result
        for (int i : res)
            System.out.print(i + " ");
    }
}

// This code is contributed by saurabh_jaiswal.

Python3

# python program for above approach

# Function to find the subsequence
# with maximum sum of length K
def maxSumSubsequence(arr, N, K):

    # Use an extra array to keep
    # track of indices while sorting
    use = []

    for i in range(0, N):
        use.append([arr[i], i])

    # Sorting in non-decreasing order
    use.sort()

    # To store the final subsequence
    ans = []

    # Pushing last K elements in ans
    for i in range(N - 1, N - K - 1, -1):

        # Pushing indices of elements
        # which are part of final subsequence
        ans.append(use[i][1])

    # Sorting the indices
    ans.sort()

    # Storing elements corresponding to each indices
    for i in range(0, len(ans)):
        ans[i] = arr[ans[i]]

    # Return ans as the final result
    return ans

# Driver Code
if __name__ == "__main__":

    N = 9
    arr = [6, 3, 4, 1, 1, 8, 7, -4, 2]

    K = 5

    # Storing answer in res
    res = maxSumSubsequence(arr, N, K)

    # Printing the result
    for i in res:
        print(i, end=' ')

    # This code is contributed by rakeshsahni

// C# program for above approach
using System;
using System.Collections.Generic;

public class GFG {

  class Pair {
    public int first;
    public int second;

    public Pair(int i, int j) {
      this.first = i;
      this.second = j;
    }
  }

  // Function to find the subsequence
  // with maximum sum of length K
  static List<int> maxSumSubsequence(int[] arr, int N, int K) {

    // Use an extra array to keep
    // track of indices while sorting
    List<Pair> use = new List<Pair>();

    for (int i = 0; i < N; i++) {
      use.Add(new Pair(arr[i], i));
    }

    // Sorting in non-decreasing order
    use.Sort((i, j) => i.first - j.first);

    // To store the readonly subsequence
    List<int> ans = new List<int>();

    // Pushing last K elements in ans
    for (int i = N - 1; i >= N - K; i--) {

      // Pushing indices of elements
      // which are part of readonly subsequence
      ans.Add(use[i].second);
    }

    // Sorting the indices
    ans.Sort();

    // Storing elements corresponding to each indices
    for (int i = 0; i < ans.Count; i++)
      ans[i] = arr[ans[i]];

    // Return ans as the readonly result
    return ans;
  }

  // Driver Code
  public static void Main(String []args) {

    int N = 9;
    int[] arr = { 6, 3, 4, 1, 1, 8, 7, -4, 2 };

    int K = 5;

    // Storing answer in res
    List<int> res = maxSumSubsequence(arr, N, K);

    // Printing the result
    foreach (int i in res)
      Console.Write(i + " ");
  }
}

// This code is contributed by 29AjayKumar

JavaScript

  <script>
        // JavaScript code for the above approach


        // Function to find the subsequence
        // with maximum sum of length K
        function maxSumSubsequence(arr, N,
            K) {

            // Use an extra array to keep
            // track of indices while sorting
            let use = [];

            for (let i = 0; i < N; i++) {
                use.push({ first: arr[i], second: i });
            }

            // Sorting in non-decreasing order
            use.sort(function (a, b) { return a.first - b.first; });

            // To store the final subsequence
            let ans = [];

            // Pushing last K elements in ans
            for (let i = N - 1; i >= N - K; i--) {

                // Pushing indices of elements
                // which are part of final subsequence
                ans.push(use[i].second);
            }

            // Sorting the indices
            ans.sort(function (a, b) { return a - b; });

            // Storing elements corresponding to each indices
            for (let i = 0; i < ans.length; i++)
                ans[i] = arr[ans[i]];

            // Return ans as the final result
            return ans;
        }

        // Driver Code


        let N = 9;
        let arr = [6, 3, 4, 1, 1, 8, 7, -4, 2]

        let K = 5;

        // Storing answer in res
        let res = maxSumSubsequence(arr, N, K);

        // Printing the result
        for (let i = 0; i < res.length; i++)
            document.write(res[i] + ' ');


  // This code is contributed by Potta Lokesh
    </script>

Output

6 3 4 8 7

Time Complexity: O(NlogN), where N is the size of the array
Auxiliary Space: O(N), Where N is the size of the array

SQL Commands | DDL, DQL, DML, DCL and TCL Commands

coder_nero

Improve

Article Tags :

Practice Tags :

Maximum sum subsequence of length K | Set 2

Similar Reads

Thank You!

What kind of Experience do you want to share?