@codeforces - 1056G@ Take Metro

目录

• @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\n", s);
}

@details@

定时重构。。。感觉非常骚。。。

当然这是基于 treap 本身内部结点个数是恒定的前提下。

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