代码求调。使用平衡树。全WA。

#include <bits/stdc++.h>

namespace tree {
    class AVL_tree {
    private:
        struct node {
            int key, count, size, height;
            node *left, *right;

            node(int val) : key(val), count(1), size(1), height(1), left(nullptr), right(nullptr) {}

            int get_balance() {
                return (left ? left->height : 0) - (right ? right->height : 0);
            }

            void updatesize() {
                size = (left ? left->size : 0) + (right ? right->size : 0) + count;
            }

            void updateheight() {
                height = std::max((left ? left->height : 0), (right ? right->height : 0)) + 1;
            }
        } *root = nullptr;

        void rightrotate(node *&p) {
            node *l = p->left, *t2 = l->right;
            p->left = t2;
            l->right = p;
            (*p).updateheight();
            (*p).updatesize();
            (*l).updatesize();
            (*l).updateheight();
            p = l;
        }

        void leftrotate(node *&p) {
            node *r = p->right, *t2 = r->left;
            p->right = t2;
            r->left = p;
            (*p).updateheight();
            (*p).updatesize();
            (*r).updatesize();
            (*r).updateheight();
            p = r;
        }

        void rebalance(node *&p) {
            if (!p) {
                return;
            } else {
                int b = (*p).get_balance();
                if (b < 2 && b > -2) {
                    return;
                } else if (b > 1) {
                    if (p->left->get_balance() < 0) {
                        leftrotate(p->left);
                    }
                    rightrotate(p);
                } else {
                    if (p->right->get_balance() > 0) {
                        rightrotate(p->right);
                    }
                    leftrotate(p);
                }
            }
        }

        void insert(int val, node *&p) {
            if (!p) {
                p = new node(val);
                return;
            } else if (p->key == val) {
                p->count++;
                return;
            } else if (p->key > val) {
                insert(val, p->left);
            } else {
                insert(val, p->right);
            }
            p->updatesize();
            p->updateheight();
            rebalance(p);
        }

        int kth_element(int k, node *&p) {
            if (!p) {
                return 0;
            } else if (!p->left) {
                if (k == 0) {
                    return p->key;
                } else {
                    return 114514;
                }
            } else {
                if (p->left->size > k) {
                    return kth_element(k, p->left);
                } else if (p->left->size + p->count > k) {
                    return p->key;
                } else {
                    return kth_element(k - p->left->size - p->count, p->right);
                }
            }
        }

    public:
        void insert(int val) {
            insert(val, root);
        }

        int kth_element(int k) {
            return kth_element(k, root);
        }
    };
}
using namespace std;
tree::AVL_tree box;
int m, n, a[200005], u[200005], i;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> m >> n;
    for (int j = 1; j <= m; ++j) {
        cin >> a[j];
    }
    for (int j = 1; j <= n; ++j) {
        cin >> u[j];
    }
    for (int j = 1; j <= m; j++) {
        box.insert(a[j]);
        if (j >= u[i + 1]) {
            cout << box.kth_element(i) << endl;
//            cout<<j<<endl;
            i++;
        }
    }
//    cout<<i;
    return 0;
}