Problem: 2061D - Kevin and Numbers
Language: c++17 

Solution 1 (runtime: 171 ms):
#include <stdio.h>
#include <algorithm>

int num = 0;
int arr[200000][2];

int search(int p)
{
    int l = -1, r = num - 1;
    while(r - l > 1)
    {
        int m = (l + r) / 2;
        if(arr[m][0] >= p)
            r = m;
        else
            l = m;
    }
    return r;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        num = 0;
        int n, m;
        scanf("%d%d", &n, &m);
        int a[n], b[m];
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        for(int i = 0; i < m; i++)
            scanf("%d", &b[i]);
        std::sort(a, a + n);
        std::sort(b, b + m);
        for(int i = 0; i < n; i++)
            arr[i][1] = 0;
        for(int i = 0; i < n; i++)
        {
            if(i == 0)  
            {
                arr[num][0] = a[i];
                arr[num][1]++;
            }
            else
            {
                if(a[i] != arr[num][0])
                    num++;
                arr[num][0] = a[i];
                arr[num][1]++;
            }
        }
        num++;
        for(int i = 0; i < m; i++)
        {
            int yes = 0;
            int even, num_even, odd, num_odd;
            even = b[i];
            num_even = 1;
            while(1)
            {
                if(even & 1 == 1)
                    break;
                int pos_even = search(even);
                if(arr[pos_even][0] == even)
                {
                    if(arr[pos_even][1] >= num_even)
                    {
                        yes = 1;
                        arr[pos_even][1] -= num_even;
                        break;
                    }
                    else
                    {
                        num_even -= arr[pos_even][1];
                        arr[pos_even][1] = 0;
                    }
                }
                even /= 2;
                num_even *= 2;
            }
            if(yes == 1 && i != m - 1)
                continue;
            if(yes)
            {
                for(int i = 0; i < num; i++)
                {
                    if(arr[i][1] != 0)
                    {
                        printf("No\n");
                        break;
                    }
                    if(i == num - 1)
                        printf("Yes\n");
                }
                break;
            }
            int pos = search(even);
            if(arr[pos][0] == even)
            {
                if(arr[pos][1] >= num_even)
                {
                    arr[pos][1] -= num_even;
                    if(i != m - 1)
                        continue;
                    for(int i = 0; i < num; i++)
                    {
                        if(arr[i][1] != 0)
                        {
                            printf("No\n");
                            break;
                        }
                        if(i == num - 1)
                            printf("Yes\n");
                    }
                    break;
                }
                else
                {
                    num_even -= arr[pos][1];
                    arr[pos][1] = 0;
                }
            }
            int tem = even / 2;
            num_odd = num_even;
            if(tem & 1 == 1)
            {
                odd = tem;
                even = odd + 1;
            }
            else
            {
                odd = tem + 1;
                even = tem;
            }
            yes = 1;
            while(1)
            {
                int pos_even = search(even);
                if(arr[pos_even][0] == even)
                {
                    if(arr[pos_even][1] >= num_even)
                    {;
                        arr[pos_even][1] -= num_even;
                        num_even = 0;
                    }
                    else
                    {
                        num_even -= arr[pos_even][1];
                        arr[pos_even][1] = 0;
                    }
                }
                int pos_odd = search(odd);
                if(arr[pos_odd][0] == odd)
                {
                    if(arr[pos_odd][1] >= num_odd)
                    {
                        arr[pos_odd][1] -= num_odd;
                        num_odd = 0;
                    }
                    else
                    {
                        num_odd -= arr[pos_odd][1];
                        arr[pos_odd][1] = 0;
                    }
                }
                if(num_even == 0 && num_odd == 0)
                    break;
                int tem_even = even / 2;
                int tem_num_odd = num_odd;
                int tem_num_even = num_even;
                int tem_odd = odd / 2;
                if(tem_odd & 1 == 1)
                {
                    odd = tem_odd;
                    num_odd = tem_num_odd;
                    even = tem_odd + 1;
                    num_even = tem_num_odd;
                }
                else
                {
                    even = tem_odd;
                    num_even = tem_num_odd;
                    odd = tem_odd + 1;
                    num_odd = tem_num_odd;
                }
                if(tem_even & 1 == 1)
                    num_odd += tem_num_even * 2;
                else
                    num_even += tem_num_even * 2;
                if(even == 0)
                {
                    if(arr[0][0] == 1 && arr[0][1] >= num_odd)
                    {
                        yes = 1;
                        arr[0][1] -= num_odd;
                    }
                    else
                        yes = 0;
                    break;
                }
            }
            if(!yes)
            {
                printf("No\n");
                break;
            }
            if(i == m - 1)
            {
                for(int i = 0; i < num; i++)
                {
                    if(arr[i][1] != 0)
                    {
                        printf("No\n");
                        break;
                    }
                    if(i == num - 1)
                        printf("Yes\n");
                }
            }
        }
    }
    return 0;
}

