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: 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;



    }



















}