Problem: 2061D - Kevin and Numbers
Language: java

Solution 1 (runtime: 718 ms):
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.NavigableSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
 
/*
 *   Author : RTE_ELMENATOR
 *   
 *   "No one will carry you. 
 *    Work harder, and turn your dream into reality."
 *   "
 *      If you're stuck in a problem while solving 
 *      Then Think about the Answer (how related to input) 
 *   "
 *   " Tree Questions : -> dp on tree
 *    dfs calcualtes the subtree distance 
 *    dfs 2 calculates the parent answer and sub tree ans combine we can give
 *     ( Path of max distance can't consider max 2 can consider "  
 */
 

public class CpWala {
	private static void solverA() {
		int size[] = Reading.readIntArray();
		int n  = size[ 0  ] , m  = size[ 1 ];
	   int[] arr = Reading.readIntArray();
	   int[] barr = Reading.readIntArray();
	   HashMap<Integer , Integer> map = new HashMap<>();
	   for(int i : arr ) {
		   map.put( i , map.getOrDefault( i , 0) + 1);
	   }
	  
	
	   int l = 0 , lb = 0 ;
	   
	   for(; lb < m ; ++ lb   ) {
		   if( barr[ lb ] ==0 ) continue;
		   int need = barr[ lb ] ;
		   
		   boolean isokay = find( need , map );
	      if(!isokay) {out.println("NO"); return;}
	   }
	   if(map.isEmpty()) out.println("YES");
	   else out.println("NO");
	}
	private static boolean find( int val ,HashMap<Integer , Integer> map ) {
		
		if( map.containsKey( val )) {
			map.put( val , map.get( val ) - 1);
		  if( map.get( val ) == 0 ) map.remove( val );
			return true;
		}
		if( val == 1) return false;
		return find( val /2 , map ) && find( val/2 + (val%2 )  , map );
	}
	private static void dfs( int curNode , int parent , ArrayList<Long> prefix 
		,	ArrayList<Long> prefix_sum , ArrayList<TreeNode>[] tree , int[] res ) {
	         if( tree[ curNode ] == null ) return;
		for(var node : tree [ curNode ]) {
			 if( parent == node.next ) continue;
			long ai = node.weight;
			long bi = node.weight1 ; 
			int next = node.next;
		    
			prefix.add( prefix.get( prefix.size()  - 1) + ai ) ; 
			
			prefix_sum.add( prefix_sum.get( prefix_sum.size() - 1) + bi );
		    res[ next ] = find(next  , prefix.get( prefix.size() - 1)  , prefix_sum ) ;  
			dfs( next ,  curNode , prefix , prefix_sum , tree , res );
			prefix.remove( prefix.size() -1  );
			prefix_sum.remove( prefix_sum.size() - 1); 		
			
		}
	}
  private static int find( int x , long value ,  ArrayList<Long> search  ) {
	  int v = Collections.binarySearch(search  , value );
	  //out.println( search +" "+value+" "+x +" "+v );
	  if( v < 0 ) return -(v + 2);
	  return v;
  }
  static PrintWriter out = new PrintWriter(System.out);
 
  public static void main(String[] arg) {
    int testNo =   Reading.readInt();
    while (testNo-- > 0) {
      solverA();
    }
    out.flush();
    out.close();
  }
 
  private static long getLowerPower(long rem, int k) {
    // k^x <= n
    long res = 1;
    while (res <= rem) {
      res = res * k;
    }
    res /= k;
    return res;
  }
 
  private static long findMinoOpern(int n, int k) {
    if (k == 1) return n;
    long res = getLowerPower(n, k);
    int count = 0;
    long rem = n;
    while (rem >= k) {
      long powcan = (rem / res);
      rem = (rem % res);
      count += powcan;
      res = getLowerPower(rem, k);
    }
    return rem % k + count;
  }
 
