省选貌似已经定在了 5 月 31 日，WC 貌似已经流水。感觉少经历了一次WC有点可惜。
不过现在来看 THUWC2020 是真的逃过一劫。还好没有真的在 2020 年举办。
加油吧。
codeforces - 528C：（本题的难点在于理解题意）要求定向后每个点出度和入度都为偶数，只需要满足（1）定向前每个点度数为偶数（2）整张图有偶数条边。前一个条件直接把奇点两两相连，后一个条件随便找个点连个自环。然后求出 dfs 树从下往上调整。注意处理自环重边。
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 100000;
const int MAXM = 300000;
struct edge{
int to; edge *nxt, *rev;
}edges[2*MAXM + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
if( u != 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;
}
else {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
}
int dfn[MAXM + 5], dcnt;
vector<pair<int, int> >ans;
int dfs(int x, edge *f) {
int cnt = 0; dfn[x] = (++dcnt);
for(edge *p=adj[x];p;p=p->nxt) {
if( p == f ) continue;
if( !dfn[p->to] ) {
if( dfs(p->to, p->rev))
ans.push_back(make_pair(x, p->to));
else ans.push_back(make_pair(p->to, x)), cnt ^= 1;
}
else if( dfn[p->to] <= dfn[x] )
ans.push_back(make_pair(p->to, x)), cnt ^= 1;
}
return cnt;
}
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);
deg[a]++, deg[b]++, addedge(a, b);
}
int lst = 0;
for(int i=1;i<=n;i++) {
if( deg[i] & 1 ) {
if( lst == 0 ) lst = i;
else addedge(lst, i), lst = 0;
}
}
if( dfs(1, NULL) ) ans.push_back(make_pair(1, 1));
printf("%d
", ans.size());
for(int i=0;i<ans.size();i++)
printf("%d %d
", ans[i].first, ans[i].second);
}
atcoder - AGC029E：记 mx[x] 表示 x 到 1（除了 x）的最大点，再记 f(x, k) 表示从 x 出发经过 <= k（除了 x）的点的点数。则 ans[x] = ans[mx[x]] + f(x, mx[x] - 1)，即我们一旦走过 mx[x] 就不会回头。但是这样算 f(mx[x], mx[mx[x]] - 1) 可能会算重。因此如果算重了，需要再减去 f(x 到 mx[x] 的路径上距离 mx[x] 最近的点, mx[mx[x]] - 1)。f 并查集离线算。
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 200000;
vector<int>G[MAXN + 5], q1[MAXN + 5], q2[MAXN + 5];
void addedge(int u, int v) {
G[u].push_back(v), G[v].push_back(u);
}
int mx[MAXN + 5], pos[MAXN + 5];
void dfs1(int x, int f, int m, int p) {
mx[x] = m, pos[x] = p;
if( x > m ) {
for(int i=0;i<G[x].size();i++)
if( G[x][i] != f ) dfs1(G[x][i], x, x, G[x][i]);
}
else {
for(int i=0;i<G[x].size();i++)
if( G[x][i] != f ) dfs1(G[x][i], x, m, p);
}
if( x != 1 ) {
q1[mx[x] - 1].push_back(x);
if( pos[x] == x && mx[mx[x]] > x )
q2[mx[mx[x]] - 1].push_back(x);
}
}
int ans[MAXN + 5], g[MAXN + 5];
void dfs2(int x, int f) {
if( x != 1 ) {
if( pos[x] == x ) g[x] += ans[mx[x]];
ans[x] += g[pos[x]];
}
for(int i=0;i<G[x].size();i++)
if( G[x][i] != f ) dfs2(G[x][i], x);
}
bool tag[MAXN + 5]; int fa[MAXN + 5], siz[MAXN + 5];
int find(int x) {return fa[x] = (fa[x] == x ? x : find(fa[x]));}
void unite(int x, int y) {
int fx = find(x), fy = find(y);
fa[fx] = fy, siz[fy] += siz[fx];
}
void add(int &sum, int x) {
x = find(x);
if( !tag[x] ) {
tag[x] = true;
sum += siz[find(x)];
}
}
void erase(int x) {tag[find(x)] = false;}
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);
}
dfs1(1, 0, 0, 1);
for(int i=1;i<=N;i++) fa[i] = i, siz[i] = 1;
for(int i=0;i<=N;i++) {
for(int j=0;j<G[i].size();j++)
if( G[i][j] <= i ) unite(i, G[i][j]);
for(int j=0;j<q1[i].size();j++) {
int x = q1[i][j], s = 0;
for(int p=0;p<G[x].size();p++)
if( G[x][p] <= i ) add(s, G[x][p]);
add(s, x), ans[x] += s;
for(int p=0;p<G[x].size();p++)
if( G[x][p] <= i ) erase(G[x][p]);
erase(x);
}
for(int j=0;j<q2[i].size();j++) {
int x = q2[i][j], s = 0;
for(int p=0;p<G[x].size();p++)
if( G[x][p] <= i ) add(s, G[x][p]);
add(s, x), g[x] -= s;
for(int p=0;p<G[x].size();p++)
if( G[x][p] <= i ) erase(G[x][p]);
erase(x);
}
}
ans[1] = 1; dfs2(1, 0);
for(int i=2;i<=N;i++)
printf("%d%c", ans[i] - 1, (i == N ? '
' : ' '));
}
codeforces - 1039D：最大长度为 i 的链剖分等价于最大长度 >= i 的链剖分。可以类比 noip2018d1t3 的贪心，能够子树内部匹配的就不往子树外部匹配，O(n) 贪心一波。注意到答案单调递减，且对于 i 答案上界为 n/i，因此当 > (O(sqrt{nlog n})) 时二分找相同答案右端点可以做到 (O(nsqrt{nlog n}))。略卡常，将递归换成扫 dfs 序。
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 100000;
const int SQRT = 1100;
vector<int>G[MAXN + 5];
void addedge(int u, int v) {
G[u].push_back(v), G[v].push_back(u);
}
int dfn[MAXN + 5], fa[MAXN + 5], dcnt;
void dfs(int x, int f) {
dfn[++dcnt] = x, fa[x] = f;
for(int i=0;i<G[x].size();i++)
if( G[x][i] != f ) dfs(G[x][i], x);
}
int mx[MAXN + 5], smx[MAXN + 5], f[MAXN + 5], g[MAXN + 5], n;
int solve(int x) {
for(register int i=1;i<=n;i++) mx[i] = smx[i] = f[i] = 0;
for(register int i=n;i>=1;i--) {
int k = dfn[i];
if( mx[k] + smx[k] + 1 >= x )
f[k]++, g[k] = 0;
else g[k] = mx[k] + 1;
if( fa[k] ) {
f[fa[k]] += f[k];
if( g[k] > mx[fa[k]] )
smx[fa[k]] = mx[fa[k]], mx[fa[k]] = g[k];
else if( g[k] > smx[fa[k]] )
smx[fa[k]] = g[k];
}
}
return f[1];
}
int ans[MAXN + 5];
int main() {
scanf("%d", &n);
for(int i=1;i<n;i++) {
int u, v; scanf("%d%d", &u, &v);
addedge(u, v);
}
dfs(1, 0); int p;
for(p = 1; p <= SQRT && p <= n; p++)
ans[p] = solve(p);
for(; p <= n;) {
int x = solve(p), l = p, r = n;
while( l < r ) {
int m = (l + r + 1) >> 1;
if( solve(m) >= x )
l = m;
else r = m - 1;
}
for(; p <= l; p++) ans[p] = x;
}
for(int i=1;i<=n;i++) printf("%d
", ans[i]);
}
hdu - 5306：segment tree beats 模板题。我也不知道为啥跑得很慢。
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int MAXN = 1000000;
int read() {
int x = 0; char ch = getchar();
while( ch > '9' || ch < '0' ) ch = getchar();
while( '0' <= ch && ch <= '9' ) x = 10*x + ch - '0', ch = getchar();
return x;
}
void write(ll x, bool _=false) {
if( !x ) {
if( !_ ) putchar('0');
return ;
}
write(x / 10, true), putchar(x % 10 + '0');
}
struct type{
int mx, smx, mc; type() {}
type(int _mx, int _smx, int _mc) : mx(_mx), smx(_smx), mc(_mc) {}
friend type merge(const type &a, const type &b) {
if( a.mx == b.mx ) return type(a.mx, max(a.smx, b.smx), a.mc + b.mc);
else if( a.mx > b.mx ) return type(a.mx, max(a.smx, b.mx), a.mc);
else return type(b.mx, max(a.mx, b.smx), b.mc);
}
};
int a[MAXN + 5], n, m;
namespace segtree{
#define lch (x << 1)
#define rch (x << 1 | 1)
int le[4*MAXN + 5], ri[4*MAXN + 5];
type t[4*MAXN + 5]; ll s[4*MAXN + 5];
void maintain(int x, int k) {
if( k < t[x].mx )
s[x] -= 1LL*(t[x].mx - k)*t[x].mc, t[x].mx = k;
}
void pushdown(int x) {maintain(lch, t[x].mx), maintain(rch, t[x].mx);}
void pushup(int x) {s[x] = s[lch] + s[rch], t[x] = merge(t[lch], t[rch]);}
void build(int x, int l, int r) {
le[x] = l, ri[x] = r;
if( l == r ) {
t[x] = type(a[l], -1, 1); s[x] = a[l];
return ;
}
int m = (l + r) >> 1;
build(lch, l, m), build(rch, m + 1, r);
pushup(x);
}
void modify(int x, int l, int r, int k) {
if( l <= le[x] && ri[x] <= r && t[x].smx < k ) {
maintain(x, k);
return ;
}
if( l > ri[x] || r < le[x] || k >= t[x].mx ) return ;
pushdown(x);
modify(lch, l, r, k), modify(rch, l, r, k);
pushup(x);
}
int query(int x, int l, int r) {
if( l <= le[x] && ri[x] <= r ) return t[x].mx;
if( l > ri[x] || r < le[x] ) return -1;
pushdown(x); return max(query(lch, l, r), query(rch, l, r));
}
ll sum(int x, int l, int r) {
if( l <= le[x] && ri[x] <= r ) return s[x];
if( l > ri[x] || r < le[x] ) return 0;
pushdown(x); return sum(lch, l, r) + sum(rch, l, r);
}
}
void solve() {
n = read(), m = read();
for(int i=1;i<=n;i++) a[i] = read();
segtree::build(1, 1, n);
for(int i=1;i<=m;i++) {
int op = read(), x = read(), y = read(), t;
if( op == 0 ) t = read(), segtree::modify(1, x, y, t);
else if( op == 1 ) write(segtree::query(1, x, y)), puts("");
else write(segtree::sum(1, x, y)), puts("");
}
}
int main() {int _ = read(); while( _-- ) solve();}
bzoj - 4695：稍微复杂一点的 Segment Tree Beats。可以把区间取 max/min 看作区间内 min/max 值整体加减。因为打 tag 会导致 min/max 值变化（反正我写的代码会变化）所以需要先处理出儿子的 min/max 是否与父亲相同。偷了个 fread 刚好卡过。
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int INF = int(1E9);
const int MAXN = 500000;
#define gc if(++ip==ie)fread(ip=buf,1,SZ,stdin)
const int SZ=1<<19;
char buf[SZ],*ie=buf+SZ,*ip=ie-1;
inline int read(){
gc;while(*ip<'-')gc;
bool f=*ip=='-';if(f)gc;
int x=*ip&15;gc;
while(*ip>'-'){x*=10;x+=*ip&15;gc;}
return f?-x:x;
}
int A[MAXN + 5], N, M;
namespace segtree{
#define lch (x << 1)
#define rch (x << 1 | 1)
int le[4*MAXN + 5], ri[4*MAXN + 5]; ll sum[4*MAXN + 5];
bool ismx[4*MAXN + 5], ismn[4*MAXN + 5];
int mx[4*MAXN + 5], smx[4*MAXN + 5], cmx[4*MAXN + 5];
int mn[4*MAXN + 5], smn[4*MAXN + 5], cmn[4*MAXN + 5];
int stg[4*MAXN + 5], mxtg[4*MAXN + 5], mntg[4*MAXN + 5];
void pushup(int x) {
sum[x] = sum[lch] + sum[rch];
mx[x] = max(mx[lch], mx[rch]);
if( mx[lch] == mx[rch] ) smx[x] = max(smx[lch], smx[rch]), cmx[x] = cmx[lch] + cmx[rch];
else if( mx[lch] < mx[rch] ) smx[x] = max(mx[lch], smx[rch]), cmx[x] = cmx[rch];
else smx[x] = max(smx[lch], mx[rch]), cmx[x] = cmx[lch];
ismx[lch] = (mx[lch] == mx[x]), ismx[rch] = (mx[rch] == mx[x]);
mn[x] = min(mn[lch], mn[rch]);
if( mn[lch] == mn[rch] ) smn[x] = min(smn[lch], smn[rch]), cmn[x] = cmn[lch] + cmn[rch];
else if( mn[lch] > mn[rch] ) smn[x] = min(mn[lch], smn[rch]), cmn[x] = cmn[rch];
else smn[x] = min(smn[lch], mn[rch]), cmn[x] = cmn[lch];
ismn[lch] = (mn[lch] == mn[x]), ismn[rch] = (mn[rch] == mn[x]);
}
void maintains(int x, int t) {
if( t == 0 ) return ;
stg[x] += t, mx[x] += t, mn[x] += t;
sum[x] += 1LL * t * (ri[x] - le[x] + 1);
if( mn[x] != mx[x] ) smn[x] += t, smx[x] += t;
}
void maintainmx(int x, int t) {
if( mn[x] == mx[x] ) maintains(x, t);
else {
mxtg[x] += t, sum[x] += 1LL * t * cmx[x];
if( mx[x] == smn[x] ) smn[x] += t; mx[x] += t;
}
}
void maintainmn(int x, int t) {
if( mn[x] == mx[x] ) maintains(x, t);
else {
mntg[x] += t, sum[x] += 1LL * t * cmn[x];
if( mn[x] == smx[x] ) smx[x] += t; mn[x] += t;
}
}
void pushdown(int x) {
if( mxtg[x] ) {
if( ismx[lch] ) maintainmx(lch, mxtg[x]);
if( ismx[rch] ) maintainmx(rch, mxtg[x]);
mxtg[x] = 0;
}
if( mntg[x] ) {
if( ismn[lch] ) maintainmn(lch, mntg[x]);
if( ismn[rch] ) maintainmn(rch, mntg[x]);
mntg[x] = 0;
}
if( stg[x] ) maintains(lch, stg[x]), maintains(rch, stg[x]), stg[x] = 0;
}
void build(int x, int l, int r) {
le[x] = l, ri[x] = r, stg[x] = mntg[x] = mxtg[x] = 0;
if( l == r ) {
sum[x] = mx[x] = mn[x] = A[l], smn[x] = INF, smx[x] = -INF, cmn[x] = cmx[x] = 1;
return ;
}
int m = (l + r) >> 1;
build(lch, l, m), build(rch, m + 1, r);
pushup(x);
}
void modifys(int x, int l, int r, int k) {
if( l > ri[x] || r < le[x] ) return ;
if( l <= le[x] && ri[x] <= r ) {
maintains(x, k);
return ;
}
pushdown(x);
modifys(lch, l, r, k), modifys(rch, l, r, k);
pushup(x);
}
void modifymn(int x, int l, int r, int k) {
if( mx[x] <= k ) return ;
if( l > ri[x] || r < le[x] ) return ;
if( l <= le[x] && ri[x] <= r && smx[x] < k ) {
maintainmx(x, k - mx[x]);
return ;
}
pushdown(x);
modifymn(lch, l, r, k), modifymn(rch, l, r, k);
pushup(x);
}
void modifymx(int x, int l, int r, int k) {
if( mn[x] >= k ) return ;
if( l > ri[x] || r < le[x] ) return ;
if( l <= le[x] && ri[x] <= r && smn[x] > k ) {
maintainmn(x, k - mn[x]);
return ;
}
pushdown(x);
modifymx(lch, l, r, k), modifymx(rch, l, r, k);
pushup(x);
}
ll querys(int x, int l, int r) {
if( l > ri[x] || r < le[x] ) return 0;
if( l <= le[x] && ri[x] <= r ) return sum[x];
pushdown(x); return querys(lch, l, r) + querys(rch, l, r);
}
int querymn(int x, int l, int r) {
if( l > ri[x] || r < le[x] ) return INF;
if( l <= le[x] && ri[x] <= r ) return mn[x];
pushdown(x); return min(querymn(lch, l, r), querymn(rch, l, r));
}
int querymx(int x, int l, int r) {
if( l > ri[x] || r < le[x] ) return -INF;
if( l <= le[x] && ri[x] <= r ) return mx[x];
pushdown(x); return max(querymx(lch, l, r), querymx(rch, l, r));
}
}
void write(int x) {
if( x < 0 ) x = -x, putchar('-');
if( x >= 10 ) write(x / 10);
putchar(x % 10 + '0');
}
void write(ll x) {
if( x < 0 ) x = -x, putchar('-');
if( x >= 10 ) write(x / 10);
putchar(x % 10 + '0');
}
int main() {
N = read();
for(int i=1;i<=N;i++) A[i] = read();
segtree::build(1, 1, N);
M = read();
for(int i=1;i<=M;i++) {
int tp = read(), L = read(), R = read();
if( tp <= 3 ) {
int X = read();
if( tp == 1 ) segtree::modifys(1, L, R, X);
else if( tp == 2 ) segtree::modifymx(1, L, R, X);
else segtree::modifymn(1, L, R, X);
} else {
if( tp == 4 ) write(segtree::querys(1, L, R)), puts("");
else if( tp == 5 ) write(segtree::querymx(1, L, R)), puts("");
else write(segtree::querymn(1, L, R)), puts("");
}
}
}
bzoj - 3064：维护标记 max(x + a, b)，可以统一题目中的操作，而且可以方便地维护最大值与历史最大值。
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int MAXN = 100000;
const ll INF = ll(1E12);
struct type{
ll a, b; type() {}
type(ll _a, ll _b) : a(_a), b(_b) {}
friend type operator + (type a, type b) {
return type(a.a + b.a, max(a.b + b.a, b.b));
} // max(max(x + a.a, a.b) + b.a, b.b)
friend type max(type a, type b) {
return type(max(a.a, b.a), max(a.b, b.b));
} // max(max(x + a.a, a.b), max(x + b.a, b.b))
}; // max(x + a, b)
int A[MAXN + 5], T;
namespace segtree{
#define lch (x << 1)
#define rch (x << 1 | 1)
int le[4*MAXN + 5], ri[4*MAXN + 5];
type tg[4*MAXN + 5], htg[4*MAXN + 5];
type mx[4*MAXN + 5], hmx[4*MAXN + 5];
void pushup(int x) {
mx[x] = max(mx[lch], mx[rch]), hmx[x] = max(hmx[lch], hmx[rch]);
}
void maintain(int x, type t, type ht) {
hmx[x] = max(hmx[x], mx[x] + ht), mx[x] = mx[x] + t;
htg[x] = max(htg[x], tg[x] + ht), tg[x] = tg[x] + t;
}
void pushdown(int x) {
maintain(lch, tg[x], htg[x]);
maintain(rch, tg[x], htg[x]);
tg[x] = htg[x] = type(0, -INF);
}
void build(int x, int l, int r) {
le[x] = l, ri[x] = r, tg[x] = htg[x] = type(0, -INF);
if( l == r ) {
mx[x] = hmx[x] = type(-INF, A[l]);
return ;
}
int m = (l + r) >> 1;
build(lch, l, m), build(rch, m + 1, r);
pushup(x);
}
type query(int x, int l, int r, int t) {
if( l > ri[x] || r < le[x] ) return type(-INF, -INF);
if( l <= le[x] && ri[x] <= r ) return (t == 0 ? mx[x] : hmx[x]);
pushdown(x); return max(query(lch, l, r, t), query(rch, l, r, t));
}
void modify(int x, int l, int r, type k) {
if( l > ri[x] || r < le[x] ) return ;
if( l <= le[x] && ri[x] <= r ) {
maintain(x, k, k);
return ;
}
pushdown(x);
modify(lch, l, r, k), modify(rch, l, r, k);
pushup(x);
}
}
char op[2];
int main() {
scanf("%d", &T);
for(int i=1;i<=T;i++) scanf("%d", &A[i]);
segtree::build(1, 1, T);
int E; scanf("%d", &E);
for(int i=1;i<=E;i++) {
int X, Y; scanf("%s%d%d", op, &X, &Y);
if( op[0] == 'Q' ) {
type ans = segtree::query(1, X, Y, 0);
printf("%lld
", max(ans.a, ans.b));
} else if( op[0] == 'A' ) {
type ans = segtree::query(1, X, Y, 1);
printf("%lld
", max(ans.a, ans.b));
} else if( op[0] == 'P' ) {
int Z; scanf("%d", &Z);
segtree::modify(1, X, Y, type(Z, -INF));
} else {
int Z; scanf("%d", &Z);
segtree::modify(1, X, Y, type(-INF, Z));
}
}
}