Solution 2 (runtime: 390 ms):
// #include <bits/stdc++.h>

// // #include <numeric>

// using namespace std;



// // #define pi (3.141592653589)

// //#define mod 1000000007

//  //#define pb push_back

// // #define is insert

// // #define mp make_pair

// // #define ff first

// // #define ss second

// // #define all(x) x.begin(), x.end()

// // #define min3(a, b, c) min(c, min(a, b))

// // #define min4(a, b, c, d) min(d, min(c, min(a, b)))

// // #define rfr(n) for(int i=n-1;i>=0;i--)

// // #define rep1(i,a,b) for(long long i=a;i<=b;i++)

// // #define fr(n) for(long long i=0;i<n;i++)

// // #define nesfr(x,y) for(long long i=0;i<x;i++)for(long long j=0;j<y;j++)

// // #define nesf1(x,y) for(long long i=1;i<x;i++)for(long long j=1;j<y;j++)



// // #define rep(i,a,b) for(long long i=a;i<b;i++)

// //#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

// #define fastIO                                                                 \

//     ios::sync_with_stdio(false);                                               \

//     cin.tie(NULL);                                                             \

//     cout.tie(NULL);                                                            \

//     cout.precision(numeric_limits<double>::max_digits10);

//  typedef long long ll;

// // typedef long double ld;

// // typedef vector<ll> vi;

// // #define nl cout << "\n"

// #define int long long

// using ull = unsigned long long;

// // const int INF = 2e18;



// // const int MAX_BIT = 30;

// // const int MOD = 998244353;

// // int add(int x, int y) {

// //     x += y;

// //     if (x >= MOD) x -= MOD;

// //     return x;

// // }

// //bool special = false;

// // long long gcd(long long a, long long b) {

// //     while (b) {

// //         a %= b;

// //         std::swap(a,b);

// //     }

// //     return a;

// // }



// // #define MAXN 1001

// // int a[MAXN];



// // int count_char(const string& s, char c) {

// //     int cnt = 0;

// //     for (char ch : s) {

// //         if (ch == c) cnt++;

// //     }

// //     return cnt; 

// // }









// // int floorOp(int x, int n) {

// //     while(n--) {

// //         if(x == 0) break;

// //         x /= 2;

// //     }

// //     return x;

// // }



// // int ceilOp(int x, int m) {

// //     while(m--) {

// //         if(x <= 1) break;

// //         x = (x + 1) / 2;

// //     }

// //     return x;

// // }





// void solve() {

//      int n,m;

//     cin>>n>>m;

//     ll sumA=0, sumB=0;

//     unordered_map<ll,int> cnt;

//     cnt.reserve(n*2);

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

//         ll x;cin>>x;

//         sumA += x;

//         cnt[x]++;

//     }

//     priority_queue<ll> pq;

//     for(int i=0;i<m;i++){

//         ll x;cin>>x;

//         sumB += x;

//         pq.push(x);

//     }

//     if(sumA != sumB){

//         cout<<"No"<<endl;

//         return;

//     }

//     while(!pq.empty() && !cnt.empty()){

//         ll x = pq.top(); pq.pop();

//         auto it = cnt.find(x);

//         if(it != cnt.end()){

//             if(--it->second == 0)

//                 cnt.erase(it);

//         } else {

//             if(x == 1) break;

//             pq.push(x/2);

//             pq.push(x - x/2);

//         }

//     }

//     cout<<(cnt.empty()?"Yes":"No")<<endl;

// }





// int32_t main() {

//     int t = 1;

//     cin >> t;

//     while (t--) {

//         solve();

//     }

//     return 0;

// }

#include "bits/stdc++.h"

using namespace std;



#define N 500005

#define ll long long

#define SZ(s) (int)s.size()



ll n, m;

multiset <int> s, g;



int solve(int x) {

    if(!x || SZ(s) == 0 || *s.begin() > x) return -1;

    if(s.find(x) != s.end()) {

        s.erase(s.find(x));

        return 1;

    }

    return min(solve(x / 2), solve((x + 1) / 2));

}



int main () {

    ios::sync_with_stdio(0);cin.tie(0);

    int tc;

    cin >> tc;

    while(tc--) {

        cin >> n >> m;

        s.clear();

        g.clear();

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

            int x;

            cin >> x;

            s.insert(x);

        }

        for(int i = 1; i <= m; i++) {

            int x;

            cin >> x;

            g.insert(x);

        }

        bool tr = 0;

        for(auto i : g) {

            if(tr) break;

            if(!(~solve(i))) tr = 1;

        }

        if(tr == 1 || SZ(s) > 0) cout << "NO\n";

        else cout << "YES\n";

    }

}