Maximum possible sum of non-adjacent array elements not exceeding K
Last Updated : 27 Apr, 2023
Given an array arr[] consisting of N integers and an integer K, the task is to select some non-adjacent array elements with the maximum possible sum not exceeding K.
Examples:
Input: arr[] = {50, 10, 20, 30, 40}, K = 100
Output: 90
Explanation: To maximize the sum that doesn't exceed K(= 100), select elements 50 and 40.
Therefore, maximum possible sum = 90.
Input: arr[] = {20, 10, 17, 12, 8, 9}, K = 64
Output: 46
Explanation: To maximize the sum that doesn't exceed K(= 64), select elements 20, 17, and 9.
Therefore, maximum possible sum = 46.
Naive Approach: The simplest approach is to recursively generate all possible subsets of the given array and for each subset, check if it does not contain adjacent elements and has the sum not exceeding K. Among all subsets for which the above condition is found to be true, print the maximum sum obtained for any subset.
Below is the implementation of the above approach:
C++ // C++ program for the above approach #include <bits/stdc++.h> using namespace std; // Function to find the // maximum sum not exceeding // K possible by selecting // a subset of non-adjacent elements int maxSum(int a[], int n, int k) { // Base Case if (n <= 0) return 0; // Not selecting current // element int option = maxSum(a, n - 1, k); // If selecting current // element is possible if (k >= a[n - 1]) option = max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])); // Return answer return option; } // Driver Code int main() { // Given array arr[] int arr[] = {50, 10, 20, 30, 40}; int N = sizeof(arr) / sizeof(arr[0]); // Given K int K = 100; // Function Call cout << (maxSum(arr, N, K)); } // This code is contributed by gauravrajput1 // Java program for the above approach import java.io.*; class GFG { // Function to find the maximum sum // not exceeding K possible by selecting // a subset of non-adjacent elements public static int maxSum( int a[], int n, int k) { // Base Case if (n <= 0) return 0; // Not selecting current element int option = maxSum(a, n - 1, k); // If selecting current element // is possible if (k >= a[n - 1]) option = Math.max( option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])); // Return answer return option; } // Driver Code public static void main(String[] args) { // Given array arr[] int arr[] = { 50, 10, 20, 30, 40 }; int N = arr.length; // Given K int K = 100; // Function Call System.out.println(maxSum(arr, N, K)); } } # Python3 program for the above approach # Function to find the maximum sum # not exceeding K possible by selecting # a subset of non-adjacent elements def maxSum(a, n, k): # Base Case if (n <= 0): return 0 # Not selecting current element option = maxSum(a, n - 1, k) # If selecting current element # is possible if (k >= a[n - 1]): option = max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])) # Return answer return option # Driver Code if __name__ == '__main__': # Given array arr[] arr = [ 50, 10, 20, 30, 40 ] N = len(arr) # Given K K = 100 # Function Call print(maxSum(arr, N, K)) # This code is contributed by mohit kumar 29
// C# program for the // above approach using System; class GFG{ // Function to find the maximum // sum not exceeding K possible // by selecting a subset of // non-adjacent elements public static int maxSum(int []a, int n, int k) { // Base Case if (n <= 0) return 0; // Not selecting current element int option = maxSum(a, n - 1, k); // If selecting current // element is possible if (k >= a[n - 1]) option = Math.Max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])); // Return answer return option; } // Driver Code public static void Main(String[] args) { // Given array []arr int []arr = {50, 10, 20, 30, 40}; int N = arr.Length; // Given K int K = 100; // Function Call Console.WriteLine(maxSum(arr, N, K)); } } // This code is contributed by Rajput-Ji <script> // Javascript program for the // above approach // Function to find the maximum sum // not exceeding K possible by selecting // a subset of non-adjacent elements function maxSum(a, n, k) { // Base Case if (n <= 0) return 0; // Not selecting current element let option = maxSum(a, n - 1, k); // If selecting current element // is possible if (k >= a[n - 1]) option = Math.max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])); // Return answer return option; } // Driver Code // Given array arr[] let arr = [ 50, 10, 20, 30, 40 ]; let N = arr.length; // Given K let K = 100; // Function Call document.write(maxSum(arr, N, K)); // This code is contributed by target_2 </script> Time Complexity: O(2N)
Auxiliary Space: O(N)
Efficient Approach: To optimize the above approach, the idea is to use Dynamic Programming. Two possible options exist for every array element:
- Either skip the current element and proceed to the next element.
- Select the current element only if it is smaller than or equal to K.
Follow the steps below to solve the problem:
- Initialize an array dp[N][K+1] with -1 where dp[i][j] will store the maximum sum to make sum j using elements up to index i.
- From the above transition, find the maximum sums if the current element gets picked and if it is not picked, recursively.
- Store the minimum answer for the current state.
- Also, add the base condition that if the current state (i, j) is already visited i.e., dp[i][j]!=-1 return dp[i][j].
- Print dp[N][K] as the maximum possible sum.
Below is the implementation of the above approach:
C++ // C++ program for the above approach #include <bits/stdc++.h> using namespace std; // Initialize dp int dp[1005][1005]; // Function find the maximum sum that // doesn't exceeds K by choosing elements int maxSum(int* a, int n, int k) { // Base Case if (n <= 0) return 0; // Return the memoized state if (dp[n][k] != -1) return dp[n][k]; // Dont pick the current element int option = maxSum(a, n - 1, k); // Pick the current element if (k >= a[n - 1]) option = max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1])); // Return and store the result return dp[n][k] = option; } // Driver Code int main() { int N = 5; int arr[] = { 50, 10, 20, 30, 40 }; int K = 100; // Fill dp array with -1 memset(dp, -1, sizeof(dp)); // Print answer cout << maxSum(arr, N, K) << endl; } // This code is contributed by bolliranadheer // Java program for the above approach import java.util.*; class GFG { // Function find the maximum sum that // doesn't exceeds K by choosing elements public static int maxSum(int a[], int n, int k, int[][] dp) { // Base Case if (n <= 0) return 0; // Return the memoized state if (dp[n][k] != -1) return dp[n][k]; // Dont pick the current element int option = maxSum(a, n - 1, k, dp); // Pick the current element if (k >= a[n - 1]) option = Math.max( option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1], dp)); // Return and store the result return dp[n][k] = option; } // Driver Code public static void main(String[] args) { int arr[] = { 50, 10, 20, 30, 40 }; int N = arr.length; int K = 100; // Initialize dp int dp[][] = new int[N + 1][K + 1]; for (int i[] : dp) { Arrays.fill(i, -1); } // Print answer System.out.println(maxSum(arr, N, K, dp)); } } # Python3 program for the # above approach # Function find the maximum # sum that doesn't exceeds K # by choosing elements def maxSum(a, n, k, dp): # Base Case if (n <= 0): return 0; # Return the memoized state if (dp[n][k] != -1): return dp[n][k]; # Dont pick the current # element option = maxSum(a, n - 1, k, dp); # Pick the current element if (k >= a[n - 1]): option = max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1], dp)); dp[n][k] = option; # Return and store # the result return dp[n][k]; # Driver Code if __name__ == '__main__': arr = [50, 10, 20, 30, 40]; N = len(arr); K = 100; # Initialize dp dp = [[-1 for i in range(K + 1)] for j in range(N + 1)] # Print answer print(maxSum(arr, N, K, dp)); # This code is contributed by shikhasingrajput
// C# program for the // above approach using System; class GFG{ // Function find the maximum // sum that doesn't exceeds K // by choosing elements public static int maxSum(int []a, int n, int k, int[,] dp) { // Base Case if (n <= 0) return 0; // Return the memoized // state if (dp[n, k] != -1) return dp[n, k]; // Dont pick the current // element int option = maxSum(a, n - 1, k, dp); // Pick the current element if (k >= a[n - 1]) option = Math.Max(option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1], dp)); // Return and store the // result return dp[n, k] = option; } // Driver Code public static void Main(String[] args) { int []arr = {50, 10, 20, 30, 40}; int N = arr.Length; int K = 100; // Initialize dp int [,]dp = new int[N + 1, K + 1]; for (int j = 0; j < N + 1; j++) { for (int k = 0; k < K + 1; k++) dp[j, k] = -1; } // Print answer Console.WriteLine(maxSum(arr, N, K, dp)); } } // This code is contributed by Rajput-Ji <script> // Javascript program to implement // the above approach // Function find the maximum sum that // doesn't exceeds K by choosing elements function maxSum(a, n, k, dp) { // Base Case if (n <= 0) return 0; // Return the memoized state if (dp[n][k] != -1) return dp[n][k]; // Dont pick the current element let option = maxSum(a, n - 1, k, dp); // Pick the current element if (k >= a[n - 1]) option = Math.max( option, a[n - 1] + maxSum(a, n - 2, k - a[n - 1], dp)); // Return and store the result return dp[n][k] = option; } // Driver Code // Given array let arr = [ 50, 10, 20, 30, 40 ]; let N = arr.length; let K = 100; // Initialize dp let dp = new Array(N + 1); // Loop to create 2D array using 1D array for (var i = 0; i < 1000; i++) { dp[i] = new Array(2); } for (var i = 0; i < 1000; i++) { for (var j = 0; j < 1000; j++) { dp[i][j] = -1; } } // Print answer document.write(maxSum(arr, N, K, dp)); </script> Time Complexity: O(N*K), where N is the size of the given array and K is the limit.
Auxiliary Space: O(N*K)
Efficient approach : Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Create a table DP to store the solution of the subproblems.
- Initialize the table with base cases
- Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
- Return the final solution stored in
Implementation :
C++ // C++ program for above approach #include <bits/stdc++.h> using namespace std; // Function to find the maximum sum that // doesn't exceed K by choosing elements int maxSum(int* a, int n, int k) { // Initialize the DP table int dp[n + 1][k + 1]; memset(dp, 0, sizeof(dp)); // Fill the DP table in bottom-up manner for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) { // Don't pick the current element dp[i][j] = dp[i - 1][j]; // Pick the current element if (j >= a[i - 1]) { dp[i][j] = max( dp[i][j], a[i - 1] + dp[i - 2][j - a[i - 1]]); } } } // Return the maximum sum return dp[n][k]; } // Driver Code int main() { int N = 5; int arr[] = { 50, 10, 20, 30, 40 }; int K = 100; // Print answer cout << maxSum(arr, N, K) << endl; return 0; } // this code is contributed by bhardwajji import java.util.*; public class Main { // Function to find the maximum sum that // doesn't exceed K by choosing elements public static int maxSum(int[] a, int n, int k) { // Initialize the DP table int[][] dp = new int[n + 1][k + 1]; for (int[] row : dp) { Arrays.fill(row, 0); } // Fill the DP table in bottom-up manner for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) { // Don't pick the current element dp[i][j] = dp[i - 1][j]; // Pick the current element if (j >= a[i - 1]) { dp[i][j] = Math.max( dp[i][j], a[i - 1] + ((i >= 2) ? dp[i - 2][j - a[i - 1]] : 0)); } } } // Return the maximum sum return dp[n][k]; } // Driver code public static void main(String[] args) { int N = 5; int[] arr = { 50, 10, 20, 30, 40 }; int K = 100; // Print answer System.out.println(maxSum(arr, N, K)); } } # Python3 program to find the maximum sum that # doesn't exceed K by choosing elements def maxSum(a, n, k): # Initialize the DP table dp = [[0 for i in range(k + 1)] for j in range(n + 1)] # Fill the DP table in bottom-up manner for i in range(1, n + 1): for j in range(1, k + 1): # Don't pick the current element dp[i][j] = dp[i - 1][j] # Pick the current element if j >= a[i - 1]: dp[i][j] = max(dp[i][j], a[i - 1] + dp[i - 2][j - a[i - 1]]) # Return the maximum sum return dp[n][k] # Driver Code if __name__ == "__main__": N = 5 arr = [50, 10, 20, 30, 40] K = 100 # Print answer print(maxSum(arr, N, K))
using System; public class GFG { // Function to find the maximum sum that // doesn't exceed K by choosing elements public static int maxSum(int[] a, int n, int k) { // Initialize the DP table int[, ] dp = new int[n + 1, k + 1]; for (int i = 0; i <= n; i++) { for (int j = 0; j <= k; j++) { dp[i, j] = 0; } } // Fill the DP table in bottom-up manner for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) { // Don't pick the current element dp[i, j] = dp[i - 1, j]; // Pick the current element if (j >= a[i - 1]) { dp[i, j] = Math.Max( dp[i, j], a[i - 1] + ((i >= 2) ? dp[i - 2, j - a[i - 1]] : 0)); } } } // Return the maximum sum return dp[n, k]; } // Driver code public static void Main() { int N = 5; int[] arr = { 50, 10, 20, 30, 40 }; int K = 100; // Print answer Console.WriteLine(maxSum(arr, N, K)); } } // JavaScript program to find the maximum sum that // doesn't exceed K by choosing elements function maxSum(a, n, k) { // Initialize the DP table let dp = new Array(n + 1); for (let i = 0; i < n + 1; i++) { dp[i] = new Array(k + 1).fill(0); } // Fill the DP table in bottom-up manner for (let i = 1; i <= n; i++) { for (let j = 1; j <= k; j++) { // Don't pick the current element dp[i][j] = dp[i - 1][j]; // Pick the current element if (j >= a[i - 1]) { dp[i][j] = Math.max(dp[i][j], a[i - 1] + dp[(i - 2) < 0 ? n: i-2][j - a[i - 1]]); } } } // Return the maximum sum return dp[n][k]; } // Driver Code let N = 5; let arr = [50, 10, 20, 30, 40]; let K = 100; // Print answer console.log(maxSum(arr, N, K)); // The code is contributed by Arushi Goel. Output:
90
Time Complexity: O(N*K), where N is the size of the given array and K is the limit.
Auxiliary Space: O(N*K)
Similar Reads
Maximum Sum pair of non adjacent elements in array
Given an array arr[] of distinct Integers, find the pair with maximum sum such that both elements of the pair are not adjacent in the array Examples: Input: arr[] = {7, 3, 4, 1, 8, 9}Output: 9 7Explanation: Pair with maximum sum is (8, 9). But since both elements are adjacent, it is not a valid pair
8 min read
Maximum frequency of any array element possible by at most K increments
Given an array arr[] of size N and an integer K, the task is to find the maximum possible frequency of any array element by at most K increments. Examples: Input: arr[] = {1, 4, 8, 13}, N = 4, K = 5 Output: 2 Explanation: Incrementing arr[0] twice modifies arr[] to {4, 4, 8, 13}. Maximum frequency =
15+ min read
Maximum sum not exceeding K possible for any rectangle of a Matrix
Given a matrix mat[][] of dimensions N * M, and an integer K, the task is to find the maximum sum of any rectangle possible from the given matrix, whose sum of elements is at most K. Examples: Input: mat[][] ={{1, 0, 1}, {0, -2, 3}}, K = 2Output: 2Explanation: The maximum sum possible in any rectang
11 min read
Maximum sum of increasing order elements from n arrays
Given n arrays of size m each. Find the maximum sum obtained by selecting a number from each array such that the elements selected from the i-th array are more than the element selected from (i-1)-th array. If maximum sum cannot be obtained then return 0.Examples: Input : arr[][] = {{1, 7, 3, 4}, {4
13 min read
Count maximum possible pairs from an array having sum K
Given an array arr[] consisting of N integers and an integer K, the task is to find the maximum number of pairs having a sum K possible from the given array. Note: Every array element can be part of a single pair. Examples: Input: arr[] = {1, 2, 3, 4}, K = 5Output: 2Explanation: Pairs with sum K fro
11 min read
Maximum sum of Subset having no consecutive elements
Given an array arr[] of size N, the task is to find the maximum possible sum of a subset of the array such that no two consecutive elements are part of the subset. Examples: Input: arr[]= {2, 3, 2, 3, 3, 4}Output: 9Explanation: The subset having all the 3s i.e. {3, 3, 3} have sum = 9.This is the max
9 min read
Maximum sum of Array formed by replacing each element with sum of adjacent elements
Given an array arr[] of size N, the task is to find the maximum sum of the Array formed by replacing each element of the original array with the sum of adjacent elements.Examples: Input: arr = [4, 2, 1, 3] Output: 23 Explanation: Replacing each element of the original array with the sum of adjacent
9 min read
Maximum subarray sum possible after removing at most K array elements
Given an array arr[] of size N and an integer K, the task is to find the maximum subarray sum by removing at most K elements from the array. Examples: Input: arr[] = { -2, 1, 3, -2, 4, -7, 20 }, K = 1 Output: 26 Explanation: Removing arr[5] from the array modifies arr[] to { -2, 1, 3, -2, 4, 20 } Su
15+ min read
Count maximum elements of an array whose absolute difference does not exceed K
Given an array A and positive integer K. The task is to find maximum number of elements for which the absolute difference of any of the pair does not exceed K.Examples: Input: A[] = {1, 26, 17, 12, 15, 2}, K = 5 Output: 3 There are maximum 3 values so that the absolute difference of each pair does n
6 min read
Maximum Subarray Sum Excluding Certain Elements
Given an array of A of n integers and an array B of m integers find the Maximum Contiguous Subarray Sum of array A such that any element of array B is not present in that subarray. Examples : Input : A = {1, 7, -10, 6, 2}, B = {5, 6, 7, 1} Output : 2 Explanation Since the Maximum Sum Subarray of A i
15+ min read