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: 796 ms):
import java.io.*;
import java.util.*;

public class Main {
    public static int INF = 0x3f3f3f3f, mod = 1000000007, mod9 = 998244353;
    public static void main(String args[]){
        try {
            PrintWriter o = new PrintWriter(System.out);
            boolean multiTest = true;
            // init
            if(multiTest) {
                int t = nextInt(), loop = 0;
                while (loop < t) {loop++;solve(o);}
            } else solve(o);
            o.close();
        } catch (Exception e) {e.printStackTrace();}
    }
    static void solve(PrintWriter o) {
        try {
            int n = nextInt(), m = nextInt(), k = n-m;
            int[] a = new int[n];
            int[] b = new int[m];
            Map<Integer, Integer> map = new HashMap<>();
            for(int i=0;i<n;i++) {
                a[i] = nextInt();
                map.put(a[i], map.getOrDefault(a[i], 0)+1);
            }
            PriorityQueue<Integer> pq = new PriorityQueue<>((x,y)->Integer.compare(y,x));
            for(int i=0;i<m;i++) {
                b[i] = nextInt();
                pq.offer(b[i]);
            }
            while(!pq.isEmpty()) {
                int x = pq.poll();
                if(map.get(x) != null) {
                    map.put(x, map.get(x)-1);
                    if(map.get(x) == 0) map.remove(x);
                }
                else if(k-- > 0) {
                    pq.offer(x/2);
                    pq.offer((x+1)/2);
                }
                else {
                    o.println("No");
                    return;
                }
            }
            if(k > 0) o.println("No");
            else o.println("Yes");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static int lower_bound(Integer[] a, long val){
        int l = 0, r = a.length;
        while(l < r){
            int mid = l + (r - l) / 2;
            if(a[mid] < val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int lower_bound(List<Integer> li, long val){
        int l = 0, r = li.size();
        while(l < r){
            int mid = l + (r - l) / 2;
            if(li.get(mid) < val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int upper_bound(long[] preSum, long val){
        int l = 0, r = preSum.length;
        while(l < r){
            int mid = l + (r - l) / 2;
            if(preSum[mid] <= val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int upper_bound(List<int[]> li, long val){
        int l = 0, r = li.size();
        while(l < r){
            int mid = l + (r - l) / 2;
            if(li.get(mid)[0] <= val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int upper_bound(List<Integer> li, int val){
        int l = 0, r = li.size();
        while(l < r){
            int mid = l + (r - l) / 2;
            if(li.get(mid) <= val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int upper_bound(int[] a, long val){
        int l = 0, r = a.length;
        while(l < r){
            int mid = l + (r - l) / 2;
            if(a[mid] <= val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int lower_bound(List<int[]> li, int val){
        int l = 0, r = li.size();
        while(l < r){
            int mid = l + (r - l) / 2;
            if(li.get(mid)[0] < val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int lower_bound(int[] a, int val){
        int l = 0, r = a.length;
        while(l < r){
            int mid = l + (r - l) / 2;
            if(a[mid] < val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static int lower_bound(long[][] a, long val){
        int l = 0, r = a.length;
        while(l < r){
            int mid = l + (r - l) / 2;
            if(a[mid][0] < val) l = mid + 1;
            else r = mid;
        }
        return l;
    }
    public static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a%b);
    }
    public static long[] extgcd(long a, long b) {
        if(b == 0) return new long[]{1, 0};
        long[] it = extgcd(b, a%b);
        long x = it[1], y = it[0];
        y -= a/b*x;
        return new long[]{x, y};
    }
    public static long lcm(long a, long b){
        return a / gcd(a,b)*b;
    }
    public static long qpow(long a, long n){
        long ret = 1l;
        while(n > 0){
            if((n & 1) == 1) ret = ret * a;
            n >>= 1;
            a = a * a;
        }
        return ret;
    }
    public static long qpow(long a, long n, int md){
        a %= md;
        long ret = 1l;
        while(n > 0){
            if((n & 1) == 1) ret = ret * a % md;
            n >>= 1;
            a = a * a % md;
        }
        return ret;
    }
    public static class FenWick {
        int n;
        long[] a;
        long[] tree;
        public FenWick(int n){
            this.n = n;
            a = new long[n+1];
            tree = new long[n+1];
        }
        private void add(int x, long val){
            while(x <= n){
                tree[x] += val;
                x += x&-x;
            }
        }
        private void addMx(int x, long val) {
            a[x] += val;
            tree[x] = a[x];
            while(x <= n) {
                for(int i=1;i<(x&-x);i<<=1) tree[x] = Math.max(tree[x], tree[x-i]);
                x += x&-x;
            }
        }
        private void addMn(int x, long val) {
            a[x] += val;
            tree[x] = a[x];
            while(x <= n) {
                for(int i=1;i<(x&-x);i<<=1) tree[x] = Math.min(tree[x], tree[x-i]);
                x += x&-x;
            }
        }
        private long query(int x){
            long ret = 0l;
            while(x > 0){
                ret += tree[x];
                x -= x&-x;
            }
            return ret;
        }
        private long queryMx(int l, int r) {
            long res = 0l;
            while(l <= r) {
                if(r-(r&-r) >= l) {
                    res = Math.max(res, tree[r]);
                    r -= r&-r;
                }
                else {
                    res = Math.max(res, a[r]);
                    r--;
                }
            }
            return res;
        }
        private long queryMn(int l, int r) {
            long res = 1l<<55;
            while(l <= r) {
                if(r-(r&-r) >= l) {
                    res = Math.min(res, tree[r]);
                    r -= r&-r;
                }
                else {
                    res = Math.min(res, a[r]);
                    r--;
                }
            }
            return res;
        }
    }
    static class Pair {
        Integer p1, p2;
        public Pair(Integer p1, Integer p2) {
            this.p1 = p1;
            this.p2 = p2;
        }
        @Override
        public int hashCode() {
            int prime = 31, ret = 0;
            ret = ret*prime+p1.hashCode();
            ret = ret*prime+p2.hashCode();
            return ret;
        }
        @Override
        public boolean equals(Object o) {
            if(o instanceof Pair pair) {
                return p1.equals(pair.p1) && p2.equals(pair.p2);
            }
            return false;
        }
    }
    static class DSU {
        int[] parent;
        int[] size;
        public DSU(int n) {
            parent = new int[n];
            size = new int[n];
            for(int i=0;i<n;i++) {
                parent[i] = i;
                size[i] = 1;
            }
        }
        public int find(int x) {
            if(parent[x] != x) parent[x] = find(parent[x]);
            return parent[x];
        }
        public void union(int x, int y) {
            int root_x = find(x);
            int root_y = find(y);
            if(root_x == root_y) return;
            parent[root_x] = root_y;
            size[root_y] += size[root_x];
            size[root_x] = 0;
        }
    }
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer tokenizer = new StringTokenizer("");
    private static String next() throws IOException{
        while(!tokenizer.hasMoreTokens()){tokenizer = new StringTokenizer(reader.readLine());}
        return tokenizer.nextToken();
    }
    public static int nextInt() throws IOException {return Integer.parseInt(next());}
    public static Long nextLong() throws IOException {return Long.parseLong(next());}
    public static double nextDouble() throws IOException {return Double.parseDouble(next());}
    public static char nextChar() throws IOException {return next().toCharArray()[0];}
    public static String nextString() throws IOException {return next();}
    public static String nextLine() throws IOException {return reader.readLine();}
}