@一句话题解

发现我 4 月根本没写多少题解。

这实在是太颓了啊啊啊啊啊啊啊。

codeforces - 674D：给儿子维护优先队列，对儿子影响打 tag；给父亲直接暴力改（因为人只会有一个父亲，尽管可以改父亲）。真实值 = 维护的值 + 父亲的 tag，然后全局再维护优先队列。因为环大小 >= 3 所以不会出问题。

#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;

const int MAXN = 100000;
const ll INF = ll(1E15);

struct heap{
	priority_queue<ll>q1, q2;
	
	void maintain() {
		while( !q1.empty() && !q2.empty() && q1.top() == q2.top() )
			q1.pop(), q2.pop();
	}
	bool empty() {maintain(); return q1.empty();}
	ll top() {maintain(); return q1.top();}
	void pop(ll k) {q2.push(k); maintain();}
	void push(ll k) {q1.push(k); maintain();}
	
}h1[MAXN + 5], h2[MAXN + 5], h3, h4;

ll a[MAXN + 5], tg[MAXN + 5];

ll t[MAXN + 5]; int d[MAXN + 5], f[MAXN + 5], n, q;
ll func(int x) {return t[x] / (d[x] + 2);}
ll func2(int x) {return t[x] - t[x] / (d[x] + 2) * (d[x] + 1);}
void pop(int x) {
	if( !h1[x].empty() ) h3.pop(h1[x].top() - tg[x]);
	if( !h2[x].empty() ) h4.pop(h2[x].top() + tg[x]);
}
void push(int x) {
	if( !h1[x].empty() ) h3.push(h1[x].top() - tg[x]);
	if( !h2[x].empty() ) h4.push(h2[x].top() + tg[x]);
}
void pop(int x, ll k) {pop(x), h1[x].pop(-k), h2[x].pop(k), push(x);}
void push(int x, ll k) {pop(x), h1[x].push(-k), h2[x].push(k), push(x);}
void add(int x, ll k) {pop(f[x], a[x]), push(f[x], a[x] += k);}
void update(int x, int k) {
	ll p1 = func(x), p2 = func2(x);
	pop(x), d[x] += k, tg[x] = func(x);
	add(f[x], tg[x] - p1), add(x, func2(x) - p2);
	push(x);
}
void debug() {
	puts("debug : ");
	for(int i=1;i<=n;i++)
		printf("%lld ", a[i] + tg[f[i]]);
	puts("");
}
int main() {
	scanf("%d%d", &n, &q);
	for(int i=1;i<=n;i++) scanf("%lld", &t[i]);
	for(int i=1;i<=n;i++) scanf("%d", &f[i]), d[f[i]]++;
	for(int i=1;i<=n;i++) a[f[i]] += func(i), a[i] += func2(i), tg[i] = func(i);
	for(int i=1;i<=n;i++) push(f[i], a[i]);
	for(int i=1;i<=q;i++) {
		int type; scanf("%d", &type);
		if( type == 1 ) {
			int x, y; scanf("%d%d", &x, &y);
			add(f[x], -func(x)), update(f[x], -1), pop(f[x], a[x]);
			push(f[x] = y, a[x]), update(f[x], 1), add(f[x], func(x));
		} else if( type == 2 ) {
			int x; scanf("%d", &x);
			printf("%lld
", a[x] + tg[f[x]]);
		} else printf("%lld %lld
", -h3.top(), h4.top());
//		debug();
	}
}

atcoder - AGC032C：首先原图要有欧拉回路。如果存在点 v 度数 >= 6，则会出现形如 v->A->v->B->v->C->v 的欧拉回路，此时一定有解；否则考虑两个度数为 4 的点 p, q，如果有 p->A->q->B->q->C->p->D->p 或 p->A->p->B->q->C->q->D->p，则也存在解；如果找不到这样的点对，则一定无解。跑欧拉回路判区间相离/包含即可。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100000;

struct edge{
	int to; bool tag;
	edge *nxt, *rev;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
	edge *p = (++ecnt), *q = (++ecnt);
	p->to = v, p->nxt = adj[u], adj[u] = p;
	q->to = u, q->nxt = adj[v], adj[v] = q;
	p->rev = q, q->rev = p;
}

int arr[MAXN + 5], cnt;
void dfs(int x) {
	for(;adj[x];) {
		edge *p = adj[x]; adj[x] = adj[x]->nxt;
		if( p->tag ) continue;
		p->rev->tag = true, dfs(p->to);
	}
	arr[++cnt] = x;
}

int nxt[MAXN + 5];

int deg[MAXN + 5];

int main() {
	int N, M; scanf("%d%d", &N, &M);
	for(int i=1;i<=M;i++) {
		int a, b; scanf("%d%d", &a, &b);
		addedge(a, b), deg[a]++, deg[b]++;
	}
	
	for(int i=1;i<=N;i++)
		if( deg[i] & 1 ) {
			puts("No");
			return 0;
		}
	for(int i=1;i<=N;i++)
		if( deg[i] >= 6 ) {
			puts("Yes");
			return 0;
		}
		
	dfs(1);
//	for(int i=1;i<=cnt;i++) printf("%d ", arr[i]);
	int mx = 1, mn = cnt;
	for(int i=cnt;i>=1;i--) {
		if( deg[arr[i]] == 4 ) {
			if( nxt[arr[i]] ) mx = max(mx, i);
			else mn = min(mn, nxt[arr[i]] = i);
		}
	}
	
	if( mn < mx ) puts("Yes");
	else {
		int p = 1;
		for(int i=1;i<=cnt;i++)
			if( nxt[arr[i]] && nxt[arr[i]] != i ) {
				if( nxt[arr[i]] < p ) {
					puts("Yes");
					return 0;
				}
				else p = nxt[arr[i]];
			}
		puts("No");
	}
}

atcoder - AGC028C：一条边 min(Ax, By) 可以拆成两条 Ax, By。每个点的贡献有四种 Ax + Bx, Ax, Bx, 0。合法的情况要么全 Ax；要么全 Bx；要么至少包含一个 Ax + Bx。最后一个可以找前 n 小的 A, B，然后再讨论一下。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int MAXN = 100000;

bool tag[MAXN + 5]; pii p[2*MAXN + 5]; int N;
int main() {
	ll SA = 0, SB = 0; scanf("%d", &N);
	for(int i=1;i<=N;i++) {
		int A, B; scanf("%d%d", &A, &B);
		SA += A, SB += B;
		p[2*i-1] = make_pair(A, i);
		p[2*i] = make_pair(B, i);
	}
	sort(p + 1, p + 2*N + 1);
	
	ll ans = 0; bool flag = false;
	for(int i=1;i<=N;i++) {
		if( tag[p[i].second] ) flag = true;
		else tag[p[i].second] = true;
		ans += p[i].first;
	}
	if( !flag ) {
		if( p[N].second == p[N + 1].second )
			ans = min(ans - p[N - 1].first + p[N + 1].first, ans - p[N].first + p[N + 2].first);
		else ans = ans - p[N].first + p[N + 1].first;
	}
	
	printf("%lld
", min(ans, min(SA, SB)));
}

atcoder - ARC091F：对 sg 函数打表得到，当 A mod K = 0 时 sg(A, K) = A / K；否则 sg(A, K) = sg(A - ⌊A/K⌋ - 1, K)。证明不会，猜测归纳法可证。求的时候如果步长 ⌊A/K⌋ + 1 相同则一次性跳到底，然后就过了时间复杂度我也不会证，感觉可以按√10^9分类。

#include <cstdio>

int sg(int x, const int &K) {
	if( x % K == 0 ) return x / K;
	int p = x / K + 1, q = x % K;
	return sg(x - (q + p - 1) / p * p, K);
}

int main() {
	int N, ans = 0; scanf("%d", &N);
	
	for(int i=1;i<=N;i++) {
		int A, K; scanf("%d%d", &A, &K);
		ans ^= sg(A, K);
	}
	puts(ans ? "Takahashi" : "Aoki");
}
/*
sg[i] = (i % K == 0 ? i / K : sg[i - i/K - 1])
*/

atcoder - ARC095F：如果记 b[a[i]] = i，则有 fa[i] = max(fa[i - 1], b[i - 1])。因此如果有解则应满足非叶结点构成一条链。先特判链为空、链只含 1 个点。如果起点是叶子，则 a[1] = 1 满足字典序最小；因此起点是链某个端点所连叶结点。两个端点都求一遍即可。

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 100000;

struct edge{
	int to; edge *nxt;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
	edge *p = (++ecnt);
	p->to = v, p->nxt = adj[u], adj[u] = p;
	p = (++ecnt);
	p->to = u, p->nxt = adj[v], adj[v] = p;
}

int deg[MAXN + 5], tmp[MAXN + 5];
int ans[MAXN + 5], a[MAXN + 5], cnt;
void dfs(int x, int f) {
	if( !f ) a[++cnt] = 1;
	int p = cnt + 1;
	for(int i=1;i<=deg[x]-2;i++)
		cnt++, a[cnt] = cnt + 1;
	a[++cnt] = p;
	if( f && tmp[x] == 1 ) cnt++, a[cnt] = cnt;
	for(edge *p=adj[x];p;p=p->nxt)
		if( deg[p->to] != 1 && p->to != f ) dfs(p->to, x);
}
void update() {
	for(int i=1;i<=cnt;i++) {
		if( ans[i] < a[i] ) break;
		else if( ans[i] > a[i] ) {
			for(int j=1;j<=cnt;j++)
				ans[j] = a[j];
			break;
		}
	}
	cnt = 0;
}

int main() {
	int n; scanf("%d", &n);
	for(int i=1;i<n;i++) {
		int u, v; scanf("%d%d", &u, &v);
		addedge(u, v), deg[u]++, deg[v]++;
	}
	
	if( n == 2 ) {
		printf("%d %d
", 1, 2);
		return 0;
	}
	for(int i=1;i<=n;i++) tmp[i] = deg[i];
	for(int i=1;i<=n;i++)
		if( deg[i] == 1 ) tmp[adj[i]->to]--;
	for(int i=1;i<=n;i++)
		if( deg[i] != 1 && tmp[i] > 2 ) {
			puts("-1");
			return 0;
		}
	
	int s = 0, t = 0;
	for(int i=1;i<=n;i++)
		if( deg[i] != 1 && tmp[i] == 1 ) {
			if( !s ) s = i;
			else t = i;
		}
	if( t == 0 ) {
		printf("1");
		for(int i=3;i<n;i++)
			printf(" %d", i);
		printf(" %d %d
", 2, n);
	}
	else {
		for(int i=1;i<=n;i++) ans[i] = n - i + 1;
		dfs(s, 0), update(), dfs(t, 0), update();
		for(int i=1;i<=n;i++)
			printf("%d%c", ans[i], i == n ? '
' : ' ');
	}
}

atcoder - AGC026D：对于 h 进行类似笛卡尔树建树（不同的是 h 相同的放一层），树中每个结点对应原图的一个矩形。定义 dp[i][0/1] 表示矩形的底层是/不是红蓝相间，可以将矩形分为三类：有两个横着相邻同色；有两个竖着相邻同色；没有相邻同色。转移时分析性质讨论一下即可。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair

const int MAXN = 100;
const int MOD = int(1E9) + 7;

inline int add(int x, int y) {x += y; return x >= MOD ? x - MOD : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + MOD : x;}
inline int mul(int x, int y) {return 1LL * x * y % MOD;}

int pow_mod(int b, int p) {
	int ret = 1;
	for(int i=p;i;i>>=1,b=mul(b,b))
		if( i & 1 ) ret = mul(ret, b);
	return ret;
}

int h[MAXN + 5], N;
pii get(int l, int r, int lh) {
	int mn = h[l];
	for(int i=l;i<=r;i++)
		mn = min(mn, h[i]);
	
	int lst = l; pii ret = mp(1, 1);
	for(int i=l;i<=r;i++) {
		if( h[i] == mn ) {
			if( i > lst ) {
				pii tmp = get(lst, i - 1, mn);
				ret.fi = mul(ret.fi, tmp.fi);
				ret.se = mul(ret.se, add(mul(2, tmp.fi), tmp.se));
			}
			ret.se = mul(ret.se, 2);
			
			lst = i + 1;
		}
	}
	if( r >= lst ) {
		pii tmp = get(lst, r, mn);
		ret.fi = mul(ret.fi, tmp.fi);
		ret.se = mul(ret.se, add(mul(2, tmp.fi), tmp.se));
	}
	
	return mp(mul(ret.fi, pow_mod(2, mn - lh)), sub(ret.se, mul(2, ret.fi)));
}

int main() {
	scanf("%d", &N);
	for(int i=1;i<=N;i++) scanf("%d", &h[i]);
	
	pii k = get(1, N, 0);
	printf("%d
", add(k.fi, k.se));
}

atcoder - ARC060F：如果不是循环串输出 1 1；如果是单字母串输出 n 1；否则把第一个字母单独剖出来一定是合法方案。因此正着倒着分别 kmp 判前缀后缀是否为循环串即可。怎么判循环串相信都是基础内容了；是的，模数是唬你的。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 500000;

int f[MAXN + 5], g[MAXN + 5], lenw; char w[MAXN + 5];
bool checkf(int x) {return f[x] && (x % (x - f[x]) == 0);}
bool checkg(int x) {return g[x] && (x % (x - g[x]) == 0);}
int main() {
	scanf("%s", w), lenw = strlen(w);
	
	f[0] = -1, f[1] = 0;
	for(int i=2;i<=lenw;i++) {
		int j = f[i - 1];
		while( j != -1 && w[j] != w[i - 1] )
			j = f[j];
		f[i] = j + 1;
	}
	
	if( checkf(lenw) ) {
		int k = lenw / (lenw - f[lenw]);
		if( k == lenw ) printf("%d
1
", lenw);
		else {
			reverse(w, w + lenw), g[0] = -1, g[1] = 0;
			for(int i=2;i<=lenw;i++) {
				int j = g[i - 1];
				while( j != -1 && w[j] != w[i - 1] )
					j = g[j];
				g[i] = j + 1;
			}
			
			int ans = 0;
			for(int i=1;i<lenw;i++)
				ans += (!checkf(i) && !checkg(lenw - i));
			printf("2
%d
", ans);
		}
	} else printf("1
1
");
}

atcoder - AGC032D：操作其实就是花费 A 把某元素右移；花费 B 把某元素左移。注意到某个元素最多需要移动一次。对不移动的元素 dp，定义 dp[i] 表示上一个不动的元素是第 i 个元素。注意两个相邻不动元素 x, y 之间不能存在 z 使得 x < z < y。（我好像在之前出过一道A等于B情况的水题）

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;

const int MAXN = 5000;
const ll INF = (1LL << 60);

ll dp[MAXN + 5];

int p[MAXN + 5], N, A, B;
int main() {
	scanf("%d%d%d", &N, &A, &B);
	for(int i=1;i<=N;i++) scanf("%d", &p[i]);
	p[N + 1] = N + 1;
	
	for(int i=1;i<=N+1;i++) {
		dp[i] = INF; int nw = 0; ll del = 0;
		for(int j=i-1;j>=1;j--) {
			if( p[j] < p[i] ) {
				if( nw < p[j] )
					dp[i] = min(dp[i], dp[j] + del), nw = p[j];
				del += B;
			}
			else del += A;
		}
		if( !nw ) dp[i] = del;
	}
	
	printf("%lld
", dp[N + 1]);
}

loj - 2012：先利用 trie 针对后缀关系建树，根为空串。先学后缀一定更优，所以相当于自上而下标号使得父子之间标号差之和最小。结论是按照 dfs 的顺序标号最优（不会证，留坑）。根据这个结论，每次 dfs 的时候走子树大小最小的子树即可。

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 100000;
const int MAXM = 520000;

int ch[26][MAXM + 5], id[MAXM + 5], ncnt;
void insert(char *S, int x) {
	int lenS = strlen(S), nw = 0;
	for(int i=lenS-1;i>=0;i--) {
		if( !ch[S[i] - 'a'][nw] )
			ch[S[i] - 'a'][nw] = (++ncnt);
		nw = ch[S[i] - 'a'][nw];
	}
	id[nw] = x;
}

vector<int>G[MAXN + 5], sz[MAXN + 5];
void build(int x, int p) {
	if( id[x] ) {
//		printf("! %d %d
", p, id[x]);
		G[p].push_back(id[x]), p = id[x];
	}
	for(int i=0;i<26;i++)
		if( ch[i][x] ) build(ch[i][x], p);
}

int siz[MAXN + 5];
void dfs(int x) {
	siz[x] = 1;
	for(int i=0;i<G[x].size();i++) {
		int to = G[x][i];
		dfs(to), sz[x].push_back(siz[to]);
		siz[x] += siz[to];
	}
}

char s[MAXM + 5];
int main() {
	int n; scanf("%d", &n);
	for(int i=1;i<=n;i++)
		scanf("%s", s), insert(s, i);
	build(0, 0);
	
	dfs(0);
	
	long long ans = 0;
	for(int i=0;i<=n;i++) {
		sort(sz[i].begin(), sz[i].end());
		int tmp = 1;
		for(int j=0;j<sz[i].size();j++)
			ans += tmp, tmp += sz[i][j];
	}
	printf("%lld
", ans);
}

codeforces - 575A：用线段树处理矩阵的区间积然后 (O(8 imes nlog n)) 乱做。注意矩阵乘法不满足交换律。

#include <map>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
 
typedef long long ll;
typedef pair<int, int> pii;
 
const int MAXN = 50000;
 
int N, M, P; ll K;
inline int add(int x, int y) {x += y; return x >= P ? x - P : x;}
inline int mul(int x, int y) {return 1LL * x * y % P;}
 
struct matrix{
	int m00, m01, m10, m11; matrix() {m00 = m01 = m10 = m11 = 0;}
	matrix(int _a, int _b, int _c, int _d) : m00(_a), m01(_b), m10(_c), m11(_d) {}
	
	friend matrix operator * (const matrix &A, const matrix &B) {
		matrix C;
		C.m00 = add(mul(A.m00, B.m00), mul(A.m01, B.m10));
		C.m01 = add(mul(A.m00, B.m01), mul(A.m01, B.m11));
		C.m10 = add(mul(A.m10, B.m00), mul(A.m11, B.m10));
		C.m11 = add(mul(A.m10, B.m01), mul(A.m11, B.m11));
		return C;
	}
}A[MAXN + 5], S;
 
namespace segtree{
	#define lch (x << 1)
	#define rch (x << 1 | 1)
	
	int le[4*MAXN + 5], ri[4*MAXN + 5]; matrix B[4*MAXN + 5];
	void build(int x, int l, int r) {
		le[x] = l, ri[x] = r;
		if( l == r ) {
			B[x] = A[l];
			return ;
		}
		int m = (l + r) >> 1;
		build(lch, l, m), build(rch, m + 1, r);
		B[x] = B[rch] * B[lch];
	}
	matrix query(int x, int l, int r) {
		if( l > ri[x] || r < le[x] ) return matrix(1, 0, 0, 1);
		if( l <= le[x] && ri[x] <= r ) return B[x];
		return query(rch, l, r) * query(lch, l, r);
	}
}
 
matrix getM(int l, int r) {return segtree::query(1, l, r);}
matrix mpow(matrix B, ll p) {
	matrix R(1, 0, 0, 1);
	for(ll i=p;i;i>>=1,B=B*B)
		if( i & 1 ) R = R*B;
	return R;
}
matrix get(ll l, ll r) {
	if( l > r ) return matrix(1, 0, 0, 1);
	if( (l / N) == (r / N) )
		return getM(l % N, r % N);
	else return getM(0, r % N) * mpow(S, (r / N) - (l / N) - 1) * getM(l % N, N - 1);
}
 
int s[MAXN + 5];
void init() {
	for(int i=0;i<N;i++) A[i] = matrix(s[i + 1 == N ? 0 : i + 1], s[i], 1, 0);
	S = matrix(1, 0, 0, 1); for(int i=0;i<N;i++) S = A[i] * S;
	segtree::build(1, 0, N - 1);
}
 
map<ll, pii>mp;
int main() {
	scanf("%lld%d%d", &K, &P, &N);
	for(int i=0;i<N;i++) scanf("%d", &s[i]);
	init();
	
	scanf("%d", &M);
	for(int i=0;i<M;i++) {
		ll j; int v; scanf("%lld%d", &j, &v);
		if( j - 1 < K ) {
			if( !mp.count(j - 1) ) mp[j - 1] = make_pair(s[j % N], s[(j - 1) % N]);
			mp[j - 1].first = v;
		}
		if( j < K ) {
			if( !mp.count(j) ) mp[j] = make_pair(s[(j + 1) % N], s[j % N]);
			mp[j].second = v;
		}
	}
	
	ll nw = 0; matrix ans = matrix(1, 0, 0, 1);
	for(map<ll, pii>::iterator it=mp.begin();it!=mp.end();it++) {
		ll x = it->first; int p = it->second.first, q = it->second.second;
		ans = matrix(p, q, 1, 0) * get(nw, x - 1) * ans;
		nw = x + 1;
	}
	ans = get(nw, K - 1) * ans, printf("%d
", ans.m10);
}

codeforces - 568C：建 2-sat。字典序最小，首先与 s 能够匹配上的前缀最长，其次公共前缀之后的字符 > s 对应字符，最后取 2-sat 字典序最小解。时间复杂度 O(n^3)。

#include <cstdio>
#include <bitset>
#include <cstring>
#include <algorithm>
using namespace std;

bitset<405>bts[405];
int f[405], nxt[30], n, m, l, sz;
char ans[205], s[205], vc[30], t1[2], t2[2];
bool check(int p, int k) {
	int x; memset(f, -1, sizeof f);
	for(int i=0;i<p;i++) {
		x = ((i << 1) | (vc[s[i] - 'a'] == 'C'));
		if( f[x] == -1 ) {
			if( !bts[x][x^1] ) {
				f[x] = 1, f[x^1] = 0;
				for(int j=0;j<l;j++)
					if( bts[x][j] ) f[j] = 1, f[j^1] = 0;
			} else return false;
		} else if( f[x] == 0 ) return false;
		ans[i] = s[i];
	}
	
	x = ((p << 1) | (vc[k] == 'C'));
	if( f[x] == -1 ) {
		if( !bts[x][x^1] ) {
			f[x] = 1, f[x^1] = 0;
			for(int j=0;j<l;j++)
				if( bts[x][j] ) f[j] = 1, f[j^1] = 0;
		} else return false;
	} else if( f[x] == 0 ) return false;
	ans[p] = k + 'a';
	
	for(int i=p+1;i<n;i++) {
		x = ((i << 1) | (vc[0] == 'C'));
		if( f[x] == -1 ) {
			if( !bts[x][x^1] ) {
				f[x] = 1, f[x^1] = 0;
				for(int j=0;j<l;j++)
					if( bts[x][j] ) f[j] = 1, f[j^1] = 0;
				ans[i] = 'a';
			} else if( !bts[x^1][x] && nxt[0] != -1 ) {
				f[x] = 0, f[x^1] = 1;
				for(int j=0;j<l;j++)
					if( bts[x^1][j] ) f[j] = 1, f[j^1] = 0;
				ans[i] = nxt[0] + 'a';
			} else return false;
		} else if( f[x] == 1 ) ans[i] = 'a';
		else if( nxt[0] != -1 ) ans[i] = nxt[0] + 'a';
		else return false;
	}
	
	puts(ans); return true;
}
int main() {
	scanf("%s%d%d", vc, &n, &m);
	l = (n << 1), sz = strlen(vc);
	for(int i=0,p1,p2;i<m;i++) {
		scanf("%d%s%d%s", &p1, t1, &p2, t2);
		p1 = ((p1 - 1) << 1 | (t1[0] == 'C'));
		p2 = ((p2 - 1) << 1 | (t2[0] == 'C'));
		bts[p1][p2] = bts[p2^1][p1^1] = true;
	}
	scanf("%s", s);
	
	for(int i=0;i<sz;i++) {
		nxt[i] = -1;
		for(int j=i;j<sz;j++)
			if( vc[j] != vc[i] ) {
				nxt[i] = j;
				break;
			}
	}
	
	for(int k=0;k<l;k++)
		for(int i=0;i<l;i++)
			if( bts[i][k] ) bts[i] |= bts[k];
	
	memset(f, -1, sizeof f);
	for(int i=0;i<=n;i++) {
		if( i == n ) {
			puts(s);
			return 0;
		}
		else {
			bool flag = true;
			
			int x = ((i << 1) | (vc[s[i] - 'a'] == 'C'));
			if( f[x] == -1 ) {
				if( !bts[x][x^1] ) {
					f[x] = 1, f[x^1] = 0;
					for(int j=0;j<l;j++)
						if( bts[x][j] ) f[j] = 1, f[j^1] = 0;
					flag = true;
				} else flag = false;
			} else flag = (f[x] == 1);
			
			if( !flag ) {
				for(;i>=0;i--) {
					bool f[2] = {};
					for(int p=s[i]-'a'+1;p<sz;p++)
						if( !f[vc[p] == 'C'] ) {
							f[vc[p] == 'C'] = true;
							if( check(i, p) ) return 0;
						}
				}
				puts("-1"); return 0;
			}
		}
	}
}

codeforces - 704C：把子句建点，两个子句有相同的变量则连边（有两类边，变量正负相同；变量一正一负）。则得到的图每个点度数 <= 2，即只有三种情况：单点、链、环。分开讨论，链和环可以 dp。写得很丑，细节多。

#include <map>
#include <vector>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair

const int MAXN = 100000;
const int MOD = 1000000007;

inline int add(int x, int y) {x += y; return x >= MOD ? x - MOD : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + MOD : x;}
inline int mul(int x, int y) {return 1LL * x * y % MOD;}

int deg[MAXN + 5]; vector<pii>G[MAXN + 5];
void addedge(int u, int v, int c) {
	deg[u]++, deg[v]++;
	G[u].push_back(mp(v, c));
	G[v].push_back(mp(u, c));
	
//	printf("! %d %d %d
", u, v, c);
}

int ans[2];
void update(int a0, int a1) {
	int p0 = ans[0], p1 = ans[1];
	ans[0] = add(mul(a0, p0), mul(a1, p1));
	ans[1] = add(mul(a0, p1), mul(a1, p0));
}

int k[MAXN + 5], n, m;

int f[2][2][MAXN + 5]; bool vis[MAXN + 5];
void dfs1(int x, int lst) {
	vis[x] = true;
	
	for(int i=0;i<G[x].size();i++) {
		int to = G[x][i].fi;
		if( to == lst ) continue;
		
		if( G[x][i].se == 0 ) {
			for(int o=0;o<=1;o++) {
				f[o][0][to] = add(f[o][0][x], f[o][1][x]);
				f[o^1][1][to] = add(f[o^1][0][x], f[o][1][x]);
			}
		}
		else {
			for(int o=0;o<=1;o++) {
				f[o][0][to] = add(f[o^1][0][x], f[o][1][x]);
				f[o^1][1][to] = add(f[o][0][x], f[o][1][x]);
			}
		}
		dfs1(to, x);
		
		return ;
	}
	
	if( k[x] == 2 ) {
		for(int o=0;o<=1;o++)
			f[o][1][x] = add(f[o^1][0][x], mul(f[o][1][x], 2));
	}
	update(add(f[0][0][x], f[0][1][x]), add(f[1][0][x], f[1][1][x]));
}
int tmp[2], st; bool t;
void dfs2(int x, int lst) {
	vis[x] = t;
	
	pii to = G[x][0];
	if( to.fi == lst ) to = G[x][1];
	
	if( to.fi == st ) {
		if( (to.se ^ t) == 0 ) {
			tmp[0] = add(tmp[0], add(f[0][0][x], f[0][1][x]));
			tmp[1] = add(tmp[1], add(f[1][0][x], f[1][1][x]));
		}
		else {
			tmp[0] = add(tmp[0], add(f[1][0][x], f[0][1][x]));
			tmp[1] = add(tmp[1], add(f[0][0][x], f[1][1][x]));
		}
		
		return ;
	}
		
	for(int o1=0;o1<=1;o1++)
		for(int o2=0;o2<=1;o2++)
			f[o1][o2][to.fi] = 0;
		
	if( to.se == 0 ) {
		for(int o=0;o<=1;o++) {
			f[o][0][to.fi] = add(f[o][0][x], f[o][1][x]);
			f[o^1][1][to.fi] = add(f[o^1][0][x], f[o][1][x]);
		}
	}
	else {
		for(int o=0;o<=1;o++) {
			f[o][0][to.fi] = add(f[o^1][0][x], f[o][1][x]);
			f[o^1][1][to.fi] = add(f[o][0][x], f[o][1][x]);
		}
	}
	dfs2(to.fi, x);

	return ;
}

map<int, int>A;
int main() {
	scanf("%d%d", &n, &m);
	for(int i=1;i<=n;i++) {
		scanf("%d", &k[i]);
		for(int j=0,x;j<k[i];j++) {
			scanf("%d", &x);
			if( A.count(x) ) addedge(A[x], i, 0);
			else if( A.count(-x) ) addedge(A[-x], i, 1);
			else A[x] = i;
		}
	}
	
	ans[0] = 1, ans[1] = 0;
	for(int i=1;i<=m;i++)
		if( !A.count(i) && !A.count(-i) )
			ans[0] = mul(2, ans[0]);
	for(int i=1;i<=n;i++) {
		if( vis[i] ) continue;
		
		if( deg[i] == 0 )
			update(1, k[i] == 1 ? 1 : 3), vis[i] = true;
		else if( deg[i] == 1 ) {
			if( k[i] == 1 ) f[0][0][i] = 1;
			else f[0][0][i] = f[1][1][i] = 1;
			
			dfs1(i, -1);
		}
		else {
			if( G[i][0].fi == i ) {
				if( G[i][0].se == 0 ) update(1, 1);
				else update(0, 2);
				
				vis[i] = true;
			}
		}
	}
	for(int i=1;i<=n;i++) {
		if( !vis[i] ) {
			st = i, tmp[0] = tmp[1] = 0;
			f[0][0][i] = 1, t = 0, dfs2(i, -1), f[0][0][i] = 0;
			f[1][1][i] = 1, t = 1, dfs2(i, -1), f[1][1][i] = 0;
			update(tmp[0], tmp[1]);
		}
	}
	
	printf("%d
", ans[1]);
}

codeforces - 704B：每个中途点一定是一进一出，从前往后 dp 枚举每个点的进出状态。除去 s,e 已经连通的连通块必然是一进一出，因此状态存连通块个数即可。注意讨论一下 s,e 是否在前面出现；以及注意不要提前接成环。

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;

const int MAXN = 5000;
const ll INF = ll(1E18);

int n, s, e; bool fs, fe;
ll f[MAXN + 5], g[MAXN + 5], x[MAXN + 5];
ll a[MAXN + 5], b[MAXN + 5], c[MAXN + 5], d[MAXN + 5];

void read() {
	scanf("%d%d%d", &n, &s, &e);
	for(int i=1;i<=n;i++) scanf("%lld", &x[i]);
	for(int i=1;i<=n;i++) scanf("%lld", &a[i]);
	for(int i=1;i<=n;i++) scanf("%lld", &b[i]);
	for(int i=1;i<=n;i++) scanf("%lld", &c[i]);
	for(int i=1;i<=n;i++) scanf("%lld", &d[i]);
}

int main() {
	read();
	
	int cnt = 0;
	for(int i=1;i<=n;i++) {
		for(int j=0;j<=cnt;j++) g[j] = f[j], f[j] = INF;
		if( i == s ) {
			if( fe ) {
				f[cnt + 1] = INF;
				for(int j=0;j<=cnt;j++) {
					f[j] = min(f[j], g[j] + c[i] + x[i]);
					f[j + 1] = min(f[j + 1], g[j] + d[i] - x[i]);
				}
				cnt++;
			}
			else {
				for(int j=0;j<=cnt;j++) {
					if( j ) f[j - 1] = min(f[j - 1], g[j] + c[i] + x[i]);
					f[j] = min(f[j], g[j] + d[i] - x[i]);
				}
			}
			fs = true;
		}
		else if( i == e ) {
			if( fs ) {
				f[cnt + 1] = INF;
				for(int j=0;j<=cnt;j++) {
					f[j] = min(f[j], g[j] + a[i] + x[i]);
					f[j + 1] = min(f[j + 1], g[j] + b[i] - x[i]);
				}
				cnt++;
			}
			else {
				for(int j=0;j<=cnt;j++) {
					if( j ) f[j - 1] = min(f[j - 1], g[j] + a[i] + x[i]);
					f[j] = min(f[j], g[j] + b[i] - x[i]);
				}
			}
			fe = true;
		}
		else {
			f[cnt + 1] = INF;
			for(int j=1;j<=cnt;j++) {
				f[j - 1] = min(f[j - 1], g[j] + c[i] + a[i] + 2*x[i]);
				f[j] = min(f[j], min(g[j] + c[i] + b[i], g[j] + d[i] + a[i]));
				f[j + 1] = min(f[j + 1], g[j] + b[i] + d[i] - 2*x[i]);
			}
			
			if( fs && (!fe) ) {
				f[0] = min(f[0], g[0] + d[i] + a[i]);
				f[1] = min(f[1], g[0] + b[i] + d[i] - 2*x[i]);
			}
			if( (!fs) && fe ) {
				f[0] = min(f[0], g[0] + c[i] + b[i]);
				f[1] = min(f[1], g[0] + b[i] + d[i] - 2*x[i]);
			}
			if( i == 1 )
				f[1] = min(f[1], g[0] + b[i] + d[i] - 2*x[i]);
			
			cnt++;
		}
	}
	
	
	printf("%lld
", f[0]);
}
/*
i -> j :
xi - xj + ci + bj (j < i)
xj - xi + di + aj (j > i)
*/

codeforces - 576D：记矩阵 Ak[i][j] 表示从点 i 走 k 步后能否到 j。转移矩阵 B 只会有 O(m) 次变更，每次变更后尝试用倍增找一下最小值。加上虚边 n->n 方便处理。最后 bitset 大法好。

#include <bitset>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int n;
struct matrix{
	bitset<150>b[150]; matrix() {memset(b, 0, sizeof b);}
	
	friend matrix operator * (matrix A, matrix B) {
		matrix C;
		for(int i=0;i<n;i++)
			for(int k=0;k<n;k++)
				if( A.b[i][k] ) C.b[i] |= B.b[k];
		return C;
	}
}A, B, I;

matrix P[60];
bool check(int l, int r) {
	if( l == r ) return false;
	
	int k = r - l, nw = l, i; P[0] = B;
	for(i = 1; (1<<i) <= k; i++) P[i] = P[i - 1] * P[i - 1];
	for(i--; i >= 0; i--) {
		if( nw > r - (1 << i) ) continue;
		
		matrix T = A * P[i];
		if( !T.b[0][n - 1] )
			A = T, nw += (1 << i);
	}
	
	if( nw != r ) {
		printf("%d
", nw + 1);
		return true;
	} else return false;
}

struct edge{
	int a, b, d; edge() {}
	edge(int _a, int _b, int _d) : a(_a), b(_b), d(_d) {}
	friend bool operator < (const edge &a, const edge &b) {
		return a.d < b.d;
	}
}e[155];

int main() {
	int m; scanf("%d%d", &n, &m);
	for(int i=0;i<m;i++)
		scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].d), e[i].a--, e[i].b--;
	e[m].a = n - 1, e[m].b = n - 1, e[m].d = 0;
	sort(e, e + m + 1);
	
	for(int i=0;i<n;i++) I.b[i][i] = 1; A = I;
	
	int lst = 0;
	for(int i=0;i<=m;i++) {
		if( check(lst, e[i].d) ) return 0;
		lst = e[i].d, B.b[e[i].a][e[i].b] = 1;
	}
	if( check(lst, lst + n) ) return 0;
	
	puts("Impossible");
}

codeforces - 547D：对行列建点，每个点所在行列连边成二分图。然后建虚点连奇点跑欧拉路。行->列染红；列->行染蓝。

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 200000;

struct edge{
	int to, id; bool tag;
	edge *nxt, *rev;
}edges[4*N + 5], *adj[2*N + 5], *ecnt = edges;

void addedge(int u, int v, int i) {
	edge *p = (++ecnt), *q = (++ecnt);
	p->to = v, p->id = i, p->tag = false, p->nxt = adj[u], adj[u] = p;
	q->to = u, q->id = i, q->tag = false, q->nxt = adj[v], adj[v] = q;
	p->rev = q, q->rev = p;
}

bool ans[N + 5];
void dfs(int x) {
	for(;adj[x];) {
		edge *p = adj[x]; adj[x] = adj[x]->nxt;
		if( p->tag ) continue;
		p->tag = p->rev->tag = true;
		ans[p->id] = (p->to > N);
		dfs(p->to);
	}
}

int deg[2*N + 5];
int main() {
	int n; scanf("%d", &n);
	for(int i=1;i<=n;i++) {
		int x, y; scanf("%d%d", &x, &y);
		addedge(x, N + y, i), deg[x]++, deg[N + y]++;
	}
	for(int i=1;i<=2*N;i++)
		if( deg[i] & 1 ) addedge(0, i, 0);
	
	for(int i=0;i<=2*N;i++) dfs(i);
	for(int i=1;i<=n;i++)
		putchar(ans[i] ? 'b' : 'r');
}

codeforces - 582D：根据某库默尔定理，组合数 C(N, M) 含 p 的因子数量等于 M + (N - M) 在 p 进制下的进位次数。那么只需要求 x + y <= A 且 x + y 在 p 进制下进位 >= α 次的数量即可。直接 (O(log^2 A)) 数位 dp 即可（虽然这么说但还是写bug写到自闭）。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MOD = int(1E9) + 7;

inline int add(int x, int y) {x += y; return x >= MOD ? x - MOD : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + MOD : x;}
inline int mul(int x, int y) {return 1LL * x * y % MOD;}

int fun(int l, int r) {
	if( l > r ) return 0;
	else return 1LL*(l + r)*(r - l + 1)/2%MOD;
}

int f[2][3500][3500], g[2][3500][3500], b[3500], p, a, n;
void solve() {
	f[0][0][0] = 1;
	for(int i=1;i<=n;i++) {
		for(int j=0;j<i;j++) {
			f[0][i][j] = add(f[0][i][j], mul(f[0][i - 1][j], fun(1, p)));
			f[0][i][j] = add(f[0][i][j], mul(f[1][i - 1][j], fun(1, p - 1)));
			f[1][i][j + 1] = add(f[1][i][j + 1], mul(f[0][i - 1][j], fun(1, p - 1)));
			f[1][i][j + 1] = add(f[1][i][j + 1], mul(f[1][i - 1][j], fun(1, p)));
		}
	}
	for(int i=0;i<=n;i++)
		for(int j=i-1;j>=0;j--) {
			f[0][i][j] = add(f[0][i][j], f[0][i][j + 1]);
			f[1][i][j] = add(f[1][i][j], f[1][i][j + 1]);
		}
	
	g[0][n + 1][0] = 1; int ans = 0;
	for(int i=n;i>=1;i--) {
		for(int j=0;j<=n-i;j++) {
			if( a - j <= i - 1 ) {
				ans = add(ans, mul(mul(g[0][i + 1][j], f[0][i - 1][max(a - j, 0)]), fun(1, b[i])));
				ans = add(ans, mul(mul(g[0][i + 1][j], f[1][i - 1][max(a - j, 0)]), fun(1, b[i] - 1)));
			}
			if( a - j <= i - 1 ) {
				ans = add(ans, mul(mul(g[1][i + 1][j], f[0][i - 1][max(a - j, 0)]), fun(p - b[i], p - 1)));
				ans = add(ans, mul(mul(g[1][i + 1][j], f[1][i - 1][max(a - j, 0)]), fun(p - b[i] + 1, p)));
			}
			
			g[0][i][j] = add(g[0][i][j], mul(g[0][i + 1][j], b[i] + 1));
			g[0][i][j] = add(g[0][i][j], mul(g[1][i + 1][j], p - b[i] - 1));
			g[1][i][j + 1] = add(g[1][i][j + 1], mul(g[0][i + 1][j], b[i]));
			g[1][i][j + 1] = add(g[1][i][j + 1], mul(g[1][i + 1][j], p - b[i]));
		}
	}
	printf("%d
", ans);
}

int A[1005], len;
int rem() {
	int r = 0;
	for(int i=len;i>=1;i--) {
		int t = (10LL*r + A[i]) / p;
		r = (10LL*r + A[i]) % p;
		A[i] = t;
	}
	while( len > 1 && A[len] == 0 ) len--;
	return r;
}
char S[1005];
int main() {
	scanf("%d%d%s", &p, &a, S), len = strlen(S);
	for(int i=0;i<len;i++)
		A[len - i] = S[i] - '0';
	
	while( len != 1 || A[1] != 0 )
		b[++n] = rem();
	
	b[1]++;
	for(int i=1;i<=n;i++)
		b[i + 1] += b[i] / p, b[i] %= p;
	if( b[n + 1] ) n++;
	
	solve();
}

codeforces - 521D：先覆盖后加后乘。每个元素最多覆盖一次（且是最大的覆盖），因此可以把覆盖变为加。同一个元素加总是先加大再加小，把每次加操作按从大到小的顺序对乘积的贡献改写为乘操作，发现更大加操作改写出来的乘操作也更大。所有操作都可变为乘操作，直接贪心（比较分数会爆 long long 所以用 long double）。

#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
#define fi first
#define se second

const int MAXN = 100000;

struct node{
	ll a, b; int i; node() {}
	node(ll _a, ll _b, int _i) : a(_a), b(_b), i(_i) {}
	friend bool operator < (const node &a, const node &b) {
		return (long double)a.a * b.b < (long double)b.a * a.b;
	}
};

vector<int>ans;
vector<node>v;
vector<pii>c[MAXN + 5];
pii d[MAXN + 5];

int a[MAXN + 5], t[MAXN + 5];
bool cmp(int x, int y) {return t[x] < t[y];}
int main() {
	int k, n, m; scanf("%d%d%d", &k, &n, &m);
	for(int i=1;i<=k;i++) scanf("%d", &a[i]), d[i] = mp(a[i], 0);
	for(int i=1;i<=n;i++) {
		int x, b; scanf("%d%d%d", &t[i], &x, &b);
		if( t[i] == 1 ) {
			if( b > d[x].fi )
				d[x] = mp(b, i);
		} else if( t[i] == 2 ) {
			c[x].push_back(mp(b, i));
		} else v.push_back(node(b, 1, i));
	}
	
	for(int i=1;i<=k;i++) {
		if( d[i].fi != a[i] )
			c[i].push_back(mp(d[i].fi - a[i], d[i].se));
		sort(c[i].begin(), c[i].end());
		
		ll s = a[i];
		for(int j=c[i].size()-1;j>=0;j--) {
			v.push_back(node(s + c[i][j].fi, s, c[i][j].se));
			s += c[i][j].fi;
		}
	}
	
	sort(v.begin(), v.end());
	for(int i=v.size()-1;v.size()-i<=m&&i>=0;i--)
		ans.push_back(v[i].i);
	
	sort(ans.begin(), ans.end(), cmp);
	printf("%d
", ans.size());
	for(int i=0;i<ans.size();i++)
		printf("%d ", ans[i]);
}

atcoder - AGC044B：每个点的距离上界为 O(N)，因此总距离上界 O(N^3)。每次修改的时候从当前点 bfs 找到那些距离严格减小的点更新。这样每次总距离严格减小，而它非负，故时间复杂度为 O(N^3)。（为什么我做不起这种sb题啊啊啊）

#include <queue>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair

const int MAXN = 500;
const int MAXM = MAXN*MAXN;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};

bool a[MAXN + 5][MAXN + 5];
int d[MAXN + 5][MAXN + 5], N;

void update(int x, int y) {
	queue<pii>que; que.push(mp(x, y));
	while( !que.empty() ) {
		pii f = que.front(); que.pop();
		for(int i=0;i<4;i++) {
			pii g = mp(f.fi + dx[i], f.se + dy[i]);
			if( d[f.fi][f.se] + a[f.fi][f.se] < d[g.fi][g.se] )
				d[g.fi][g.se] = d[f.fi][f.se] + a[f.fi][f.se], que.push(g);
		}
	}
}

int P[MAXM + 5], M;
int main() {
	scanf("%d", &N), M = N*N;
	for(int i=1;i<=M;i++)
		scanf("%d", &P[i]);
	for(int i=1;i<=N;i++)
		for(int j=1;j<=N;j++)
			d[i][j] = min(min(i - 1, j - 1), min(N - i, N - j)), a[i][j] = 1;
	
	int ans = 0;
	for(int i=1;i<=M;i++) {
		int x = (P[i] - 1) / N + 1, y = (P[i] - 1) % N + 1;
		ans += d[x][y], a[x][y] = 0, update(x, y);
	}
	printf("%d
", ans);
}

loj - 2018：操作 2,3,4,5 只更改 O(1) 条边。可以根据插入时间为优先级建笛卡尔树，操作 1 加入的点会选择它前驱和后继中插入时间靠后的那个（如果被旋转到根则把优先级调至当前最低），于是 lct 乱做（当然这种题写lct其实是脑子不够的做法，直接set+线段树就够了）。

#include<map>
#include<cstdio>
#include<cstdlib>
using namespace std;
const int MAXN = 100000;
struct link_cut_tree{
	struct node{
		int siz;
		node *ch[2], *fa;
		bool dir() {return fa->ch[1] == this;}
	}pl[MAXN + 5], *ncnt, *NIL;
	void pushup(node *x) {
		x->siz = x->ch[0]->siz + x->ch[1]->siz + 1;
	}
	link_cut_tree() {
		ncnt = NIL = &pl[0];
		NIL->ch[0] = NIL->ch[1] = NIL->fa = NIL;
		NIL->siz = 0;
	}
	node *newnode() {
		node *p = (++ncnt);
		p->ch[0] = p->ch[1] = p->fa = NIL;
		p->siz = 1;
		return p;
	}
	bool is_root(node *x) {
		return x->fa->ch[0] != x && x->fa->ch[1] != x;
	}
	void set_child(node *x, node *y, int d) {
		if( x != NIL ) x->ch[d] = y;
		if( y != NIL ) y->fa = x;
	}
	void rotate(node *x) {
		node *y = x->fa; int d = x->dir();
		if( is_root(y) ) x->fa = y->fa;
		else set_child(y->fa, x, y->dir());
		set_child(y, x->ch[!d], d);
		set_child(x, y, !d);
		pushup(y);
	}
	void splay(node *x) {
		while( !is_root(x) ) {
			node *y = x->fa;
			if( is_root(y) )
				rotate(x);
			else {
				if( y->dir() == x->dir() )
					rotate(y);
				else rotate(x);
				rotate(x);
			}
		}
		pushup(x);
	}
	void access(node *x) {
		node *y = NIL;
		while( x != NIL ) {
			splay(x);
			x->ch[1] = y;
			pushup(x);
			y = x, x = x->fa;
		}
	}
	int query(node *x) {
		access(x), splay(x);
		return x->siz;
	}
}T;
link_cut_tree::node *nd[MAXN + 5];
int fa[MAXN + 5], ch[2][MAXN + 5];
void link(int a, int b, int type) {
	if( a ) ch[type][a] = b;
	if( b ) fa[b] = a, T.splay(nd[b]), nd[b]->fa = nd[a];
}
int pri[MAXN + 5], cnt;
map<int, int>mp;
map<int, int>::iterator it1, it2;
int root, m;
int main() {
	scanf("%d", &m), nd[0] = T.NIL;
	for(int i=1;i<=m;i++) {
//		T.debug();
		int op; scanf("%d", &op);
		if( op == 1 ) {
			int c; scanf("%d", &c);
			mp[c] = (++cnt);
			nd[cnt] = T.newnode(), pri[cnt] = i;
			it1 = mp.find(c), it2 = it1, it2++;
			if( it1 == mp.begin() ) {
				if( it2 == mp.end() ) root = i;
				else link(it2->second, cnt, 0);
			}
			else {
				it1--;
				if( it2 == mp.end() )
					link(it1->second, cnt, 1);
				else {
					if( pri[it1->second] > pri[it2->second] )
						link(it1->second, cnt, 1);
					else link(it2->second, cnt, 0);
				}
			}
			printf("%d
", T.query(nd[cnt]));
		}
		else if( op == 2 || op == 4 ) {
			int p = mp.begin()->second;
			printf("%d
", T.query(nd[p]));
			if( op == 2 && p == root ) continue;
			link(fa[p], ch[1][p], 0);
			if( fa[p] ) T.access(nd[fa[p]]);
			if( op == 2 ) {
				nd[p]->fa = T.NIL, fa[p] = 0;
				link(p, root, 1);
				root = p, pri[p] = -i;
			}
			else {
				if( root == p ) root = ch[1][p];
				mp.erase(mp.begin()->first);
				*nd[p] = *T.NIL;
			}
		}
		else {
			int p = mp.rbegin()->second;
			printf("%d
", T.query(nd[p]));
			if( op == 3 && p == root ) continue;
			link(fa[p], ch[0][p], 1);
			if( fa[p] ) T.access(nd[fa[p]]);
			if( op == 3 ) {
				nd[p]->fa = T.NIL, fa[p] = 0;
				link(p, root, 0);
				root = p, pri[p] = -i;
			}
			else {
				if( root == p ) root = ch[0][p];
				mp.erase(mp.rbegin()->first);
				*nd[p] = *T.NIL;
			}
		}
	}
}

loj - 2019：离线。考虑 i < j 且 ki < kj 的情况（另一种同理），则 kj 是 [i, j] 中的最大值。找到 j 左边第一个 kp > kj，则 (p, j) 中的 i 都可以贡献 p1/p2。注意到满足区间两端分别为最大值/次大值的区间只有 O(n) 个，所以我们可以让 (p, j) 强制贡献 p2，最后给 O(n) 个区间贡献 p1-p2（算错值域没开longlong白给50分）。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

typedef long long ll;

const int MAXN = 200000;

namespace segtree{
	#define lch (x << 1)
	#define rch (x << 1 | 1)
	
	int le[4*MAXN + 5], ri[4*MAXN + 5];
	ll tg[4*MAXN + 5], s[4*MAXN + 5];
	void maintain(int x, ll k) {tg[x] += k, s[x] += k*(ri[x] - le[x] + 1);}
	void pushdown(int x) {
		if( tg[x] ) {
			maintain(lch, tg[x]), maintain(rch, tg[x]);
			tg[x] = 0;
		}
	}
	void pushup(int x) {s[x] = s[lch] + s[rch];}
	void build(int x, int l, int r) {
		tg[x] = s[x] = 0, le[x] = l, ri[x] = r;
		if( l == r ) return ;
		int m = (l + r) >> 1;
		build(lch, l, m), build(rch, m + 1, r);
	}
	void update(int x, int l, int r, ll k) {
		if( l > ri[x] || r < le[x] ) return ;
		if( l <= le[x] && ri[x] <= r ) {
			maintain(x, k);
			return ;
		}
		pushdown(x);
		update(lch, l, r, k), update(rch, l, r, k);
		pushup(x);
	}
	ll sum(int x, int l, int r) {
		if( l > ri[x] || r < le[x] ) return 0;
		if( l <= le[x] && ri[x] <= r ) return s[x];
		pushdown(x); return sum(lch, l, r) + sum(rch, l, r);
	}
}

struct query{
	int l, r, i; query() {}
	query(int _l, int _r, int _i) : l(_l), r(_r), i(_i) {}
};
vector<query>ql[MAXN + 5], qr[MAXN + 5];
int k[MAXN + 5], le[MAXN + 5], ri[MAXN + 5];
ll ans[MAXN + 5];
int main() {
	int n, m, p1, p2; scanf("%d%d%d%d", &n, &m, &p1, &p2);
	for(int i=1;i<=n;i++) scanf("%d", &k[i]);
	for(int i=1;i<=m;i++) {
		int a, b; scanf("%d%d", &a, &b);
		query q = query(a, b, i);
		ql[a].push_back(q), qr[b].push_back(q);
	}
	
	k[0] = n + 1;
	for(int i=1;i<=n;i++) {
		le[i] = i - 1;
		while( k[le[i]] < k[i] )
			le[i] = le[le[i]];
	}
	segtree::build(1, 1, n);
	for(int i=1;i<=n;i++) {
		if( le[i] + 1 < i ) segtree::update(1, le[i] + 1, i - 1, p2);
		if( le[i] != 0 ) segtree::update(1, le[i], le[i], p1 - p2);
		for(int j=0;j<qr[i].size();j++) {
			query q = qr[i][j];
			ans[q.i] += segtree::sum(1, q.l, q.r);
		}
	}
	
	k[n + 1] = n + 1;
	for(int i=n;i>=1;i--) {
		ri[i] = i + 1;
		while( k[ri[i]] < k[i] )
			ri[i] = ri[ri[i]];
	}
	segtree::build(1, 1, n);
	for(int i=n;i>=1;i--) {
		if( ri[i] - 1 > i ) segtree::update(1, i + 1, ri[i] - 1, p2);
		if( ri[i] != n + 1 ) segtree::update(1, ri[i], ri[i], p1 - p2);
		for(int j=0;j<ql[i].size();j++) {
			query q = ql[i][j];
			ans[q.i] += segtree::sum(1, q.l, q.r);
		}
	}
	
	for(int i=1;i<=m;i++) printf("%lld
", ans[i]);
}

loj - 2020：把代价 (sum(x_i - y_i + c)^2) 拆开，形成一个关于 c 的二次函数 - (sum x_iy_i)。前一个对称轴乱算，后一个可以化卷积 ntt 做。

#include <cmath>
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 200000;
const int MOD = 998244353;

inline int add(int x, int y) {x += y; return x >= MOD ? x - MOD : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + MOD : x;}
inline int mul(int x, int y) {return 1LL * x * y % MOD;}

int pow_mod(int b, int p) {
	int ret = 1;
	for(int i=p;i;i>>=1,b=mul(b,b))
		if( i & 1 ) ret = mul(ret, b);
	return ret;
}
int w[20], iw[20], iv[1<<20];
void init() {
	for(int i=0;i<20;i++) {
		w[i] = pow_mod(3, (MOD - 1) / (1 << i));
		iw[i] = pow_mod(w[i], MOD - 2);
		iv[1<<i] = pow_mod(1 << i, MOD - 2);
	}
}
void ntt(int *A, int n, int type) {
	for(int i=0,j=0;i<n;i++) {
		if( i < j ) swap(A[i], A[j]);
		for(int k=(n>>1);(j^=k)<k;k>>=1);
	}
	for(int i=1,s=2,t=1;s<=n;i++,s<<=1,t<<=1) {
		int u = (type == 1 ? w[i] : iw[i]);
		for(int j=0;j<n;j+=s)
			for(int k=0,p=1;k<t;k++,p=mul(p,u)) {
				int x = A[j + k], y = mul(A[j + k + t], p);
				A[j + k] = add(x, y), A[j + k + t] = sub(x, y);
			}
	}
	if( type == -1 ) {
		for(int i=0;i<n;i++)
			A[i] = mul(A[i], iv[n]);
	}
}
int length(int n) {
	int len; for(len = 1; len < n; len <<= 1);
	return len;
}

int A, B, n, m;
int func(int x) {return n*x*x - 2*B*x;}

int x[MAXN + 5], y[MAXN + 5];
int main() {
	init(); scanf("%d%d", &n, &m);
	for(int i=0;i<n;i++) scanf("%d", &x[i]), A += x[i]*x[i], B += x[i];
	for(int i=0;i<n;i++) scanf("%d", &y[i]), A += y[i]*y[i], B -= y[i];
	reverse(y, y + n);
	
	int len = length(2*n - 1);
	ntt(x, len, 1), ntt(y, len, 1);
	for(int i=0;i<len;i++) x[i] = mul(x[i], y[i]);
	ntt(x, len, -1);
	
	int mx = x[n - 1];
	for(int i=0;i<n-1;i++) mx = max(mx, x[i] + x[n + i]);
	printf("%d
", A - 2*mx + min(func(floor(1.0 * B / n)), func(ceil(1.0 * B / n))));
}

loj - 6722：关键在于从前往后构造而非从后往前构造。怎么构造手玩一下就出来了。打一下表发现值域连续且单调，所以二分。本来还有个 (frac{N^2}{N + K} sim pi) 的优化来着，不过 loj 上好像不需要也能够 AC。所以当时比赛我是脑子里哪个部位缺根筋没想到啊。

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;

const int N = int(2E6);

int a[N + 5];
int check(int n, ll m) {
	for(int i=1;i<n;i++) {
		if( m % (i + 1) == 0 )
			a[i] = 0, m = m / (i + 1) * i;
		else {
			int r = m % (i + 1) - 1;
			a[i] = i - r, m = m / (i + 1) * i + r;
		}
		
		if( m == 0 ) return 1;
	}
	
	a[n] = n;
	if( m == 1 ) return 0;
	else return -1;
}

int main() {
	ll k; scanf("%lld", &k);
	
	int l = 1, r = N;
	while( l <= r ) {
		int mid = (l + r) >> 1, p = check(mid, mid + k);
		if( p == 0 ) {
			printf("%d
", mid);
			for(int i=1;i<=mid;i++)
				printf("%d%c", a[i], i == mid ? '
' : ' ');
			return 0;
		}
		else if( p == 1 ) r = mid - 1;
		else l = mid + 1;
	}
}

bzoj - 2661：最大权匹配，打个表发现是二分图。上最小费用最大流。

#include <queue>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair

const int MAXN = 1000;

namespace FlowGraph{
	const int MAXV = 1000, MAXE = 5000, INF = (1 << 30);
	
	struct edge{
		int to, cap, flow, cost;
		edge *nxt, *rev;
	}edges[MAXE + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt = edges;
	void addedge(int u, int v, int c, int w) {
		edge *p = (++ecnt), *q = (++ecnt);
		p->to = v, p->nxt = adj[u], adj[u] = p;
		p->cap = c, p->flow = 0, p->cost = w;
		q->to = u, q->nxt = adj[v], adj[v] = q;
		q->cap = 0, q->flow = 0, q->cost = -w;
		p->rev = q, q->rev = p;
		
//		printf("! %d %d %d %d
", u, v, c, w);
	}
	
	int d[MAXV + 5], h[MAXV + 5], s, t;
	bool relabel() {
		for(int i=0;i<=t;i++)
			h[i] += d[i], d[i] = INF, cur[i] = adj[i];
		
		priority_queue<pii, vector<pii>, greater<pii> >que;
		que.push(mp(d[s] = 0, s));
		while( !que.empty() ) {
			int x = que.top().se, k = que.top().fi; que.pop();
			if( k != d[x] ) continue;
			for(edge *p=adj[x];p;p=p->nxt) {
				int c = p->cost + h[x] - h[p->to];
				if( d[p->to] > k + c && p->cap > p->flow )
					que.push(mp(d[p->to] = k + c, p->to));
			}
		}
		
		return d[t] != INF;
	}
	bool vis[MAXV + 5];
	int aug(int x, int tot) {
		if( x == t ) return tot;
		int sum = 0; vis[x] = true;
		for(edge *&p=cur[x];p;p=p->nxt) {
			int c = h[x] - h[p->to] + p->cost;
			if( d[x] + c == d[p->to] && p->cap > p->flow && !vis[p->to] ) {
				int del = aug(p->to, min(p->cap - p->flow, tot - sum));
				sum += del, p->flow += del, p->rev->flow -= del;
				if( sum == tot ) break;
			}
		}
		vis[x] = false; return sum;
	}
	
	pii min_cost_max_flow(int _s, int _t) {
		int flow = 0, cost = 0; s = _s, t = _t;
		while( relabel() ) {
			int del = aug(s, INF);
			flow += del, cost += del*(d[t] + h[t]);
		}
		return mp(flow, cost);
	}
}

struct edge{
	int to; edge *nxt;
}edges[MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
	edge *p = (++ecnt);
	p->to = v, p->nxt = adj[u], adj[u] = p;
	p = (++ecnt);
	p->to = u, p->nxt = adj[v], adj[v] = p;
}

int clr[MAXN + 5];
void dfs(int x, int c) {
	clr[x] = c;
	for(edge *p=adj[x];p;p=p->nxt)
		if( clr[p->to] == -1 ) dfs(p->to, !c);
}

bool is_square(int x) {
	int y = int(sqrt(x));
	return y * y == x;
}
int gcd(int x, int y) {
	return y == 0 ? x : gcd(y, x % y);
}
void try_add(int i, int j) {
	if( is_square(i*i - j*j) && gcd(j, i*i - j*j) == 1 )
		addedge(i, j);
}
int main() {
	int a, b; scanf("%d%d", &a, &b);
	for(int i=a;i<=b;i++)
		for(int j=a;j<i;j++)
			try_add(i, j);
	for(int i=a;i<=b;i++) clr[i] = -1;
	for(int i=a;i<=b;i++)
		if( clr[i] == -1 ) dfs(i, 0);

	int s = b - a + 1, t = b - a + 2;
	for(int i=a;i<=b;i++)
		if( clr[i] ) {
			for(edge *p=adj[i];p;p=p->nxt)
				FlowGraph::addedge(i - a, p->to - a, 1, 0);
			FlowGraph::addedge(s, i - a, 1, -i);
		}
		else FlowGraph::addedge(i - a, t, 1, -i);
	
	pii ans = FlowGraph::min_cost_max_flow(s, t);
	printf("%d %d
", ans.fi, -ans.se);
}

bzoj - 1937：树边减，非树边加。把改变量当作变量，根据破圈法可列出线性规划，发现是个最小顶标和，直接上 KM（为此我还研究了一晚上的KM算法的O(N^3)怎么写）。

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 50, MAXM = 800, INF = (1 << 30);

int A[MAXN + 5][MAXM + 5], nx, ny;
int wx[MAXN + 5], wy[MAXM + 5], matx[MAXN + 5], maty[MAXM + 5];
bool vx[MAXN + 5], vy[MAXM + 5]; int pre[MAXM + 5], slk[MAXM + 5];
int KM() {
	for(int i=1;i<=nx;i++) {
		wx[i] = 0;
		for(int j=1;j<=ny;j++)
			wx[i] = max(wx[i], A[i][j]);
	}
	for(int i=1;i<=ny;i++) wy[i] = 0;
	
	for(int i=1;i<=nx;i++) {
		for(int j=1;j<=nx;j++) vx[j] = false;
		for(int j=1;j<=ny;j++) vy[j] = false, pre[j] = 0, slk[j] = INF;
		
		int p = i; vx[p] = true;
		while( true ) {
			int del = INF, q;
			for(int j=1;j<=ny;j++) {
				if( vy[j] ) continue;
				int t = wx[p] + wy[j] - A[p][j];
				if( t < slk[j] ) slk[j] = t, pre[j] = p;
				if( slk[j] < del ) del = slk[j], q = j;
			}
			
			for(int j=1;j<=nx;j++)
				if( vx[j] ) wx[j] -= del;
			for(int j=1;j<=ny;j++) {
				if( vy[j] ) wy[j] += del;
				else slk[j] -= del;
			}
			
			if( !maty[q] ) {
				while( q ) {
					p = pre[q];
					int tmp = matx[p];
					matx[p] = q, maty[q] = p;
					q = tmp;
				}
				break;
			} else p = maty[q], vx[p] = vy[q] = true;
		}
	}
	
	int ans = 0;
	for(int i=1;i<=nx;i++) ans += wx[i];
	for(int i=1;i<=ny;i++) ans += wy[i];
	return ans;
}


int G[MAXN + 5][MAXN + 5], H[MAXN + 5][MAXN + 5], N, M;
bool dfs(int s, int f, int t, int x, int w) {
	if( s == t ) return true;
	for(int i=1;i<=N;i++)
		if( H[s][i] && i != f && dfs(i, s, t, x, w) ) {
//			printf("! %d %d %d
", H[s][i], x, G[s][i] - w);
			A[H[s][i]][x] = max(A[H[s][i]][x], G[s][i] - w);
			return true;
		}
	return false;
}

int main() {
	scanf("%d%d", &N, &M);
	for(int i=1,u,v,w;i<=M;i++)
		scanf("%d%d%d", &u, &v, &w), G[u][v] = G[v][u] = w;
	for(int i=1,a,b;i<N;i++)
		scanf("%d%d", &a, &b), H[a][b] = H[b][a] = i;
	
	int cnt = 0;
	for(int i=1;i<=N;i++)
		for(int j=i+1;j<=N;j++)
			if( G[i][j] && !H[i][j] )
				dfs(i, -1, j, ++cnt, G[i][j]);
	
	nx = N - 1, ny = max(nx, M - N + 1); //X部大小 <= Y部大小
	printf("%d
", KM());
}