# Maximum sum of non-overlapping subarrays of length atmost K

• Difficulty Level : Hard
• Last Updated : 11 May, 2021

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’

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++

 `// C++ program to implement above approach``#include ``#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;``}`

## Java

 `// 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.`

## Python3

 `# 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`

## C#

 `// 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.`

## Javascript

 ``

Output:

`11`

Time Complexity: O(n*k)

My Personal Notes arrow_drop_up