Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Maximize count of numbers that can be removed from end of either arrays with total sum at most K

Given two arrays S1 and S2 containing N and M integers, and an integer K, the task is to find the maximum number of integers that can be removed from end of either given arrays, such that the sum of removed elements is less than or equal to K.

Example:



Input: S1[] = {1, 2, 3}, S2[] = {1, 2, 4}, K = 10
Output: 5
Explanation: All the elements of S1 i.e, {1, 2, 3} and two elements of S2 i.e, {1, 2} can be removed from the given arrays as their sum is 9 which is less than 10. Hence, the number of integers that can be removes is 5 which is the maximum possible.

Input: S1[] = {12, 21, 102}, S2[] = {167, 244, 377, 56, 235, 269, 23}, K = 1000
Output: 7



 

Approach: The above approach can be solved with the help of a greedy approach. The idea is to consider the given arrays as stacks (as only the endmost element can be removed from any array). Check over all possible valid sequences of operations using a two-pointer approach. Below are the steps to follow:

Below is the implementation of the above approach:




// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return max profit
// from both stacks given as input
int Max_profit_maximisation(int Stack1[], int Stack2[],
                            int n, int m, int K)
{
    // Stores the final answer
    int maximum_result = 0;
  
    // Stores the pointer to the
    // current window in stack 1
    int index_for_Stack1 = 0;
  
    // Stores the pointer to the
    // current window in stack 2
    int index_for_Stack2;
  
    // Stores sum of current window
    int curr_sum = 0;
  
    // Case where snly stack 1
    // is considered
    while (index_for_Stack1 < n
           && curr_sum + Stack1[index_for_Stack1]
                  < K) {
        curr_sum += Stack1[index_for_Stack1];
        index_for_Stack1++;
    }
  
    // Update answer
    maximum_result = index_for_Stack1;
  
    // Traverse Stack 2 and insert
    // elements into the current
    // window one at a time
    while (index_for_Stack2 < m) {
        curr_sum += Stack2[index_for_Stack2];
        index_for_Stack2++;
  
        // curr_sum after removing
        // last elements from Stack1
        while (curr_sum > K
               && index_for_Stack1 > 0) {
            index_for_Stack1--;
            curr_sum -= Stack1[index_for_Stack1];
        }
  
        // Updating the answer
        maximum_result
            = max(maximum_result,
                  index_for_Stack1
                      + index_for_Stack2);
    }
  
    // Return Answer
    return maximum_result;
}
  
