For each A[i] find smallest subset with all elements less than A[i] sum more than B[i]

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

// Java program for Find minimum size of subset
// for each index of the array satisfying the
// given condition
public class GFG{

    // Functions to print minimum size of subset
    // for each element satisfying the given conditions
    public static void printSubsets(int N, int A[], int B[]){

        // Storing the elements of A along with
        // their indices in a arrayList of pairs v
        Pair v[] = new Pair[N];
        for(int i = 0 ; i < N ; i++){
            v[i] = new Pair(A[i], i);
        }

        // Sorting the array v
        Arrays.sort(v, new comp());

        // Declaring a array of size N to
        // store the answer
        int ans[] = new int[N];

        // Declaring a map to store the corresponding
        // values of B
        TreeMap<Integer, Integer> s = new TreeMap<Integer,Integer>();

        // iterating through the sorted arraylist v.
        // Since the arraylist is sorted, so the 1st
        // condition is already fulfilled, i.e.
        // all the elements of A at indices of resultant
        // set would be less than current A[i]
        for (int i = 0 ; i < N ; i++) {
            int curr_B = B[v[i].second];

            int size = 0;
            int sum = 0;
            // iterating through the set to find
            // the minimum set whose sum>B[i]
            //(or curr_B)
            for (Map.Entry<Integer, Integer> x : s.entrySet()) {
                for(int j=1 ; j<=x.getValue() ; j++){
                    sum += (-x.getKey());
                    size += 1;
                    if (sum > curr_B)
                        break;
                }
                if (sum > curr_B)
                    break;
            }

            // inserting the current element of B
            // into the TreeMap
            if(s.containsKey(-curr_B)){
                s.put(-curr_B, s.get(-curr_B)+1);
            }else{
                s.put(-curr_B, 1);
            }
    
            // if sum>B[i] condition is fulfilled,
            // we assign size of resultant subset to
            // the answer at the index
            if (sum > curr_B) {
                ans[v[i].second] = size;
            }
    
            // else we assign -1
            else {
                ans[v[i].second] = -1;
            }
        }
    
        // printing the answer
        for (int i = 0; i < N; i++) {
            System.out.print(ans[i] + " ");
        }
    }

    // Driver code
    public static void main(String args[])
    {
        int N = 5;
        int A[] = {3, 2, 100, 4, 5};
        int B[] = {1, 2, 4, 3, 5};

        printSubsets(N, A, B);
    }
}

class Pair{
    Integer first;
    Integer second;

    Pair(int x, int y){
        this.first = x;
        this.second = y;
    }
}

class comp implements Comparator<Pair>{
    public int compare(Pair x, Pair y){
        if(x.first.equals(y.first)){
            return x.second.compareTo(y.second);
        }
        return x.first.compareTo(y.first);
    }
}

// This code is contributed by subhamgoyal2014.