Luogu 3960 [NOIP2017] 列队 - splay|线段树

题解

是我从来没有做过的裂点splay。。。 看的时候还是很懵逼的QAQ。

把最后一列的$n$个数放在一个平衡树中， 有 $n$ 个点

剩下的$n$行数， 每行都开一个平衡树，开始时每棵树中仅有$1$个点， 记录了开始时的区间左端点 $1$ 和右端点$m - 1$。

这样每次出队都最多只会影响两棵平衡树， 其中一颗为表示最后一列的平衡树。

然后就可以分成两种情况进行处理

1. $y = m$ 即出队的人位于最后一列，那么仅会影响最后一列的那颗平衡树， 删除位于第$x$个位置的点， 再插入到最后即可

2. $y \ne m$ 首先把最后一列的平衡树的第$x$个节点 $tmp$ 删除，

　　然后将第$x$棵平衡树 分成$[1,y - 1]$,$ y $,$ [y +1,m - 1] $三个区间， 再将y删除并插入到 最后一列平衡树的最后。

　　最后再把tmp插入到第$x$ 棵平衡树的最后。

虽然看起来很暴力， 但因为我太弱还是想不到TAT

代码

 #include<cstring>
 #include<algorithm>
 #include<cstdio>
 #define rd read()
 #define ri register int
 #define il inline
 using namespace std;
 typedef long long ll;

 const int N = 3e5 + 1e4;

 int sz[N << ], cnt[N << ], l[N << ], r[N << ], root[N]; //root为每颗平衡树的根节点
 int ch[N << ][], f[N << ];
 ll key[N << ];//key为节点对应的人的编号
 int n, m, q, tot;

 int read() {
     int X = , p = ; char c = getchar();
     for(; c > '' || c < ''; c = getchar() ) if( c == '-' ) p = -;
     for(; c >= '' && c <= ''; c = getchar() ) X = X *  + c - '';
     return X * p;
 }

 il void update( int x ) {
     sz[x] = cnt[x];
     sz[x] += sz[ch[x][]] + sz[ch[x][]];
 }

 il int get( int x ) {
     return ch[f[x]][] == x;
 }

 int build( int l, int r , int fa ) {//最后一列的平衡树
     if( l > r ) return ;
     int mid = (l + r) >> ;
     sz[mid] = cnt[mid] = ;
     key[mid] = 1LL * mid * m;//编号
     f[mid] = fa;
     ch[mid][] = build( l, mid - , mid );
     ch[mid][] = build( mid + , r, mid );
     update(mid);
     return mid;
 }

 void rotate( int x ) {
     int old = f[x], oldf = f[old], son = ch[x][get(x) ^ ];
     if(oldf) ch[oldf][get(old)] = x;
     ch[x][get(x) ^ ] = old;
     ch[old][get(x)] = son;
     f[old] = x; f[x] = oldf;
     if(son) f[son] = old;
     update(old); update(x);
 }

 void splay( int x, int id ) {//id表示平衡树的编号
     for( int fa; (fa = f[x]); rotate(x))
         if(f[fa]) rotate(get(fa) == get(x) ? fa : x);
     root[id] = x;
 }

 int findk( int k , int now ) {//查询最后一列的平衡树中的第k个点
     for(; ;) {
         if( k <= sz[ch[now][]] ) now = ch[now][];
         else if( k == sz[ch[now][]] + cnt[now] ) return now;
         else {
             k -= sz[ch[now][]] + cnt[now];
             now = ch[now][];
         }
     }
 }

 void insert_last( int id, ll x ) {//向第id棵平衡树的末尾插入key为x 的点
     if(!root[id]) {
         root[id] = ++tot;
         key[tot] = x;
         sz[tot] = cnt[tot] = ;
         ch[tot][] = ch[tot][] = ;
         return;
     }
     int now = root[id];
     for(; ch[now][]; now = ch[now][] );
     f[++tot] = now;
     ch[tot][] = ch[tot][] = ;
     ch[now][] = tot;
     sz[tot] = cnt[tot] = ;
     key[tot] = x;
     update(now);
     splay(tot, id);
 }

 int pre( int id ) {//前驱
     int now = ch[root[id]][];
     for(; ch[now][]; now = ch[now][] );
     return now;
 }

 void del( int id ) {//删除第id棵平衡树的根节点
     int rt = root[id];
     if(!ch[rt][] && !ch[rt][]) {
         root[id] = ;
         return;
     }
     if(!ch[rt][]) {
         root[id] = ch[rt][];
         f[root[id]] = ;
         return;
     }
     if(!ch[rt][]) {
         root[id] = ch[rt][];
         f[root[id]] = ;
         return;
     }
     int pr = pre(id);
     splay(pr, id);
     ch[pr][] = ch[rt][];
     f[ch[rt][]] = pr;
     update(pr);
 }

 void split( int k, int now, int id ) {//将第id棵平衡树分裂
     if( k <= sz[ch[now][]] ) {
         split(k, ch[now][], id);
         return;
     }
     if( k > sz[ch[now][]] + cnt[now] ) {
         split(k - sz[ch[now][]] - cnt[now], ch[now][], id);
         return;
     }
     k -= sz[ch[now][]];
     if( k !=  ) {
         sz[++tot] = k - ;
         cnt[tot] = k - ;
         f[tot] = now;
         cnt[now] -= k - ;
         ch[tot][] = ch[now][];
         f[ch[now][]] = tot;
         ch[now][] = tot;
         l[tot] = l[now];
         r[tot] = l[tot] + k - ;
         l[now] = r[tot] + ;
         update(tot);
     }
     if(cnt[now] != ) {
         sz[++tot] = cnt[now] - ;
         cnt[tot] = cnt[now] - ;
         f[tot] = now;
         cnt[now] = ;
         ch[tot][] = ch[now][];
         f[ch[now][]] = tot;
         ch[now][] = tot;
         r[tot] = r[now];
         r[now] = l[now];
         l[tot] = l[now] + ;
         update(tot);
     }
     splay(now, id);
 }

 int main()
 {
     n = rd, m = rd; q = rd;
     root[] = build( , n, );
     tot = n;
     for( int i = ; i <= n; ++i ) {
         root[i] = ++tot;
         sz[tot] = cnt[tot] = m - ;
         l[tot] = ; r[tot] = m - ;
     }
     for(; q; --q ) {
         int x = rd, y = rd, tmp = findk(x, root[]);
         ll ans;
         splay(tmp, );
         del();//删除tmp
         if( y != m ) {
             split(y, root[x], x);
             int rt = root[x];
             if(!key[rt]) key[rt] = 1LL * (x - ) * m + l[rt];
             ans = key[rt];
             del(x);
             insert_last(x, key[tmp]);//向第x棵平衡树插入，表示左移
             insert_last(, ans);//向最后一列的平衡树插入，表示将位于x,y的人拉到最后
         }
         else {
             insert_last(, key[tmp]);
             ans = key[tmp];
         }
         printf("%lld\n", ans);
     }
 }

---

更新。。。

用动态开点线段树做了一波

和splay差不多的思想， 先不把线段树中的点都开满，有$N+1$个空树。

定义$sum$为删除的数，每次查询第$k$个数时， 把$k$与 mid - l + 1 - sum[lson[nd]] 进行比较， 进入相应子树继续查询。

添加时就用vector插入。

删除时只要添加节点并记录

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #define ll long long
 #define rd read()
 using namespace std;

 const int N = 3e6;

 int n, m, q, tot;
 int rt[N << ], ls[N << ], rs[N << ], sum[N << ];
 int pos, mx;

 vector<ll> v[N];

 int read() {
     int X = , p = ; char c = getchar();
     for(; c > '' || c < ''; c = getchar()) if(c == '-') p = -;
     for(; c >= '' && c <= ''; c = getchar()) X = X *  + c - '';
     return X * p;
 }

 void change(int &o, int l, int r) {
     if(!o) o = ++tot;
     sum[o]++;
     if(l == r) return;
     int mid = (l + r) >> ;
     if(pos <= mid) change(ls[o], l, mid);
     else change(rs[o], mid + , r);
 }

 int query(int nd, int l, int r, int k) {
     if(l == r) return l;
     int mid = (l + r) >> , tmp = mid - l +  - sum[ls[nd]];
     if(k <= tmp) return query(ls[nd], l, mid, k);
     else return query(rs[nd], mid + , r, k - tmp);
 }

 ll work1(int x, ll y) {
     pos = query(rt[n + ], , mx, x);
     change(rt[n + ], , mx);
     ll ans = pos <= n ? 1LL * m * pos : v[n + ][pos - n - ];
     v[n + ].push_back(y ? y : ans);
     return ans;
 }

 ll work2(int x, int y) {
     pos = query(rt[x], , mx, y);
     change(rt[x], , mx);
     ll ans = pos < m ? 1LL * (x - ) * m + pos : v[x][pos - m];
     v[x].push_back(work1(x, ans));
     return ans;
 }

 int main()
 {
     n = rd; m = rd; q = rd;
     mx = max(n, m) + q;
     for(; q; q--) {
         int x = rd, y = rd;
         if(y == m) printf("%lld\n", work1(x, ));
         else printf("%lld\n", work2(x, y));
     }
 }