  private static int[] kmp(String string) {
    int[] res = new int[string.length()];
    int j = 0;
    for (int indx = 1; indx < string.length();) {
      if (string.charAt(indx) == string.charAt(j)) {
        if (j == 0) {
          res[indx] = 1;
        } else
          res[indx] = j + 1;
        j++;
        indx++;
      } else {
        if (j == 0) {
          indx++;
          continue;
        }
        j = res[j - 1];
      }
    }
    return res;
  }
}
class Union {
	int[] parent ;
	int[] rank ; 
	int n ; 
	int[] size ;
	public Union ( int size  ) {
		n  = size + 1;
		this.size = new int[ size + 1 ];
		parent = new int [ size + 1];
	   rank = new int[ size + 1];
	   Arrays.fill( this.size ,1 );
	   Arrays.fill( parent , -1 );
	   Arrays.fill( rank , -1 );
	}
	public void union(int u , int v ) {
		int parent_u = find( u ) ;
		int parent_v = find( v );
		if( parent_u != parent_v ) {
			if( parent_v > parent_u) {
			parent[ parent_u ] = parent_v  ; 
			size[ parent_u ] += size[ parent_v ];
			}
			else {
				parent[ parent_v ] = parent_u;
				size[ parent_u ]+=size[ parent_u];
			}
		}
	}
	public int find( int node ) {
		if( parent[ node ] == -1 ) return node ; 
		return parent[ node ] = find( parent[ node ]);
	}
 
}
class TreeNode {
	int  next  ; 
	long weight , weight1 ;
	public TreeNode ( int node , int weight , int weight1 ) {
		this.next = node ; 
		this.weight = weight;
		this.weight1 = weight1 ; 
	}
	public String toString() {
		return "["+next+" , " + weight + " , "+weight1+" ] ";
	}
}
class Reading {
  private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
 
  public Reading() {
    reader = new BufferedReader(new InputStreamReader(System.in));
  }
 
  public static int readInt() {
    try {
      return Integer.parseInt(reader.readLine().trim());
    } catch (Exception e) {
      return -1;
    }
  }
 
  public static int[] readIntArray() {
    try {
      return Arrays.stream(reader.readLine().trim().split("\\s+"))
                   .mapToInt(Integer::parseInt)
                   .toArray();
    } catch (Exception e) {
      return null;
    }
  }
 
  public static long[] readLongArray() {
    try {
      return Arrays.stream(reader.readLine().trim().split("\\s+"))
                   .mapToLong(Long::parseLong)
                   .toArray();
    } catch (Exception e) {
      return null;
    }
  }
 
  public static String readString() {
    try {
      return reader.readLine();
    } catch (Exception e) {
      return null;
    }
  }
 
  public static char[] readToCharArray() {
    try {
      return reader.readLine().replaceAll("\\s+", "").toCharArray();
    } catch (Exception e) {
      return null;
    }
  }
}

Solution 2 (runtime: 718 ms):


import java.io.*;

import java.util.*;



public class bcf{









    //functions to reduce time

