# Maximum elements that can be removed from front of two arrays such that their sum is at most K

• Last Updated : 04 Jun, 2021

Given an integer K and two arrays A[] and B[] consisting of N and M integers, the task is to maximize the number of elements that can be removed from the front of either array according to the following rules:

• Remove an element from the front of either array A[] and B[] such that the value of the removed element must be at most K.
• Decrease the value of K by the value of the element removed.

Examples:

Input: K = 7, A[] = {2, 4, 7, 3}, B[] = {1, 9, 3, 4, 5}
Output: 3
Explanation:
Operation 1: Choose element from the array A[] and decrease K by A(=2), then value of K becomes = (7 – 2) = 5.
Operation 2: Choose element from the array B[] and decrease K by B(=1), then value of K becomes = (5 – 1) = 4.
Operation 3: Choose element from the array A[] and decrease K by A(=4), then value of K becomes = (4 – 4) = 4.
After the above operations, no more element can be removed. Therefore, print 3.

Input: K = 9, A[] = {12, 10, 1, 2, 3}, B[] = {15, 19, 3, 4, 5}
Output: 0

Approach: The given problem can be solved by using the Prefix Sum and Binary Search to find the total items possible j to take from stack B after taking i items from stack A and return the result as the maximum value of (i + j). Follow the below steps to solve the given problem:

• Find prefix sum of the arrays A[] and B[].
• Initialize a variable, say count as 0, that stores the maximum items that can be taken.
• Traverse the array, A[] over the range [0, N] using the variable i and perform the following steps:
• If the value of A[i] is greater than K, then break out of the loop.
• Store the remaining amount after taking i items from stack A in a variable, rem as K – A[i].
• Perform a binary search on the array B, to find the maximum items say, j that can be taken in rem amount from stack B (after taking i elements from stack A).
• Store the maximum value of i + j in the variable count.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum number``// of items that can be removed from``// both the arrays``void` `maxItems(``int` `n, ``int` `m, ``int` `a[],``              ``int` `b[], ``int` `K)``{``    ``// Stores the maximum item count``    ``int` `count = 0;` `    ``// Stores the prefix sum of the``    ``// cost of items``    ``int` `A[n + 1];``    ``int` `B[m + 1];` `    ``// Insert the item cost 0 at the``    ``// front of the arrays``    ``A = 0;``    ``B = 0;` `    ``// Build the prefix sum for``    ``// the array A[]``    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// Update the value of A[i]``        ``A[i] = a[i - 1] + A[i - 1];``    ``}` `    ``// Build the prefix sum for``    ``// the array B[]``    ``for` `(``int` `i = 1; i <= m; i++) {` `        ``// Update the value of B[i]``        ``B[i] = b[i - 1] + B[i - 1];``    ``}` `    ``// Iterate through each item``    ``// of the array A[]``    ``for` `(``int` `i = 0; i <= n; i++) {` `        ``// If A[i] exceeds K``        ``if` `(A[i] > K)``            ``break``;` `        ``// Store the remaining amount``        ``// after taking top i elements``        ``// from the array A``        ``int` `rem = K - A[i];` `        ``// Store the number of items``        ``// possible to take from the``        ``// array B[]``        ``int` `j = 0;` `        ``// Store low and high bounds``        ``// for binary search``        ``int` `lo = 0, hi = m;` `        ``// Binary search to find``        ``// number of item that``        ``// can be taken from stack``        ``// B in rem amount``        ``while` `(lo <= hi) {` `            ``// Calculate the mid value``            ``int` `mid = (lo + hi) / 2;``            ``if` `(B[mid] <= rem) {` `                ``// Update the value``                ``// of j and lo``                ``j = mid;``                ``lo = mid + 1;``            ``}``            ``else` `{` `                ``// Update the value``                ``// of the hi``                ``hi = mid - 1;``            ``}``        ``}` `        ``// Store the maximum of total``        ``// item count``        ``count = max(j + i, count);``    ``}` `    ``// Print the result``    ``cout << count;``}` `// Driver Code``int` `main()``{``    ``int` `n = 4, m = 5, K = 7;``    ``int` `A[n] = { 2, 4, 7, 3 };``    ``int` `B[m] = { 1, 9, 3, 4, 5 };``    ``maxItems(n, m, A, B, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum number``// of items that can be removed from``// both the arrays``static` `void` `maxItems(``int` `n, ``int` `m, ``int` `a[],``                     ``int` `b[], ``int` `K)``{``    ` `    ``// Stores the maximum item count``    ``int` `count = ``0``;` `    ``// Stores the prefix sum of the``    ``// cost of items``    ``int` `A[] = ``new` `int``[n + ``1``];``    ``int` `B[] = ``new` `int``[m + ``1``];` `    ``// Insert the item cost 0 at the``    ``// front of the arrays``    ``A[``0``] = ``0``;``    ``B[``0``] = ``0``;` `    ``// Build the prefix sum for``    ``// the array A[]``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ` `        ``// Update the value of A[i]``        ``A[i] = a[i - ``1``] + A[i - ``1``];``    ``}` `    ``// Build the prefix sum for``    ``// the array B[]``    ``for``(``int` `i = ``1``; i <= m; i++)``    ``{``        ` `        ``// Update the value of B[i]``        ``B[i] = b[i - ``1``] + B[i - ``1``];``    ``}` `    ``// Iterate through each item``    ``// of the array A[]``    ``for``(``int` `i = ``0``; i <= n; i++)``    ``{``        ` `        ``// If A[i] exceeds K``        ``if` `(A[i] > K)``            ``break``;` `        ``// Store the remaining amount``        ``// after taking top i elements``        ``// from the array A``        ``int` `rem = K - A[i];` `        ``// Store the number of items``        ``// possible to take from the``        ``// array B[]``        ``int` `j = ``0``;` `        ``// Store low and high bounds``        ``// for binary search``        ``int` `lo = ``0``, hi = m;` `        ``// Binary search to find``        ``// number of item that``        ``// can be taken from stack``        ``// B in rem amount``        ``while` `(lo <= hi)``        ``{``            ` `            ``// Calculate the mid value``            ``int` `mid = (lo + hi) / ``2``;``            ``if` `(B[mid] <= rem)``            ``{``                ` `                ``// Update the value``                ``// of j and lo``                ``j = mid;``                ``lo = mid + ``1``;``            ``}``            ``else``            ``{``                ` `                ``// Update the value``                ``// of the hi``                ``hi = mid - ``1``;``            ``}``        ``}` `        ``// Store the maximum of total``        ``// item count``        ``count = Math.max(j + i, count);``    ``}` `    ``// Print the result``    ``System.out.print(count);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `n = ``4``, m = ``5``, K = ``7``;``    ``int` `A[] = { ``2``, ``4``, ``7``, ``3` `};``    ``int` `B[] = { ``1``, ``9``, ``3``, ``4``, ``5` `};``    ` `    ``maxItems(n, m, A, B, K);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum number``# of items that can be removed from``# both the arrays``def` `maxItems(n, m, a, b, K):``    ` `    ``# Stores the maximum item count``    ``count ``=` `0` `    ``# Stores the prefix sum of the``    ``# cost of items``    ``A ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]``    ``B ``=` `[``0` `for` `i ``in` `range``(m ``+` `1``)]` `    ``# Build the prefix sum for``    ``# the array A[]``    ``for` `i ``in` `range``(``1``, n ``+` `1``, ``1``):``        ` `        ``# Update the value of A[i]``        ``A[i] ``=` `a[i ``-` `1``] ``+` `A[i ``-` `1``]` `    ``# Build the prefix sum for``    ``# the array B[]``    ``for` `i ``in` `range``(``1``, m ``+` `1``, ``1``):``        ` `        ``# Update the value of B[i]``        ``B[i] ``=` `b[i ``-` `1``] ``+` `B[i ``-` `1``]` `    ``# Iterate through each item``    ``# of the array A[]``    ``for` `i ``in` `range``(n ``+` `1``):``        ` `        ``# If A[i] exceeds K``        ``if` `(A[i] > K):``            ``break` `        ``# Store the remaining amount``        ``# after taking top i elements``        ``# from the array A``        ``rem ``=` `K ``-` `A[i]` `        ``# Store the number of items``        ``# possible to take from the``        ``# array B[]``        ``j ``=` `0` `        ``# Store low and high bounds``        ``# for binary search``        ``lo ``=` `0``        ``hi ``=` `m` `        ``# Binary search to find``        ``# number of item that``        ``# can be taken from stack``        ``# B in rem amount``        ``while` `(lo <``=` `hi):` `            ``# Calculate the mid value``            ``mid ``=` `(lo ``+` `hi) ``/``/` `2``            ` `            ``if` `(B[mid] <``=` `rem):``                ` `                ``# Update the value``                ``# of j and lo``                ``j ``=` `mid``                ``lo ``=` `mid ``+` `1` `            ``else``:``                ` `                ``# Update the value``                ``# of the hi``                ``hi ``=` `mid ``-` `1` `        ``# Store the maximum of total``        ``# item count``        ``count ``=` `max``(j ``+` `i, count)` `    ``# Print the result``    ``print``(count)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``n ``=` `4``    ``m ``=` `5``    ``K ``=` `7``    ``A ``=` `[ ``2``, ``4``, ``7``, ``3` `]``    ``B ``=` `[ ``1``, ``9``, ``3``, ``4``, ``5` `]``    ` `    ``maxItems(n, m, A, B, K)``        ` `# This code is contributed by bgangwar59`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG``{   ` `// Function to find the maximum number``// of items that can be removed from``// both the arrays``static` `void` `maxItems(``int` `n, ``int` `m, ``int``[] a,``                     ``int``[] b, ``int` `K)``{``    ` `    ``// Stores the maximum item count``    ``int` `count = 0;` `    ``// Stores the prefix sum of the``    ``// cost of items``    ``int``[] A = ``new` `int``[n + 1];``    ``int``[] B= ``new` `int``[m + 1];` `    ``// Insert the item cost 0 at the``    ``// front of the arrays``    ``A = 0;``    ``B = 0;` `    ``// Build the prefix sum for``    ``// the array A[]``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ` `        ``// Update the value of A[i]``        ``A[i] = a[i - 1] + A[i - 1];``    ``}` `    ``// Build the prefix sum for``    ``// the array B[]``    ``for``(``int` `i = 1; i <= m; i++)``    ``{``        ` `        ``// Update the value of B[i]``        ``B[i] = b[i - 1] + B[i - 1];``    ``}` `    ``// Iterate through each item``    ``// of the array A[]``    ``for``(``int` `i = 0; i <= n; i++)``    ``{``        ` `        ``// If A[i] exceeds K``        ``if` `(A[i] > K)``            ``break``;` `        ``// Store the remaining amount``        ``// after taking top i elements``        ``// from the array A``        ``int` `rem = K - A[i];` `        ``// Store the number of items``        ``// possible to take from the``        ``// array B[]``        ``int` `j = 0;` `        ``// Store low and high bounds``        ``// for binary search``        ``int` `lo = 0, hi = m;` `        ``// Binary search to find``        ``// number of item that``        ``// can be taken from stack``        ``// B in rem amount``        ``while` `(lo <= hi)``        ``{``            ` `            ``// Calculate the mid value``            ``int` `mid = (lo + hi) / 2;``            ``if` `(B[mid] <= rem)``            ``{``                ` `                ``// Update the value``                ``// of j and lo``                ``j = mid;``                ``lo = mid + 1;``            ``}``            ``else``            ``{``                ` `                ``// Update the value``                ``// of the hi``                ``hi = mid - 1;``            ``}``        ``}` `        ``// Store the maximum of total``        ``// item count``        ``count = Math.Max(j + i, count);``    ``}` `    ``// Print the result``    ``Console.Write(count);``}`  `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `n = 4, m = 5, K = 7;``    ``int``[] A = { 2, 4, 7, 3 };``    ``int``[] B = { 1, 9, 3, 4, 5 };``    ` `    ``maxItems(n, m, A, B, K);` `}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N * log(M))
Auxiliary Space: O(N + M)

My Personal Notes arrow_drop_up