Related Articles

Related Articles

Maximum sum of non-overlapping subarrays of length atmost K
  • Difficulty Level : Hard
  • Last Updated : 09 May, 2020

Given an integer array ‘arr’ of length N and an integer ‘k’, select some non-overlapping subarrays such that each sub-array if of length at most ‘k’, no two sub-arrays are adjacent and sum of all the elements of the selected sub-arrays are maximum.

Examples:

Input : arr[] = {-1, 2, -3, 4, 5}, k = 2
Output : 11
Sub-arrays that maximizes sum will be {{2}, {4, 5}}.
Thus, the answer will be 2+4+5 = 11.

Input :arr[] = {1, 1, 1, 1, 1}, k = 1
Output : 3

Naive Approach : A simple way is to generate all possible subsets of elements satisfying above conditions recursively and find the subset with maximum sum.
Time Complexity : O(2N)

Efficient Approach: A better approach is to use dynamic programming.

Let’s suppose we are at an index ‘i’.
Let dp[i] be defined as the maximum sum of elements of all possible subsets of sub-array {i, n-1} satisfying above conditions.



We will have ‘K+1’ possible choices i.e.

  1. Reject ‘i’ and solve for ‘i+1’.
  2. Select sub-array {i} and solve for ‘i+2’
  3. Select sub-array {i, i+1} and solve for ‘i+3’
  4. .
    .
    k+1) Select sub-array {i, i+1, i+2, .., i+k-1} and solve for ‘i+k+1’.

Thus, recurrence relation will be:

dp[i] = max(dp[i+1], arr[i]+dp[i+2], arr[i]+arr[i+1]+dp[i+3],
        ...arr[i]+arr[i+1]+arr[i+2]...+arr[i+k-1] + dp[i+k+1])

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement above approach
#include <bits/stdc++.h>
#define maxLen 10
using namespace std;
  
// Variable to store states of dp
int dp[maxLen];
  
// Variable to check if a given state has been solved
bool visit[maxLen];
  
// Function to find the maximum sum subsequence
// such that no two elements are adjacent
int maxSum(int arr[], int i, int n, int k)
{
    // Base case
    if (i >= n)
        return 0;
  
    // To check if a state has been solved
    if (visit[i])
        return dp[i];
    visit[i] = 1;
  
    // Variable to store
    // prefix sum for sub-array
    // {i, j}
    int tot = 0;
    dp[i] = maxSum(arr, i + 1, n, k);
  
    // Required recurrence relation
    for (int j = i; j < i + k and j < n; j++) {
        tot += arr[j];
        dp[i] = max(dp[i], tot +
                     maxSum(arr, j + 2, n, k));
    }
  
    // Returning the value
    return dp[i];
}
  
// Driver code
int main()
{
    // Input array
    int arr[] = { -1, 2, -3, 4, 5 };
  
    int k = 2;
  
    int n = sizeof(arr) / sizeof(int);
  
    cout << maxSum(arr, 0, n, k);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement above approach
import java.io.*;
  
class GFG
{
      
    static int maxLen = 10;
      
    // Variable to store states of dp
    static int dp[] = new int[maxLen];
      
    // Variable to check 
    // if a given state has been solved
    static boolean []visit = new boolean[maxLen];
      
    // Function to find the maximum sum subsequence
    // such that no two elements are adjacent
    static int maxSum(int arr[], int i, 
                    int n, int k)
    {
        // Base case
        if (i >= n)
            return 0;
      
        // To check if a state has been solved
        if (visit[i])
            return dp[i];
        visit[i] = true;
      
        // Variable to store
        // prefix sum for sub-array
        // {i, j}
        int tot = 0;
        dp[i] = maxSum(arr, i + 1, n, k);
      
        // Required recurrence relation
        for (int j = i; j < (i + k) &&
                            (j < n); j++)
        {
            tot += arr[j];
            dp[i] = Math.max(dp[i], tot +
                    maxSum(arr, j + 2, n, k));
        }
      
        // Returning the value
        return dp[i];
    }
  
    // Driver code
    public static void main (String[] args) 
    {
  
        // Input array
        int arr[] = { -1, 2, -3, 4, 5 };
          
        int k = 2;
          
        int n = arr.length;
          
        System.out.println(maxSum(arr, 0, n, k));
    }
}
  
// This code is contributed by ajit.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement above approach 
maxLen = 10
  
# Variable to store states of dp 
dp = [0]*maxLen; 
  
# Variable to check if a given state has been solved 
visit = [0]*maxLen; 
  
# Function to find the maximum sum subsequence 
# such that no two elements are adjacent 
def maxSum(arr, i, n, k) : 
  
    # Base case 
    if (i >= n) :
        return 0
  
    # To check if a state has been solved 
    if (visit[i]) : 
        return dp[i]; 
          
    visit[i] = 1
  
    # Variable to store 
    # prefix sum for sub-array 
    # {i, j} 
    tot = 0
    dp[i] = maxSum(arr, i + 1, n, k); 
  
    # Required recurrence relation 
    j = i
    while (j < i + k and j < n) :
        tot += arr[j]; 
        dp[i] = max(dp[i], tot +
                    maxSum(arr, j + 2, n, k)); 
                      
        j += 1
      
    # Returning the value 
    return dp[i]; 
  
  
# Driver code 
if __name__ == "__main__"
  
    # Input array 
    arr = [ -1, 2, -3, 4, 5 ]; 
  
    k = 2
  
    n = len(arr); 
  
    print(maxSum(arr, 0, n, k)); 
      
# This code is contributed by AnkitRai01

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement above approach
using System;
  
class GFG
{
static int maxLen = 10;
  
// Variable to store states of dp
static int []dp = new int[maxLen];
  
// Variable to check 
// if a given state has been solved
static bool []visit = new bool[maxLen];
  
// Function to find the maximum sum subsequence
// such that no two elements are adjacent
static int maxSum(int []arr, int i, 
                  int n, int k)
{
    // Base case
    if (i >= n)
        return 0;
  
    // To check if a state has been solved
    if (visit[i])
        return dp[i];
    visit[i] = true;
  
    // Variable to store
    // prefix sum for sub-array
    // {i, j}
    int tot = 0;
    dp[i] = maxSum(arr, i + 1, n, k);
  
    // Required recurrence relation
    for (int j = i; j < (i + k) &&
                        (j < n); j++)
    {
        tot += arr[j];
        dp[i] = Math.Max(dp[i], tot +
                  maxSum(arr, j + 2, n, k));
    }
  
    // Returning the value
    return dp[i];
}
  
// Driver code
static public void Main ()
{
  
    // Input array
    int []arr = { -1, 2, -3, 4, 5 };
      
    int k = 2;
      
    int n = arr.Length;
      
    Console.WriteLine (maxSum(arr, 0, n, k));
}
}
  
// This code is contributed by ajit.

chevron_right


Output:

11

Time Complexity: O(n*k)

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :