【Codeforces-420D】Cup Trick(无旋treap-平衡树)

题目传送门：https://codeforces.com/problemset/problem/420/D

题意：给出m次操作，每次操作输入两个值x，y，将y位置值为x的数移到最前面，让你求一个长度为n的初始序列满足所要进行操作的条件。

思路：由于初始序列未知，我们可以将序列都设为0，然后按操作进行，如果进行操作时，y位置为0，说明这个位置没有动过，可以为之前操作中没有操作过的值（比如说，如果你上一步操作把3位置的1移到了最前面，那么这一步操作你不能将这个位置的1移到最前面，因为这个位置的值不是1，如果这个位置在最前面的话，那么位置的值就不是0而是1了），那么我们可以将这个位置的值设为x，并移到最前面的位置，如果在操作的过程中遇到了重复操作的值，或者位置上的值与所操作的值不吻合的话说明这个初始序列是不存在的，那么就直接输出-1。

具体实现：我们可以用平衡树来维护这个序列，利用平衡树是有序的，来维护每次操作将值移到最前面的过程，我们可以将平衡树的val作为序列排序的对比值，大的val在最后面，小的val在最前面，每次操作可以是之前的val-1就可以了，emm，具体实现还是看代码吧。

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
 
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<set>
#include<queue>
#include<map>
//#define int long long
using namespace std;
const int MAXN = 2000010;
const int MOD = 2147483647;
 
int inf = 2000005;
 
//inline int read() {
//    char a = getchar();
//    int x = 0, f = 1;//f判断正负数
//    while (a < '0' || a > '9') {
//        if (a == '-') f = -1;
//        a = getchar();
//    }
//    while (a >= '0' && a <= '9') {
//        x = x * 10 + (a - '0');
//        a = getchar();
//    }
//    return x * f;
//}
//inline void write(int x) {
//    if (x < 0) {
//        putchar('-');
//        x = -x;
//    }
//    if (x > 9) write(x / 10);
//    putchar(x % 10 + '0');
//}
 
queue<int>q;
 
struct Node
{
    int left;      //左子树
    int right;     //右子树
    int size;      //大小
    int val;       //值
    int key;       //平衡种子
    int real;
 
}tree[MAXN];
 
int root, tot;
 
inline int add(int val, int real) {
    tot++;
    tree[tot].size = 1;
    tree[tot].val = val;
    tree[tot].key = rand() % MOD;
    tree[tot].left = 0;
    tree[tot].right = 0;
    tree[tot].real = real;
 
    return tot;
}
 
inline void update_root(int now) {
    int left, right;
 
    left = tree[now].left;
    right = tree[now].right;
 
    tree[now].size = tree[left].size + tree[right].size + 1;
}
 
//拆分(now原treap,a左子树,b右子树,val值)
inline void split_new(int now, int& a, int& b, int val) {
    if (now == 0) {
        a = 0;
        b = 0;
        return;
    }
 
    if (tree[now].val <= val) {//now左子树中的所有值都小于now，
        a = now;
        split_new(tree[now].right, tree[a].right, b, val);
    }
    else {
        b = now;
        split_new(tree[now].left, a, tree[b].left, val);
    }
 
    update_root(now);
}
 
inline void merge_new(int& now, int a, int b) {
    if (a == 0 || b == 0) {
        now = a + b;
        return;
    }
 
    //按照key值合并(堆性质)
    if (tree[a].key < tree[b].key) {
        /**
         * a树key值小于b树，那么b树属于a树的后代，因为b树恒大于a树，那么b树一定属于a树的右后代，
         * a的左子树不变，直接赋给now，递归合并a的右子树和b
         */
        now = a;
        merge_new(tree[now].right, tree[a].right, b);
    }
    else {
        now = b;
        merge_new(tree[now].left, a, tree[b].left);
    }
 
    update_root(now);
}
 
int pos, value;
inline void find_new(int now, int rank) {//找第k大
    while (tree[tree[now].left].size + 1 != rank) {
        if (tree[tree[now].left].size >= rank) {
            now = tree[now].left;
        }
        else {
            rank -= tree[tree[now].left].size + 1;
            now = tree[now].right;
        }
    }
    pos = tree[now].val;
    value = tree[now].real;
    //cout << tree[now].val << " " << tree[now].real << "\n";
}
 
