@codeforces - 1056G@ Take Metro

Posted 2021-03-25 tiw-air-oao

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

环上有 n 个点，按顺时针顺序以 1 到 n 编号。其中 1~m 号点是红色的，m+1~n 号点时蓝色的。
一开始你位于点 s，并给定一个 t。

你需要重复以下步骤，直到 t = 0：
如果你所在结点为红色，顺时针移动 t 个点；否则逆时针移动 t 个点。然后 t 减一。

求最终所在的结点编号。

Input
第一行包含两个整数 n 和 m (3≤n≤10^5, 1≤m<n)，含义见上。
第二行包含两个整数 s 和 t (1≤s≤n, 1≤t≤10^12)，含义见上。

Output
仅输出一个整数，表示最终所在的结点编号。

Examples
Input
10 4
3 1
Output
4

Input
10 4
3 5
Output
4

@solution@

不难想到当 x > n 时，我们等价于走 x mod n 步（n 步相当于绕一个圈子）。
于是我们可以预先走 t mod n 步，之后每一次就走 n 步（即走 n, n - 1, ..., 1 步），重复 t / n 次。
我们可以预处理每个点走 n, n - 1, ..., 1 步所到达的目的地，然后就可以倍增了。

接着考虑怎么预处理每个点走 n, n - 1, ..., 1 步所到达的目的地。我们不妨大胆设一个 dp。
假如说正着设 dp 状态（即定义 dp[i][j] 表示从 i 出发走 n, ..., n - j 步所到达的目的地），我们的转移依赖于 dp[i][j-1]，不好进行优化。
于是我们倒着设 dp 状态，即定义 dp[i][j] 表示从 i 出发走 j, ..., 1 步所到达的目的地。
这样子 dp[i][j] 在 i <= m 时等于 dp[i+j][j-1]；在 i > m 时等于 dp[i-j][j-1]（这里的 ±j 是在环的意义下进行加减）。

然后我们就可以优化这个 dp 了：注意它的转移总是 dp[][j-1] 的两个个区间进行平移得到 dp[][j]。
于是我们使用可持久化 treap，每次 dp 转移相当于先分裂出对应区间，再将区间合并。
有一个小 trick：可持久化 treap 中深度可能比较深，可以尝试将 merge 写成随机合并 + 定期重构（当然也不一定要加。。。这个看具体的人而定）。

@accepted code@

#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<iostream>
using namespace std;
typedef long long ll;
const int MAXN = 100000;
struct treap{
    struct node{
        int key, siz;
        node *ch[2];
    }pl[30*MAXN + 5], *ncnt, *NIL;
    typedef pair<node*, node*> Droot;
    treap() {
        NIL = &pl[0];
        NIL->ch[0] = NIL->ch[1] = NIL;
        NIL->key = NIL->siz = 0;
    }
    void trans(int *f, node *x, int k) {
        if( x == NIL ) return ;
        f[x->ch[0]->siz + k + 1] = x->key;
        trans(f, x->ch[0], k);
        trans(f, x->ch[1], x->ch[0]->siz + k + 1);
    }
    void pushup(node *x) {
        x->siz = x->ch[0]->siz + x->ch[1]->siz + 1;
    }
    node *build(int *f, int l, int r) {
        if( l > r ) return NIL;
        int mid = (l + r) >> 1;
        node *p = (++ncnt); p->key = f[mid];
        p->ch[0] = build(f, l, mid - 1);
        p->ch[1] = build(f, mid + 1, r);
        pushup(p);
        return p;
    }
    node *build(int *f, int n) {
        ncnt = &pl[0];
        return build(f, 1, n);
    }
    Droot split(node *x, int k) {
        if( x == NIL ) return make_pair(NIL, NIL);
        node *p = (++ncnt); (*p) = (*x);
        if( x->ch[0]->siz >= k ) {
            Droot q = split(x->ch[0], k);
            p->ch[0] = q.second; pushup(p);
            return make_pair(q.first, p);
        }
        else {
            Droot q = split(x->ch[1], k - x->ch[0]->siz - 1);
            p->ch[1] = q.first; pushup(p);
            return make_pair(p, q.second);
        }
    }//first k elements
    node *merge(node *x, node *y) {
        if( x == NIL ) return y;
        if( y == NIL ) return x;
        node *p = (++ncnt);
        if( rand() & 1 ) {
            (*p) = (*x), p->ch[1] = merge(x->ch[1], y);
            pushup(p);
        }
        else {
            (*p) = (*y), p->ch[0] = merge(x, y->ch[0]);
            pushup(p);
        }
        return p;
    }
}T;
treap::node *root;
int f[MAXN + 5];
int nxt[45][MAXN + 5];
int main() {
    int n, m, s; ll t;
    scanf("%d%d%d%lld", &n, &m, &s, &t);
    srand(20041112 ^ n ^ m ^ s);
    for(int i=1;i<=n;i++) f[i] = i;
    root = T.build(f, n);
    for(int i=1;i<=n;i++) {
        if( i % 300 == 0 )
            T.trans(f, root, 0), root = T.build(f, n);
        treap::node *p, *q;
        treap::node *tmp = T.split(root, i).second;
        if( tmp->siz >= m )
            p = T.split(tmp, m).first;
        else p = T.merge(tmp, T.split(root, m-tmp->siz).first);
        tmp = T.split(root, n - i).first;
        if( tmp->siz >= n-m )
            q = T.split(tmp, tmp->siz-(n-m)).second;
        else q = T.merge(T.split(root, n-((n-m)-tmp->siz)).second, tmp);
        root = T.merge(p, q);
    }
    T.trans(f, root, 0);
    while( t % n ) {
        if( s <= m ) s = (s - 1 + t) % n + 1;
        else s = ((s - 1 - t) % n + n) % n + 1;
        t--;
    }
    for(int i=1;i<=n;i++) nxt[0][i] = f[i];
    for(int j=1;j<45;j++)
        for(int i=1;i<=n;i++)
            nxt[j][i] = nxt[j-1][nxt[j-1][i]];
    int x = t/n;
    for(int i=44;i>=0;i--)
        if( (1LL<<i) & x ) s = nxt[i][s];
    printf("%d
", s);
}

@details@

定时重构。。。感觉非常骚。。。
当然这是基于 treap 本身内部结点个数是恒定的前提下。

因为有定时重构的缘故所以空间也不需要消耗特别大。