Maximum K-digit number possible from subsequences of two given arrays

import java.util.*;
import java.io.*;

// Java program for the above approach
class GFG{

    // Function to calculate maximum 
    // number from nums of length c_len
    static ArrayList<Integer> helper(ArrayList<Integer> nums, int c_len)
    {
        // Store the resultant maximum
        ArrayList<Integer> ans = new ArrayList<Integer>();
      
        // Length of the nums array
        int ln = nums.size();
      
        // Traverse the nums array
        for(int i = 0 ; i < ln ; i++)
        {   
            while(ans.size() > 0 && ans.get(ans.size() - 1) < nums.get(i) && ((ln-i) > (c_len - ans.size()))){
                // If true, then pop
                // out the last element
                ans.remove(ans.size() - 1);
            }
            
            // Check the length with
            // required length
            if(ans.size() < c_len){
                // Append the value to ans
                ans.add(nums.get(i));
            }
        }
        // Return the ans
        return ans;
    }

    // Returns True if a1 is greater than a2
    static boolean comp(ArrayList<Integer> a1, ArrayList<Integer> a2){
        int s1 = a1.size();
        int s2 = a2.size();

        int i1 = 0, i2 = 0;
        while(i1 < s1 && i2 < s2){
            if(a1.get(i1) > a2.get(i2)){
                return true;
            }else if(a1.get(i1) < a2.get(i2)){
                return false;
            }
            i1++;
            i2++;
        }
        if(i1 < s1) return true;
        return false;
    }

    // Function to find maximum K-digit number
    // possible from subsequences of the
    // two arrays nums1[] and nums2[]
    static ArrayList<Integer> maxNumber(ArrayList<Integer> nums1, ArrayList<Integer> nums2,int k)
    {
        // Store lengths of the arrays
        int l1 = nums1.size();
        int l2 = nums2.size();
        
        // Store the resultant subsequence
        ArrayList<Integer> rs = new ArrayList<Integer>();
        
        // Traverse and pick the maximum
        for(int s1 = Math.max(0, k-l2) ; s1 <= Math.min(k, l1) ; s1++)
        {
            // p1 and p2 stores maximum number possible
            // of length s1 and k - s1 from
            // the arrays nums1[] & nums2[]
            ArrayList<Integer> p1 = new ArrayList<Integer>();
            ArrayList<Integer> p2 = new ArrayList<Integer>();

            p1 = helper(nums1, s1);
            p2 = helper(nums2, k-s1);
            
            // Update the maximum number
            ArrayList<Integer> temp = new ArrayList<Integer>();
            for(int j = 0 ; j < k ; j++)
            { 
                ArrayList<Integer> temp2 = comp(p1, p2) ? p1 : p2;
                int fr = temp2.get(0);
                if(comp(p1, p2)){
                    if(p1.size() > 0){
                        p1.remove(0);
                    }
                }else{
                    if(p2.size() > 0){
                        p2.remove(0);
                    }
                }
                temp.add(fr);
            }
            
            rs = comp(rs, temp) ? rs : temp;
            
        }
        // Return the result
        return rs;
    }
    

    public static void main(String args[])
    {
        ArrayList<Integer> arr1 = new ArrayList<Integer>(
            List.of(
                3, 4, 6, 5
            )
        );
        ArrayList<Integer> arr2 = new ArrayList<Integer>(
            List.of(
                9, 1, 2, 5, 8, 3
            )
        );
        int K = 5;
      
        // Function Call
        ArrayList<Integer> v = maxNumber(arr1, arr2, K);
        for(int i = 0 ; i < v.size() ; i++){
            System.out.print(v.get(i) + " ");
        }
    }
}

// This code is contributed by subhamgoyal2014.