HackerEarth Rooms problem solution

In this HackerEarth Rooms problem solution, Harsh is thinking of starting his own business.He has decided to start with the hotel business. He has been given a list which contains the arrival time and the duration of stay of each guest at his hotel. He can give 1 room to only 1 guest.Since he does not want to disappoint his guests he wants to find the minimum number of rooms he need to build so that he could accomodate all the guests. Help him in finding this answer.

import java.io.*;
import java.util.*;
public final class hotel_stay
{
    static FastScanner sc=new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out=new PrintWriter(System.out);
    static Pair[] c;
    static Node[] tree;

    static void build(int node,int l,int r)
    {
        if(l>r)
        {
            return;
        }
        if(l==r)
        {
            tree[node]=new Node(l,c[l].r);
        }
        else
        {
            int mid=(l+r)>>1;
            build(node<<1,l,mid);
            build(node<<1|1,mid+1,r);
            if(tree[node<<1].val<tree[node<<1|1].val)
            {
                tree[node]=tree[node<<1];
            }
            else
            {
                tree[node]=tree[node<<1|1];
            }
        }
    }

    static Node getMin(int node,int s,int e,int l,int r)
    {
        if(s>e || l>e || r<s)
        {
            return new Node(-1,Long.MAX_VALUE);
        }
        if(l<=s && r>=e)
        {
            return tree[node];
        }
        else
        {
            int mid=(s+e)>>1;
            Node q1=getMin(node<<1,s,mid,l,r);
            Node q2=getMin(node<<1|1,mid+1,e,l,r);
            if(q1.val<q2.val)
            {
                return q1;
            }
            else
            {
                return q2;
            }
        }
    }

    static void update(int node,int s,int e,int l,int r,long val)
    {
        if(s>e || l>e || r<s)
        {
            return;
        }
        if(l<=s && r>=e)
        {
            if(tree[node].idx==l)
            {
                tree[node].val=val;
            }
        }
        else
        {
            int mid=(s+e)>>1;
            update(node<<1,s,mid,l,r,val);
            update(node<<1|1,mid+1,e,l,r,val);
            if(tree[node<<1].val<tree[node<<1|1].val)
            {
                tree[node]=tree[node<<1];
            }
            else
            {
                tree[node]=tree[node<<1|1];
            }
        }
    }

    public static void main(String args[]) throws Exception
    {
        int t=sc.nextInt();
        while(t>0)
        {
            int n=sc.nextInt(),max=1;
            long[] a=new long[n],b=new long[n];
            c=new Pair[n];
            tree=new Node[4*n];
            for(int i=0;i<n;i++)
            {
                a[i]=sc.nextLong();
            }
            for(int i=0;i<n;i++)
            {
                b[i]=sc.nextLong();
                c[i]=new Pair(a[i],a[i]+b[i]);
            }
            Arrays.sort(c);
            build(1,0,n-1);
            int ans=0;
            for(int i=0;i<n;i++)
            {
                Node min_node=getMin(1,0,n-1,0,i-1);
                //out.println(i+" "+min_node.val);
                if(min_node.val<=c[i].l)
                {
                    update(1,0,n-1,min_node.idx,min_node.idx,Long.MAX_VALUE);
                    continue;
                }
                else
                {
                    ans++;
                }
            }
            out.println(ans);
            t--;
        }
        out.close();
    }
}
class Pair implements Comparable<Pair>
{
    long l,r;
    public Pair(long l,long r)
    {
        this.l=l;
        this.r=r;
    }
    public int compareTo(Pair x)
    {
        return Long.compare(this.l,x.l);
    }
}
class Node
{
    int idx;
    long val;
    public Node(int idx,long val)
    {
        this.idx=idx;
        this.val=val;
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public String next() throws Exception {
        return nextToken().toString();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}