Problem: 2061D - Kevin and Numbers
Language: java

Solution 1 (runtime: 718 ms):

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

public class ComTemp2 {

    private static final long MINA = 1;
    private static final long MAXA = 1000000000000L;
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    static PrintWriter writer;

    static int MOD = (int) (1e9 + 7);
    static final int MOD1 = 998244353;

    public static Scanner scanner = new Scanner(System.in);

    public static boolean flag1 = true, flag2 = true;

    public static void main(String[] args) throws IOException {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        tokenizer = new StringTokenizer("");

        int n = nextInt();
//        int n = 1;
        while (n-- > 0) {
            solve();
        }

        writer.close();
    }


    static int fun(int a1, int a2, int a3, int a4, int a5) {
        int count = 0;
        if (a3 == a1 + a2) count++;
        if (a4 == a2 + a3) count++;
        if (a5 == a3 + a4) count++;
        return count;
    }

    public static void solve() throws IOException {
        int n = nextInt(), m = nextInt();
        int[] arr = nextIntArray(n), brr = nextIntArray(m);
        PriorityQueue<Long> a = new PriorityQueue<>((x,y)->Long.compare(y,x)), b = new PriorityQueue<>((x,y)->Long.compare(y,x));
        for (int i = 0; i < n; i++) {
            a.add((long) arr[i]);
        }
        for (int i = 0; i < m; i++) {
            b.add((long) brr[i]);
        }
//        writer.println(a+" "+b);

        while (!a.isEmpty() && !b.isEmpty()) {
            if (Objects.equals(a.peek(), b.peek())){
                a.poll();
                b.poll();
            }else {
               long e = b.poll();
               if (e<a.peek() || a.size() <= b.size()){
                   writer.println("NO");
                   return;
               }
               b.add(e/2);
               if (e%2==0){
                   e/=2;
               }else {
                   e/=2;
                   e++;
               }
               b.add(e);
            }
        }

        if (!a.isEmpty() || !b.isEmpty()){
            writer.println("NO");
            return;
        }

        writer.println("YES");
    }

    public static void solv() throws IOException {
        int n = nextInt();
        for (int i = 0; i < 2; i++) {
            writer.print(1 + " ");
        }
        for (int i = 2; i < n - 1; i++) {
            writer.print(i + " ");
        }
        writer.println(1);
    }

    public static boolean isPowerLogarithmic(int x, int y) {
        if (x <= 0 || y <= 0 || y == 1) return false; // Edge cases

        double logResult = Math.log(x) / Math.log(y);
        return Math.abs(logResult - Math.round(logResult)) < 1e-10;
    }


/*
14
10100001000101
15
001110100100001
14
10100101111101

11
01100101101
14
01001111101001
 */

    private static int ask(int l, int r) throws IOException {
        if (r - l + 1 <= 1)
            return 0;
        writer.println(String.valueOf("? ") + String.valueOf(l) + " " + String.valueOf(r));
        writer.flush();
        return nextInt();
    }

    public static int leftmostBit(int n) {
        return (int) Math.pow(2, (int) (Math.log(n) / Math.log(2)));
    }

    public static int leftmostBit(long n) {
        return (int) Math.pow(2, (long) (Math.log(n) / Math.log(2)));
    }

    public static long gcdOfArray(int[] arr) {
        long result = arr[0];
        for (int i = 1; i < arr.length; i++) {
            result = gcd(result, arr[i]);
            if (result == 1)
                break; // Early exit if GCD is 1
        }
        return result;
    }

    static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public static List<Integer> findDivisors(int n) {
        List<Integer> divisors = new ArrayList<>();

        for (int i = 1; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                divisors.add(i); // Add the divisor
                if (i != n / i) { // Avoid duplicate for perfect squares
                    divisors.add(n / i);
                }
            }
        }

        // Optional: Sort the divisors if needed
        divisors.sort(Integer::compareTo);
        return divisors;
    }

    public static long[] unique(long[] arr) {
        int n = arr.length;
        ArrayList<Long> l1 = new ArrayList<>();
        l1.add(arr[0]);
        for (int i = 1; i < n; i++) {
            if (arr[i] == arr[i - 1]) {
                continue;
            } else {
                l1.add(arr[i]);
            }
        }
        n = l1.size();
        long[] tem = new long[n];
        for (int i = 0; i < n; i++) {
            tem[i] = l1.get(i);
        }
        return tem;
    }

    public static void reverseArray(long[] array) {
        int start = 0, end = array.length - 1;
        while (start < end) {
            long temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            start++;
            end--;
        }
    }

    public static <T> void printArr(int[] arr) {
        for (int e : arr) {
            writer.print(e + " ");
        }
        writer.println();
    }

    public static void printArr(long[] arr) {
        for (long e : arr) {
            writer.print(e + " ");
        }
        writer.println();
    }

    private static int lowerBound(long[] arr, long target, int start, int end) {
        int left = start, right = end;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    // Binary search for the last index where arr[index] <= target
    private static int upperBound(long[] arr, long target, int start, int end) {
        int left = start, right = end;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
//        if (arr[right]>target)return -1;
        return right;
    }

    public static class Pair<K, V> {
        private K key;
        private V value;

        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "Pair{" + "key=" + key + ", value=" + value + '}';
        }
    }

    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    static String nextLine() throws IOException {
        return reader.readLine();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    static int[] nextIntArray(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextInt();
        }
        return arr;
    }

    // Function to read the next array of longs
    static long[] nextLongArray(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextLong();
        }
        return arr;
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}