inline void insert_new(int val, int real) {
    int x, y, z;
 
    x = 0;
    y = 0;
    z = add(val, real);
    split_new(root, x, y, val);
    merge_new(x, x, z);
    merge_new(root, x, y);
}
 
inline void del_new(int val) {
    int x, y, z;
 
    x = y = z = 0;
    split_new(root, x, y, val);
    split_new(x, x, z, val - 1);
    merge_new(z, tree[z].left, tree[z].right);
    merge_new(x, x, z);
    merge_new(root, x, y);
}
 
inline void get_rank(int val) {
    int x, y;
 
    x = y = 0;
    split_new(root, x, y, val - 1);
    cout << tree[x].size + 1 << "\n";
    merge_new(root, x, y);
}
 
inline void get_val(int rank) {
    find_new(root, rank);
}
 
inline void get_pre(int val) {
    int x, y;
 
    x = y = 0;
    split_new(root, x, y, val - 1);
    find_new(x, tree[x].size);
    merge_new(root, x, y);
}
 
inline void get_next(int val) {
    int x, y;
 
    x = y = 0;
    split_new(root, x, y, val);
    find_new(y, 1);
    merge_new(root, x, y);
}
 
int mp[2000010];
int vis[1000005];
int sp[2000010];
 
int main() {
 
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    //cin >> n >> m;
    int rem = 0;
    cin >> n >> m;
    
 
    //memset(tree, 0, sizeof(tree));
 
    add(MOD, 0);
    root = 1;
    tree[root].size = 0;
 
    /*insert_new(2, 99);
    insert_new(1, 87);
    insert_new(3, 35);
    get_val(2);
    del_new(2);
    get_val(2);*/
 
    /*3 3
    1 3
    2 3
    3 3*/
 
    int flag = 1;
    for (int i = 1; i <= n; i++) {
        //s.insert(i);
        insert_new(inf - i, 0);    //利用val值来排序，val只需要不断递减，就可以保证每次操作都可以移动到最前面
        //get_val(1);
    }
    int cnt = inf - n;
    set<int>::iterator it;
    /*if (n == 1000000 && m == 1000000) {
        cout << -1 << "\n";
        return 0;
    }*/
    int x, y;
    for (; m; --m) {
        cin >> x >> y;
        /*x = read();
        y = read();*/
        //if (i >= 500000) continue;
        //if (!flag) continue;
        get_val(y);
        if (value == x || value == 0) {
            if (value == 0 && vis[x]) {
                flag = 0;
                //write(-1);
                cout << -1;
                return 0;
            }
            del_new(pos);
            insert_new(--cnt, x);
 
            //if (!vis[x]) {
            //    /*it = s.find(x);
            //    s.erase(it);*/
            //    sp[x] = 1;
            //}
            if (mp[pos] == 0 && !vis[x]) {
                mp[pos] = x;
                vis[x] = 1;
                sp[x] = 1;
            }
 
        }
        else {
            flag = 0;
            //write(-1);
            cout << -1;
            return 0;
            //cout << -1 << "\n";
        }
    }
    /*if (n == 1000000 && m == 1000000) {
        cout << -1 << "\n";
        return 0;
    }*/
    if (flag) {
        /*it = s.begin();
        while (it != s.end()) {
            q.push(*it);
            it++;
        }*/
        for (int i = 1; i <= n; i++) {
            if (!sp[i]) {
                q.push(i);
            }
        }
        /*for (int i = 1; i <= n; i++) {
            get_val(i);
            if (value == 0) {
                int p = q.front();
                q.pop();
                cout << p << " ";
            }
            else cout << value << " ";
        }*/
        //int itt = inf;
        for (int i = inf - n; i <= inf - 1; i++) {
            // pp;
            //mp[i] != 0 ? write(mp[i]), putchar(' ') : pp = q.front(), q.pop(), printf("%d", pp), putchar(' ');
            if (mp[i] != 0) {
                //cout << mp[i] << " ";
                cout << mp[i] << " ";
                //putchar(' ');
            }
            else {
                int pp = q.front();
                q.pop();
                cout << pp << " ";
                /*write(pp);
                putchar(' ');*/
            }
        }
    }
    else cout << -1;
 
    return 0;
}