    public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));







    public static int max=Integer.MAX_VALUE, min=Integer.MIN_VALUE;

    public static long maxl=(long)1e9, minl=Long.MIN_VALUE;

    public static long mod=1000000007;

    public static void main(String[] swami) throws FileNotFoundException {



        try {

//            File file = new File("/home/swamikedari/Documents/IdeaProjects/cpContests/src/testcases.txt");

//

//            // Check if the file exists

//            if (file.exists() && !file.isDirectory()) {

//                br = new BufferedReader(new FileReader(file));

//            }

            int t=getint();

            while(t-->0){

                int n=getint(), m=getint();

                long[] a=getarrl(n);

                long[] b=getarrl(m);



                PriorityQueue<Long> qa=new PriorityQueue<>(Comparator.reverseOrder());

                PriorityQueue<Long> qb=new PriorityQueue<>(Comparator.reverseOrder());

                for(long v: a)qa.add(v);

                for(long v: b)qb.add(v);

                boolean notpossible=false;

                while(!qa.isEmpty() && !qb.isEmpty() && qb.size()<=qa.size()){

                    while(!qb.isEmpty() && !Objects.equals(qb.peek(), qa.peek()) && qb.size()<=qa.size()) {

                        long minb = qb.remove();

                        qb.add((long)Math.ceil((double)minb/2));

                        qb.add((long)Math.floor((double)minb/2));

                    }

                    if(!qb.isEmpty() && qb.size()<=qa.size()) { qb.remove();qa.remove();}

                    else { notpossible=true; break;}

                }

                //println(qa.toString());

                //println(qb.toString());

                if(!qa.isEmpty() || !qb.isEmpty() || notpossible)println("NO");

                else println("YES");

            }

        }

        catch(Exception e){

            System.out.println(e);

        }

    }





    public static char value(char a,char b){

        String set="SET";

        for(int i = 0; i<set.length(); i++){

            if(set.charAt(i)!=a && set.charAt(i)!=b)return set.charAt(i);

        }

        return '?';

    }



    public static boolean isgreat(int[][] a,int i,int j){

        int[] xi={-1,0,1,0};

        int[] yi={0,-1,0,1};

        boolean isbig=true;

        for(int ind=0;ind<4;ind++){

            if(isbd(i+xi[ind],j+yi[ind],a.length,a[0].length)){

                if(a[i][j]<=a[i+xi[ind]][j+yi[ind]]){

                    isbig=false;

                }

            }

        }

        return isbig;

    }



    public static int maxval(int[][] a,int i,int j){

        int[] xi={-1,0,1,0};

        int[] yi={0,-1,0,1};

        int val=0;

        for(int ind=0;ind<4;ind++){

            if(isbd(i+xi[ind],j+yi[ind],a.length,a[0].length)){

                val=Math.max(a[i+xi[ind]][j+yi[ind]],val);

            }

        }

        return val;

    }





    public static boolean isbd(int i,int j,int n,int m){

        if(i>=0 && i<n && j>=0 && j<m)return true;

        return false;

    }





    public static boolean getans(long[] a,int i,long x,long[] ans){

        ans[0]++;

        if(i<0){

            return false;

        }

        if(x<0){

            return false;

        }

        if(x==0){

            return true;

        }

        boolean take=false;

        if(a[i]<=x){

            take=getans(a,i,x-a[i],ans);

        }

        boolean nottake=getans(a,i-1,x,ans);

        return take|nottake;

    }



    public static int getans(char[] ch,int i,int j, int n,int[][] dp){

        if(i==n){

            return 0;

        }

        int ans=(int)1e9;

        if(dp[i][j]!=-1){

            return dp[i][j];

        }

        if(j==0){

            int val=0;

            for(int k=i;k<=n;k++){

                ans=Math.min(ans,getans(ch,k,1,n,dp)+val);

                if(k<n && ch[k]=='b'){

                    val++;

                }

            }



            return dp[i][j]=ans;

        }

        else if(j==1){

            int val=0;

            for(int k=i;k<=n;k++){

                ans=Math.min(ans,getans(ch,k,2,n,dp)+val);

                if(k<n && ch[k]=='a'){

                    val++;

                }

            }

            return dp[i][j]=ans;

        }

        else{

                ans=0;

                for(int k=i;k<n;k++){

                    if(ch[k]!='a'){

                        ans++;

                    }

                }

                //println(ans);

                return dp[i][j]=ans;



        }

    }



    public static void dfs(ArrayList<ArrayList<Integer>> ar,int i,boolean[] vis,ArrayList<Integer> val){



        vis[i]=true;

        val.add(Integer.valueOf(i));

        for(int k: ar.get(i)){

            if(!vis[k]){

                dfs(ar,k,vis,val);

            }

        }

    }







    public static void dfs(ArrayList<HashSet<Integer>> ar,int i,boolean[] v){

        //print(i+" ");

        v[i]=true;

        for(int k: ar.get(i)){

            if(!v[k]){

                dfs(ar,k,v);

            }

        }

    }





    static StringTokenizer st=new StringTokenizer("");

    static String next() {

        while (!st.hasMoreTokens())

            try {

                st=new StringTokenizer(br.readLine());

            } catch (IOException e) {

                e.printStackTrace();

            }

        return st.nextToken();

    }









    public static int[] getarr(int n){

        int[] a=new int[n];

        for(int i=0;i<n;i++){

            a[i]=getint();

        }

        return a;

    }



    public static long[] getarrl(int n){

        long[] a=new long[n];

        for(int i=0;i<n;i++){

            a[i]=getlong();

        }

        return a;

    }

    public  static int getint(){

        return Integer.parseInt(next());

    }



    public  static long getlong(){

        return Long.parseLong(next());

    }



    public static String getstr(){

        return next();

    }



    // print statements



    public static void println(int i){

        System.out.println(i);

    }

    public static void println(String k){

        System.out.println(k);

    }



    public static void println(long k){

        System.out.println(k);

    }

    public static void println(float k){

        System.out.println(k);

    }

    public static void println(char k){

        System.out.println(k);

    }

    public static void println(double k){System.out.println(k); }

    public static void println(){System.out.println();}

    public static void println(int[] a){

        System.out.println(Arrays.toString(a));

    }

    public static void println(long[] a){

        System.out.println(Arrays.toString(a));

    }

    public static void println(char[] a){

        System.out.println(Arrays.toString(a));

    }

    public static void println(float[] a){

        System.out.println(Arrays.toString(a));

    }

    public static void println(double[] a){

        System.out.println(Arrays.toString(a));

    }

    public static void print(int[] A) {

        for(int i : A) {

            System.out.print(i+" ");

        }

        System.out.println();

    }

    public static void print(long[] A) {

        for(long i : A) {

            System.out.print(i+" ");

        }

        System.out.println();

    }



    public static void print(int i){

        System.out.print(i);

    }

    public static void print(String k){

        System.out.print(k);

    }

    public static void print(double k){System.out.print(k); }

    public static void print(long k){

        System.out.print(k);

    }

    public static void print(float k){

        System.out.print(k);

    }

    public static void print(char k){

        System.out.print(k);

    }





    // mod by the number

    static long mod(long x) {

        return ((x%mod + mod)%mod);

    }



    // gcd

    public static long gcd(long i,long j){

        if(i==0){

            return j;

        }

        return gcd(j%i,i);

    }



    // lcm

    public static long lcm(long i,long j){

        return i*j/gcd(i,j);

    }





    public static int gcd(int i,int j){

        if(i==0){

            return j;

        }

        return gcd(j%i,i);

    }



    // lcm

    public static int lcm(int i,int j){

        return i*j/gcd(i,j);

    }



    // quick sort



    public static void quicksort(int[] a,int l,int h){

        if(l<h){

            int pivot=partition(a,l,h);

            quicksort(a,l,pivot-1);

            quicksort(a,pivot+1,h);

        }

    }



    public static int partition(int[] a,int l,int h){

        int i=l-1;

        int piv=a[h];

        for(int j=l;j<h;j++){

            if(a[j]<piv){

                i++;

                swap(a,i,j);

            }

        }

        swap(a,i+1,h);

        return i+1;

    }



    public static void quicksortrev(int[] a,int l,int h){

        if(l<h){

            int pivot=partitionrev(a,l,h);

            quicksortrev(a,l,pivot-1);

            quicksortrev(a,pivot+1,h);

        }

    }



    public static int partitionrev(int[] a,int l,int h){

        int i=l-1;

        int piv=a[h];

        for(int j=l;j<h;j++){

            if(a[j]>piv){

                i++;

                swap(a,i,j);

            }

        }

        swap(a,i+1,h);

        return i+1;

    }



    public static void swap(int[] a,int i,int j){

        int temp=a[i];

        a[i]=a[j];

        a[j]=temp;



    }







    // binarysearch for the input and between the input



    public static int bs(int[] a,int i,int j,int k,int n){

        if(i<=j){

            int mid=mid(i,j);

            if(mid+1<n && a[mid]<=k && a[mid+1]>k){

                return mid;

            }

            else if(a[mid]<=k && mid==n-1){

                return mid;

            }

            else if(a[mid]>k && mid==0){

                return mid;

            }

            else if(a[mid]<k){

                return  bs(a,mid+1,j,k,n);

            }

            else{

                return bs(a,i,mid-1,k,n);

            }

        }

        return -1;

    }



    public static int mid(int i,int j){

        return (i+j)/2;

    }



    public static int bs(long[] a,int i,int j,long  k,int n){

        if(i<=j){

            int mid=mid(i,j);

            if(mid+1<n && a[mid]<=k && a[mid+1]>k){

                return mid;

            }

            else if(a[mid]<=k && mid==n-1){

                return mid;

            }

            else if(a[mid]<k){

                return  bs(a,mid+1,j,k,n);

            }

            else{

                return bs(a,i,mid-1,k,n);

            }

        }

        return -1;

    }



    public static long mid(long i,long j){

        return (i+j)/2;

    }



    // converting the int value to the char value and vice versa

    public static int toint(char a){

        return (int)a-48;

    }



    public static int tochar(int a){

        return (char)(a+48);

    }



    // converting the small alphabet characters to index and vice-versa

    public static int chartoint(char a){

        return (int)a-97;

    }



    public static char inttochar(int a){

        return (char)(a+97);

    }





    // important dp problems memoization solutions



    public static int lcs(String a,String b,int i,int j,int[][] dp,boolean[][] vis){

        if(i<0 || j<0){

            return 0;

        }

        if(vis[i][j]){

            return dp[i][j];

        }

        vis[i][j]=true;

        if(a.charAt(i)==b.charAt(j)){

            return dp[i][j]=lcs(a,b,i-1,j-1,dp,vis)+1;

        }

        else{

            return dp[i][j]=lcs(a,b,i-1,j,dp,vis);

        }

    }



    // power functions



    public static long pow(long a,long b){

        long ans=1;

        while(b!=0){

            if(b%2==1){

                ans=(ans*a)%1000000007;

            }

            a=a*a;

            a=a%1000000007;

            b/=2;

        }

        return ans;

    }





    // min and max functions



    public static int max(int a, int b){

        return Math.max(a, b);

    }



    public static int min(int a, int b){

        return Math.min(a, b);

    }





    static int max(int[] A) {

        int max=Integer.MIN_VALUE;

        for (int j : A) {

            max = Math.max(max, j);

        }

        return max;

    }

    static int min(int[] A) {

        int min=Integer.MAX_VALUE;

        for (int j : A) {

            min = Math.min(min, j);

        }

        return min;

    }

    static long max(long[] A) {

        long max=Long.MIN_VALUE;

        for (long l : A) {

            max = Math.max(max, l);

        }

        return max;

    }

    static long min(long[] A) {

        long min=Long.MAX_VALUE;

        for (long l : A) {

            min = Math.min(min, l);

        }

        return min;

    }



    // prime numbers related functions

    public static ArrayList<Integer> sieveOfEratosthenes(int n)

    {

        ArrayList<Integer> primes = new ArrayList<>();

        boolean[] prime = new boolean[n+1];

        for(int i=0;i<=n;i++)

            prime[i] = true;



        for(int p = 2; p*p <=n; p++)

        {



            if(prime[p])

            {



                for(int i = p*p; i <= n; i += p)

                    prime[i] = false;

            }

        }





        for(int i = 2; i <= n; i++)

        {

            if(prime[i])

                primes.add(Integer.valueOf(i));

        }

        return primes;

    }





    // prefix sum arrays and suffix sum array



    public static long [] prefix(long [] A) {

        long[] p=new long[A.length];

        p[0]=A[0];

        for(int i=1;i<A.length;i++)

            p[i]=p[i-1]+A[i];

        return p;

    }

    public static long [] prefix(int [] A) {

        long[] p=new long[A.length];

        p[0]=A[0];

        for(int i=1;i<A.length;i++)

            p[i]=p[i-1]+A[i];

        return p;

    }

    public static long [] suffix(long [] A) {

        long[] p=new long[A.length];

        p[A.length-1]=A[A.length-1];

        for(int i=A.length-2;i>=0;i--)

            p[i]=p[i+1]+A[i];

        return p;

    }

    public static long [] suffix(int [] A) {

        long[] p=new long[A.length];

        p[A.length-1]=A[A.length-1];

        for(int i=A.length-2;i>=0;i--)

            p[i]=p[i+1]+A[i];

        return p;

    }





    // hash map direct storage using the arrays



    public static HashMap<Long,Long> hash(long [] A){

        HashMap<Long,Long> map=new HashMap<Long, Long>();

        for(long i : A) {

            if(map.containsKey(i)) {

                map.put(i, map.get(i)+(long)1);

            }

            else {

                map.put(i, (long)1);

            }

        }

        return map;

    }



    public static HashMap<Integer,Long> hash(int[] A){

        HashMap<Integer,Long> map=new HashMap<Integer, Long>();

        for(int i : A) {

            if(map.containsKey(i)) {

                map.put(i, map.get(i)+(long)1);

            }

            else {

                map.put(i, (long)1);

            }

        }

        return map;

    }





    public static HashMap<Character,Long> hash(char [] A){

        HashMap<Character,Long> map=new HashMap<Character,Long>();

        for(char i : A) {

            if(map.containsKey(i)) {

                map.put(i, map.get(i)+(long)1);

            }

            else {

                map.put(i, (long)1);

            }

        }

        return map;

    }



    // segment tree implementation

    public static int[] array=new int[100005];

    public static int[] segarray=new int[4*100005];



    public static void buildmax(int ind,int low,int high){

        int mid=mid(low,high);

        if(low==high){

            segarray[ind]=array[low];

        }

        buildmax(2*ind+1,low,mid);

        buildmax(2*ind+2,mid+1,high);

        segarray[ind]=max(array[2*ind+1],array[2*ind+2]);



    }



    public static int querymax(int ind,int low,int high,int l,int r){

        if(low>=l && high<=r){

            return segarray[ind];

        }

        if(high<l || low>r){

            return min;

        }

        int mid=mid(low,high);

        int left=querymax(2*ind+1,low,mid,l,r);

        int right=querymax(2*ind+2,mid+1,high,l,r);

        return max(left,right);

    }





    public static void buildsum(int ind,int low,int high){

        int mid=mid(low,high);

        if(low==high){

            segarray[ind]=array[low];

        }

        buildsum(2*ind+1,low,high);

        buildsum(2*ind+2,low,high);

        segarray[ind]=segarray[2*ind+1]+segarray[2*ind+2];

    }



    public static int querysum(int ind,int low,int high,int l,int r){

        if (low >= l && high <= r) {

            return segarray[ind];

        }

        if(high<l || low>r){

            return 0;

        }

        int mid=mid(low,high);

        int left=querysum(2*ind+1,low,mid,l,r);

        int right=querysum(2*ind+2,mid+1,high,l,r);

        return left+right;



    }



















}