Solution 2 (runtime: 702 ms):
import java.util.*;
import java.io.*;
 
public class cp {
    static class Datamax implements Comparable<Datamax>{
        int idx;
        int val;
        public Datamax(int val,int idx){
            this.idx = idx;
            this.val = val;
        }
        @Override
        public int compareTo(Datamax p1){
            if(this.val<p1.val) return 1;
            return -1;
        }
    }
    static class Circle{
        int x;
        int y;
        int radius;
        public Circle(int x,int y,int radius){
            this.x = x;
            this.y = y;
            this .radius = radius;
        }
    }
    // static class Edge {
    //     int dst;
    //     int dir;
    //     public Edge(int dst,int dir){
    //         this.dir = dir;
    //         this.dst = dst;
    //     }
    // }
    public static PP.Reader cs = new PP.Reader(System.in);
    // public static Scanner cs = new Scanner(System.in);
    public static BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException{
        int tests = cs.nextInt();
        while(tests>0){
            tests--;
            solve();
        }
        // writer.flush();
        writer.close();
    }
    public static long mod = (long)Math.pow(10,9) + 7;
    public static long MOD = 998244353;
    public static int netchange = 0;
    public static boolean poss;
    // public static int nodes = 0;
    public static void solve() throws IOException{
        // long it = cs.nextLong();
        // int n = (int)it;
        int n = cs.nextInt();
        int m = cs.nextInt();
        // int k = cs.nextInt();
        // long k = cs.nextLong();  
        // String str = cs.next();
        // String strb = cs.next();
        // long[] arr = new long[n];
        // long[] brr = new long[m];
        HashMap<Long,Integer> hm = new HashMap<>();
        for(int i = 0; i < n; i++){
            long temp = cs.nextLong();
            if(hm.containsKey(temp)) hm.put(temp,hm.get(temp)+1);
            else hm.put(temp,1);
        }
        boolean answer = true;
        for(int i = 0; i < m; i++){
            long temp = cs.nextLong();
            if(!check_existence(hm, temp)){
                answer = false;
            }
        } 
        if(!hm.isEmpty() || !answer) System.out.println("No");
        else System.out.println("Yes");
    }
    //Write fxn here     
    public static boolean check_existence(HashMap<Long,Integer> hm,long element){
        if(hm.containsKey(element)){
            if(hm.get(element) == 1) hm.remove(element);
            else hm.put(element,hm.get(element)-1);
            return true;
        }
        if(element == 1) return false;
        long first = element/2;
        long second = element/2;
        if(element%2 == 1) second++;
        return check_existence(hm,first) && check_existence(hm,second);
    }
    public static void dfs(ArrayList<ArrayList<Integer>> graph,int curr,int changed[]){
        for(Integer nb : graph.get(curr)){
            if(changed[nb] != 0){
                if(changed[nb] == changed[curr]) poss = false;
            }
            else{
                if(changed[curr] == 1) changed[nb] = -1;
                else changed[nb] = 1;
                netchange += changed[nb];
                dfs(graph,nb, changed);
            }
        }
    }
    public static  int binary(int[] arr,int start,int end,int key){
        int mid = (int)start;
        int st = start;
        int en = end;
        while(start<=end){
            mid = (int)(start+end)/2;
            if(arr[mid]==key) return mid;
            else if(arr[mid]>key) end = mid-1;
            else if(arr[mid]<key) start = mid+1;
        }
        //if(end<start){
            if(end<st) end++;
            // if(start>en) start--;
            // if(Math.abs(arr[end]-key)<=Math.abs(arr[start]-key-1)){
                // return start;
            // }
            return end;
        //}
        //return mid+1;
    }
    public static long invmod(long A, long M)
    {
 
        for (int X = 1; X < (int)M; X++)
            if (((A % M) * (X % M)) % M == 1)
                return X;
        return 1;
    } 
    public static long gcd(long a,long b){
        long c = Math.min(a,b);
        long d = Math.max(a,b);
        if(d%c==0) return c;
        return gcd(c,d%c);
    }
    public static long divmod(long a,long b,long m){   //claculate (a/b)%m
        // a = a%m;b = b%m  // Include if not working
        long inv =  powermod(b, m-2, m);
        return (inv*a)%m;
    }
    static long powermod(long x, long y, long p) //calculate (x^y)%p
    {
        long res = 1;
        x = x % p; 
        while (y > 0) {
            if ((y & 1) > 0)
                res = (res * x) % p;
            y = y >> 1; 
            x = (x * x) % p;
        }
        return res;
    }
}

class PP {
    static String IN = "%s";
    static String OUT = "%s";

    static class Reader {
        BufferedReader br;
        StringTokenizer st;

        Reader(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            try {
                while (st == null || !st.hasMoreTokens())
                    st = new StringTokenizer(br.readLine());
                return st.nextToken();
            } catch (Exception ignored) {
            }
            return null;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}