treap

//poj 1442
#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<cstdio>
using namespace std;
const int N=1000000+100;
struct Node
{
    Node* son[2];
    int rank;
    int size;
    int key;
    int nu;
    bool operator<(const Node &a)const
    {
        return rank<a.rank;   //重载小于好，用于维护堆的性质
    }
    int cmp(int x)const
    {
        if(x==key) return -1;    //比较函数，用于确定寻找的值的位置，0表示左儿子，1表示右儿子，-1代表当前节点
        return x<key?0:1;
    }
    void maintain()//这里仅仅需要维护size
    {
        size = nu + son[0]->size + son[1]->size;
    }
}node[N];

struct Treap
{
    int n_cnt;
    Node *root;
    Node *null ;//定义空结点，可以有效避免NULL带来的问题
    //初始化Treap
    void init()
    {
        null=&node[0];
        memset(null,0,sizeof(node[0]));
        n_cnt=1;
        srand(time(NULL));
        root = null;
    }
    //旋转操作，d=0时代表左旋，d=1时代表右旋
    void rotate(Node* &o,int d)
    {
        Node*  k = o->son[d^1];
        o->son[d^1] = k -> son[d];
        k->son[d] = o;
        o->maintain();//注意，必须先维护o再维护k，因为o是子节点，不优先维护，会导致父节点出错
        k->maintain();
        o = k;
    }
    void ins(Node*  &o,int x)
    {
        if(o==null)
        {
            o = &node[n_cnt++];
            o->son[0] = o->son[1] = null;
            o->rank = rand();
            o->key = x;
            o->size = 1;
            o->nu=1;
        }
        else
        {
            int d = o->cmp(x);
            if(d==-1)
            {
                o->nu++;
            }
            else
            {
                ins(o->son[d],x);
                if(*o < *(o->son[d]) )
                    rotate(o,d^1);//当位于左儿子时，需要进行的是右旋，当位于右儿子时应当进行左旋，因此通项为rotate(o,d^1)
            }
        }
        o->maintain();
    }
    void del(Node* &o,int x)
    {
        int d = o->cmp(x);
        if(d==-1)//已经找到待删除节点，将会有两种情况
        {
            if(o->nu>1)
            {
                o->nu--;o->maintain();
            }
            else if(o->son[0] == null) o = o->son[1];//左儿子为空，直接连接父节点和右儿子
            else if(o->son[1] == null) o= o->son[0];//右儿子为空，同上
            else
            {
                d = *(o->son[0]) < *(o->son[1]) ? 0:1;//在子节点中找到一个rank大的节点，将其旋转到当前节点，那么当前节点应当位于相反的子节点
                rotate(o,d);
                del(o->son[d],x);
            }
        }
        else
            del(o->son[d],x);
        if(o!=null) o->maintain();//删除节点后，需要对size进行维护。需要注意的是，如果节点为空时，就不需要维护了
    }
    int kth(Node* o,int k)//寻找第k大数
    {
        if(o == null || k<=0 || k>o->size) return -1;//k过大或者过小都不能找到，Treap中没有节点也无需找
        int s = o->son[1]->size;//获得右儿子的size
        if(k <= s+o->nu&&k>s) return o->key;//当k为 s + 1时，说明当前节点就是答案
        else
            if(k<=s) return kth(o->son[1],k);//当k<s时，说明第k大数在右子树，k值无需更改
        else
            return kth(o->son[0],k-s-o->nu);//当k>s+1时，第k大数在左子树，需要减去右子树的值和节点本身
    }
    int find(Node* o,int k)//返回该数是第几大
    {
        if(o == null) return -1;
        int d = o->cmp(k);
        if(d == -1) return 1 + o->son[1]->size;
        else if(d == 1) return find(o->son[d],k);
        else
        {
            int tmp = find(o->son[d],k);
            if(tmp == -1) return -1;
            else
                return tmp + o->nu + o->son[1]->size;
        }
    }
} treap;

int val[N];
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        treap.init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&val[i]);
        }
        int st=1;
//        for(int i=1;i<=n;i++)
//        {
//            treap.ins(treap.root,val[i]);
//        }
//        printf("%d\n",treap.root->size);
        for(int i=1;i<=m;i++)
        {
            int a;scanf("%d",&a);
            for(int j=st;j<=a;j++)
            {
                treap.ins(treap.root,val[j]);
            }
            st=a+1;
            printf("%d\n",treap.kth(treap.root,treap.root->size-i+1));
        }
    }
    return 0;
}