// Driver code
int main()
{
    int S1[] = { 12, 21, 102 };
    int S2[] = { 167, 244, 377, 56,
                 235, 269, 23 };
    int N = 3;
    int M = 7;
    int K = 1000;
  
    cout << Max_profit_maximisation(S1, S2, N, M, K);
  
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program of the above approach 



import java.util.*; 




  



class GFG{ 




  


// Function to return max profit 


// from both stacks given as input 



static int Max_profit_maximisation(int Stack1[], int Stack2[], 




                            int n, int m, int K) 



{ 



    // Stores the final answer 




    int maximum_result = 0; 




  



    // Stores the pointer to the 




    // current window in stack 1 




    int index_for_Stack1 =0; 




  



    // Stores the pointer to the 




    // current window in stack 2 




    int index_for_Stack2=Integer.MAX_VALUE; 




  



    // Stores sum of current window 




    int curr_sum = 0; 




  



    // Case where snly stack 1 




    // is considered 




    while (index_for_Stack1 < n 




           && curr_sum + Stack1[index_for_Stack1] 




                  < K) { 




        curr_sum += Stack1[index_for_Stack1]; 




        index_for_Stack1++; 




    } 




  



    // Update answer 




    maximum_result = index_for_Stack1; 




  



    // Traverse Stack 2 and insert 




    // elements into the current 




    // window one at a time 




    while (index_for_Stack2 < m) { 




        curr_sum += Stack2[index_for_Stack2]; 




        index_for_Stack2++; 




  



        // curr_sum after removing 




        // last elements from Stack1 




        while (curr_sum > K 




               && index_for_Stack1 > 0) { 




            index_for_Stack1--; 




            curr_sum -= Stack1[index_for_Stack1]; 




        } 




  



        // Updating the answer 




        maximum_result 




            = Math.max(maximum_result, 




                  index_for_Stack1 




                      + index_for_Stack2); 




    } 




  



    // Return Answer 




    return maximum_result; 



} 



  


// Driver code 



public static void main(String[] args) 



{ 



    int S1[] = { 12, 21, 102 }; 




    int S2[] = { 167, 244, 377, 56, 




                 235, 269, 23 }; 




    int N = 3; 




    int M = 7; 




    int K = 1000; 




  



    System.out.print(Max_profit_maximisation(S1, S2, N, M, K)); 



} 


} 



  


// This code is contributed by shikhasingrajput


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python program of the above approach 



  


# Function to return max profit 


# from both stacks given as input 



def Max_profit_maximisation(Stack1, Stack2, n, m, K): 




      



    # Stores the final answer 




    maximum_result = 0




  



    # Stores the pointer to the 




    # current window in stack 1 




    index_for_Stack1 = 0




  



    # Stores the pointer to the 




    # current window in stack 2 




    index_for_Stack2 = 100**100




  



    # Stores sum of current window 




    curr_sum = 0




  



    # Case where snly stack 1 




    # is considered 




    while (index_for_Stack1 < n 




           and curr_sum + Stack1[index_for_Stack1] 




                  < K): 




        curr_sum += Stack1[index_for_Stack1] 




        index_for_Stack1 += 1




  



    # Update answer 




    maximum_result = index_for_Stack1 




  



    # Traverse Stack 2 and insert 




    # elements into the current 




    # window one at a time 




    while (index_for_Stack2 < m) : 




        curr_sum += Stack2[index_for_Stack2] 




        index_for_Stack2 += 1




  



        # curr_sum after removing 




        # last elements from Stack1 




        while (curr_sum > K 




               and index_for_Stack1 > 0): 




            index_for_Stack1 -= 1




            curr_sum -= Stack1[index_for_Stack1] 




  



        # Updating the answer 




        maximum_result = max(maximum_result, 




                            index_for_Stack1 




                            + index_for_Stack2) 




  



    # Return Answer 




    return maximum_result 




  


# Driver Code 



if __name__ == '__main__': 




      



    S1 = [ 12, 21, 102 ]; 




    S2 = [ 167, 244, 377, 56, 




                 235, 269, 23 ]; 




    N = 3; 




    M = 7; 




    K = 1000; 




  



    print(Max_profit_maximisation(S1, S2, N, M, K)) 




  



    # This code is contributed by Samim Hossain Mondal.



















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program of the above approach 



using System; 




  



class GFG{ 




  


// Function to return max profit 


// from both stacks given as input 



static int Max_profit_maximisation(int []Stack1, int []Stack2, 




                                   int n, int m, int K) 



{ 



      



    // Stores the readonly answer 




    int maximum_result = 0; 




  



    // Stores the pointer to the 




    // current window in stack 1 




    int index_for_Stack1 =0; 




  



    // Stores the pointer to the 




    // current window in stack 2 




    int index_for_Stack2=int.MaxValue; 




  



    // Stores sum of current window 




    int curr_sum = 0; 




  



    // Case where snly stack 1 




    // is considered 




    while (index_for_Stack1 < n &&  




           curr_sum + Stack1[index_for_Stack1] < K)  




    { 




        curr_sum += Stack1[index_for_Stack1]; 




        index_for_Stack1++; 




    } 




  



    // Update answer 




    maximum_result = index_for_Stack1; 




  



    // Traverse Stack 2 and insert 




    // elements into the current 




    // window one at a time 




    while (index_for_Stack2 < m) 




    { 




        curr_sum += Stack2[index_for_Stack2]; 




        index_for_Stack2++; 




  



        // curr_sum after removing 




        // last elements from Stack1 




        while (curr_sum > K && index_for_Stack1 > 0) 




        { 




            index_for_Stack1--; 




            curr_sum -= Stack1[index_for_Stack1]; 




        } 




  



        // Updating the answer 




        maximum_result = Math.Max(maximum_result, 




                                  index_for_Stack1 +  




                                  index_for_Stack2); 




    } 




  



    // Return Answer 




    return maximum_result; 



} 



  


// Driver code 



public static void Main(String[] args) 



{ 



    int []S1 = { 12, 21, 102 }; 




    int []S2 = { 167, 244, 377, 56, 




                 235, 269, 23 }; 




    int N = 3; 




    int M = 7; 




    int K = 1000; 




  



    Console.Write(Max_profit_maximisation(S1, S2, N, M, K)); 



} 


} 



  


// This code is contributed by shikhasingrajput


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script> 



       // JavaScript code for the above approach 



 



       // Function to return max profit 




       // from both stacks given as input 




       function Max_profit_maximisation(Stack1, Stack2, 




           n, m, K) { 




           // Stores the final answer 




           let maximum_result = 0; 



 



           // Stores the pointer to the 




           // current window in stack 1 




           let index_for_Stack1 = 0; 



 



           // Stores the pointer to the 




           // current window in stack 2 




           let index_for_Stack2; 



 



           // Stores sum of current window 




           let curr_sum = 0; 



 



           // Case where snly stack 1 




           // is considered 




           while (index_for_Stack1 < n 




               && curr_sum + Stack1[index_for_Stack1] 




               < K) { 




               curr_sum += Stack1[index_for_Stack1]; 




               index_for_Stack1++; 




           } 



 



           // Update answer 




           maximum_result = index_for_Stack1; 



 



           // Traverse Stack 2 and insert 




           // elements into the current 




           // window one at a time 




           while (index_for_Stack2 < m) { 




               curr_sum += Stack2[index_for_Stack2]; 




               index_for_Stack2++; 



 



               // curr_sum after removing 




               // last elements from Stack1 




               while (curr_sum > K 




                   && index_for_Stack1 > 0) { 




                   index_for_Stack1--; 




                   curr_sum -= Stack1[index_for_Stack1]; 




               } 



 



               // Updating the answer 




               maximum_result 




                   = Math.max(maximum_result, 




                       index_for_Stack1 




                       + index_for_Stack2); 




           } 



 



           // Return Answer 




           return maximum_result; 




       } 



 



       // Driver code 




       let S1 = [12, 21, 102]; 




       let S2 = [167, 244, 377, 56, 




           235, 269, 23]; 




       let N = 3; 




       let M = 7; 




       let K = 1000; 



 



       document.write(Max_profit_maximisation(S1, S2, N, M, K)); 



 



 // This code is contributed by Potta Lokesh 




   </script>



















                        






                        








Output

3


Time Complexity: O(N+M)
Auxiliary Space: O(1)

	

        Article Tags : 
        

            Arrays
DSA
Greedy
Stack
TrueGeek        


		
	

	


      

      

          
Recommended Articles

      

      

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

          
2. Check if it is possible to obtain a Balanced Parenthesis by shifting brackets to either end at most K times

          
3. Check if there exists a pair (a, b) such that for all the N pairs either of the element should be equal to either a or b

          
4. Minimum digits to be removed to make either all digits or alternating digits same

          
5. Queries to find minimum sum of array elements from either end of an array

          
6. Queries to find the minimum array sum possible by removing elements from either end

          
7. Maximize the number of times a character can be removed from substring 01 from given Binary String

          
8. Count of distinct N-size Arrays with elements upto K such that adjacent element pair is either ascending or non-multiples

          
9. Maximize element at index K in an array with at most sum M and difference between adjacent elements at most 1

          
10. Minimize count of array elements to be removed to maximize difference between any pair up to K

          
11. Minimize count of 0s required to be removed to maximize length of longest substring of 1s

          
12. Find the last element after repeatedly removing every second element from either end alternately

          
13. Minimum array elements required to be subtracted from either end to reduce K to 0

          
14. Minimum jumps from either end to reach largest and smallest character in given String

          
15. Minimize deletions from either end to remove Minimum and Maximum from Array

          
16. Maximize sum of array elements removed by performing the given operations

          
17. Maximize sum of product of neighbouring elements of the element removed from Array

          
18. Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays

          
19. Maximize sum of products at corresponding indices in two arrays by reversing at most one subarray in first Array

          
20. Check if sum of array can be made equal to X by removing either the first or last digits of every array element

          
21. Maximize length of longest non-decreasing array possible by the elements present in either ends of the given array

          
22. Maximize the sum of sum of the Array by removing end elements

          
23. Generate an array with K positive numbers such that arr[i] is either -1 or 1 and sum of the array is positive

          
24. Count of triplets that can be removed without changing Mean of given Array

          
25. Count pairs with odd Bitwise XOR that can be removed and replaced by their Bitwise OR