边分治维护强连通分量（CF1989F，P5163）
这里的边分治和树上的点分治边分治不一样，是维护强连通分量用的，每条边有一个出现时间，通过将每条边按连通关系分流重新排列，从而维护每个时间点整张图的连通性。
具体的，这个算法是维护这样的一类问题：
n 个点，m 条边按时间顺序依次加入，每加入一条边，你需要回答一些问题，比如在这个时间点，图中有多少强连通分量，或者某个点所在强连通分量的大小。
暴力的做法是每加入一条边就跑一遍tarjan算法，当边比较稠密时，缩点合并比较频繁，每次缩点就会让总点数减小，只用缩点后的图继续加边，复杂度似乎说的过去。
但强连通分量比较多时，跑一遍tarjan甚至缩不了任何点，比如一张DAG，就可以轻松卡到 n^2。这样暴力复杂度高的原因在于，很多无法成为强连通分量里的边遍历了好几次，每次都没有被缩掉，极大地浪费了时间。
按连通性进行边分治：
我们希望多次进行tarjan算法时，那些连不出强连通分量的边可以少遍历几次，而是尽量让它们在形成强连通分量的时候被遍历，因为这样可以把这些点和边缩掉，以后也不用遍历。
一个很妙的分治方式：我们将当前计算的时间线 \([l,r]\) 分一半，只保留前一半时间的边，跑一遍tarjan算法，将强连通分量找到，把那些已经在强连通分量中的边放进前一半时间 \([l,mid]\) ，把没有进入强连通分量的边放进后一半时间 \([mid+1,r]\) 。
这样做的意义是：在 mid 时刻某些边还没有进入强连通分量，说明在之前的时刻也一定没有进入，这条边就是一条废边，在前 mid 的时间里对我们要维护的东西（连通块）没有任何作用，我们把它丢进后半的时间，也就是在计算前面的时间段内，tarjan算法根本不会去跑这条边，这就节省了暴力做法多次遍历同一条边的复杂度。而反过来，在mid时刻形成的强连通分量，必定是在 \([l,mid]\) 内形成的，但我们不知道具体形成时间。所以我们再分治下去，计算 \([l,mid]\) 这个时间段内的连通情况，以及后半段 \([mid+1,r]\) 的连通情况，在后半段，新加入的边和前半段丢进来的废边有可能会形成新的强连通分量。
我们将每条边不断地向下分，形成类似线段树的分治结构，这个和线段树分治+可撤销并查集的科技非常相似，都是按时间分治，有异曲同工之处。
我们放一张图，图中的边权是这条边加入的时间：
当我们的时间分治到线段树的叶子时，也就是代表这个时刻，由于我们一直将同一个强连通分量的边放在同一侧，在叶子处的边一定是形成了新的强连通分量，我们可以放心地将叶子处的这些点进行合并处理。
注意到时间段 6-10 处的 1,2,3 号点已经缩成了一个点，这是由于我们优先走线段树的左子树，在 3 时刻，我们就已经用并查集将1,2,3三个点连接在一起，并用1号点当做这个强连通分量的代表点，之后的连接1,2,3的边，统一改为连接 1 号点。
在做题时看到题解里说要用并查集维护缩点，于是去学习了一下，回来发现这个维护和那个维护不是同一回事，有一个并查集代替tarjan的缩点算法，实现起来也比较简单，感兴趣可以看下：一个代替tarjan的缩点算法：并查集维护缩点。可是这里所说的并查集仅仅是维护一下每个强连通分量有哪些点，并没有替换掉tarjan算法。
这张图中还有一个要注意的点：虽然我们只有9条边，但是分治的时间段是1-10，这是因为时间点10是用于 “垃圾存放” 的，因为我们每个时间段都把边分成了两种，把废边扔到右侧，保证在遍历到叶子时一定是找到了一个强连通分量，但是仍然有一些边最终也没有进入强连通分量（如此图中的7号边），我们每次都将它分流到右侧，因此被放在了垃圾回收的地方，多出来的这个时刻 10 也不需要我们记录答案。
注意到每层都是 m 条边，一共log层，因此复杂度是 \(O(mlogm)\)。
下面是算法的核心代码：（此模板用于记录每个时刻强连通分量数量，代码下附带样例与上图相同）
int find(int x) { return fa[x]==x ? x : fa[x]=find(fa[x]); }
inline void merge(int x,int y) {
x = find(x); y = find(y);
if(x==y) return ;
fa[x] = y;
_ans--;
}
void tarjan(int u) {
dfn[u] = low[u] = ++tim;
st[++cnt] = u; in[u] = 1;
for(int v : e[u]) {
if(!dfn[v]) {
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(in[v]) low[u] = min(low[u],dfn[v]);
}
if(low[u]==dfn[u]) {
while(1) {
int v = st[cnt--]; in[v] = 0;
belong[v] = u;
if(v==u) break;
}
}
}
void solve(ll now,ll l,ll r) {
if(l==r) {
for(E vv : d[now]) merge(vv.x, vv.y);
vector<E>().swap(d[now]);
ans[l] = _ans;
return ;
}
ll mid = l+r >> 1;
for(E &vv : d[now]) {
e[vv.x = find(vv.x)].clear();
e[vv.y = find(vv.y)].clear();
dfn[vv.x] = dfn[vv.y] = 0;
}
for(E vv : d[now]) if(vv.ti<=mid) e[vv.x].push_back(vv.y);
for(E vv : d[now]) {
if(vv.ti<=mid) {
if(!dfn[vv.x]) tarjan(vv.x);
if(!dfn[vv.y]) tarjan(vv.y);
if(belong[vv.x]==belong[vv.y]) d[ls].push_back(vv);
else d[rs].push_back(vv);
}
else {
d[rs].push_back(vv);
}
}
vector<E>().swap(d[now]);
solve(ls, l, mid);
solve(rs, mid+1, r);
}
void chushihua() {
_ans = 0;
tim = 0;
}
int main() {
int x,y;
T = read();
while(T--) {
chushihua();
n = read(); m = read();
_ans = n;
for(int i=1;i<=n;i++) fa[i] = i;
for(int i=1;i<=m;i++) {
x = read(); y = read();
d[1].push_back({x,y,i});
}
solve(1, 1, m+1);
for(int i=1;i<=m;i++) cout<<ans[i]<<"\n";
}
return 0;
}
/*
1
7 9
1 3
2 1
3 2
3 4
5 6
4 5
5 7
6 4
4 2
*/
例题1：CF1989F
题意：一个方阵，可以横着刷红漆，竖着刷蓝漆，你可以不花费代价一行一列刷，或花费 k^2 的代价同时刷 k 次，相交处颜色自己定。Q次询问，每次增加一个格子的颜色限制，问最小花费。
Solution:
我们把每一行，每一列的刷漆动作都看成一个点，一个格子颜色的限制暗示了一个顺序：这个颜色的动作必须晚于另一个颜色的动作。这个限制也就是拓扑序的一条边，连接这一行一列两个动作的点。
这些边限制了我们选点的顺序，而当这些边形成了环，我们就无法找出一个拓扑序，就需要进行同时刷 k 次的操作。根据经验得出 k 就是这些边强连通分量的大小，这个强连通分量的贡献也就是 size 的平方。
因此题意转化为了：每个时刻加入一条边，询问当前时刻所有 size>1 的强连通分量的 size 平方和。可以直接套用边分治缩点的模板。
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
#define QWQ cout<<"QwQ\n";
#define ll long long
#include <vector>
#include <queue>
#include <map>
#define ls now<<1
#define rs now<<1|1
using namespace std;
const ll N=501010;
const ll qwq=303030;
const ll inf=0x3f3f3f3f;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll T;
ll n,m,Q,tot;
ll ans[N], _ans;
ll fa[N],siz[N];
struct E{
ll x,y,ti;
};
vector <E> d[N<<2];
vector <ll> e[N];
ll tim,dfn[N],low[N],belong[N];
ll in[N],st[N],cnt;
ll find(ll x) { return fa[x]==x ? x : fa[x]=find(fa[x]); }
inline void merge(ll x,ll y) {
x = find(x); y = find(y);
if(x==y) return ;
if(siz[x]>1) _ans -= siz[x] * siz[x];
if(siz[y]>1) _ans -= siz[y] * siz[y];
fa[x] = y;
siz[y] += siz[x];
_ans += siz[y] * siz[y];
}
void tarjan(ll u) {
dfn[u] = low[u] = ++tim;
st[++cnt] = u; in[u] = 1;
for(ll v : e[u]) {
if(!dfn[v]) {
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(in[v]) low[u] = min(low[u],dfn[v]);
}
if(low[u]==dfn[u]) {
while(1) {
ll v = st[cnt--]; in[v] = 0;
belong[v] = u;
if(v==u) break;
}
}
}
void solve(ll now,ll l,ll r) {
if(l==r) {
for(E v : d[now]) merge(v.x, v.y);
vector<E>().swap(d[now]);
ans[l] = _ans;
return ;
}
ll mid = l+r >> 1;
for(ll i=0;i<d[now].size();i++) {
d[now][i].x = find(d[now][i].x);
d[now][i].y = find(d[now][i].y);
}
for(E v : d[now]) e[v.x].clear(), e[v.y].clear(), dfn[v.x] = dfn[v.y] = 0;
for(E v : d[now]) if(v.ti<=mid) e[v.x].push_back(v.y);
for(E v : d[now]) {
if(v.ti<=mid) {
if(!dfn[v.x]) tarjan(v.x);
if(!dfn[v.y]) tarjan(v.y);
if(belong[v.x]==belong[v.y]) d[ls].push_back(v);
else d[rs].push_back(v);
}
else {
d[rs].push_back(v);
}
}
vector<E>().swap(d[now]);
solve(ls, l, mid);
solve(rs, mid+1, r);
}
int main() {
ll x,y; char cz[2];
n = read(); m = read(); Q = read();
tot = n+m;
for(ll i=1;i<=tot;i++) fa[i] = i, siz[i] = 1;
for(ll i=1;i<=Q;i++) {
x = read(); y = read();
scanf("%s",cz);
if(cz[0]=='R') d[1].push_back({y+n, x, i});
else d[1].push_back({x, y+n, i});
}
solve(1, 1, Q+1);
for(ll i=1;i<=Q;i++) cout<<ans[i]<<"\n";
return 0;
}
例题2：P5163
题意：给你一张 n 个点 m 条边的有向图，q 个操作：操作一，删除某条边；操作二，增加某个点权值；操作三，询问某个点所在强连通分量内前 k 大点权和。
Solution：
我们的边分治缩点模板是每个时刻加入一条边，这题是删除某条边，我们倒着来做，从最后一个操作开始往上，就变成了加边。由于最后一个操作时边还有剩余，我们也给剩余的边设置一个不一样加入时间，省去讨论的麻烦。
将每个修改点权的操作和询问挂在某条边加入的时间点，在分治到叶子结点时处理这些操作。记住我们正着挂，在遍历时要倒着遍历。
这题要维护的东西比上一个例题要复杂，但也是很模板的东西，而且和我们的边分治过程代码交叉很少，所以不难写。
可以用平衡树，启发式合并，空间稍微小点但是时间多个log，不如权值线段树合并，也可以维护前 k 大的权值。
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
#define QWQ cout<<"QwQ\n";
#define ll long long
#include <vector>
#include <queue>
#include <map>
#define ls L[now]
#define rs R[now]
using namespace std;
const ll N=501010;
const ll qwq=303030;
const ll inf=0x3f3f3f3f;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll n,m,Q;
map <ll,ll> f;
struct E{
ll x,y,ti;
};
vector <E> d[N<<2];
vector <ll> e[N];
ll X[N],Y[N];
struct Qr{
ll cz,x,y;
};
vector <Qr> g[N];
ll ans[N],cntq;
ll a[N];
ll ma_val = 1e9;
ll siz[N*34],t[N*34],rt[N],tot,L[N*34],R[N*34];
inline void pushup(ll now) {
t[now] = t[ls] + t[rs];
siz[now] = siz[ls] + siz[rs];
}
void insert(ll &now,ll l,ll r,ll x,ll v) {
// if(l==1 && r==ma_val) cout<<""
if(!now) now = ++tot;
if(l==r) { siz[now] += v; t[now] += l*v; return ; }
ll mid = (l+r) >> 1;
if(x<=mid) insert(ls, l, mid, x, v);
else insert(rs, mid+1, r, x, v);
if(!siz[ls]) ls = 0;
if(!siz[rs]) rs = 0;
pushup(now);
}
ll query(ll now,ll l,ll r,ll k) {
if(siz[now]<=k) return t[now];
if(l==r) { return k*l; }
ll mid = (l+r) >> 1;
if(siz[rs]>=k) return query(rs, mid+1, r, k);
else return query(ls, l, mid, k-siz[rs]) + t[rs];
}
ll merge_tree(ll r1,ll r2,ll l,ll r) {
if(!r1 || !r2) return r1 + r2;
if(l==r) {
siz[r1] += siz[r2];
t[r1] += t[r2];
return r1;
}
ll mid = (l+r) >> 1;
L[r1] = merge_tree(L[r1], L[r2], l, mid);
R[r1] = merge_tree(R[r1], R[r2], mid+1, r);
pushup(r1);
return r1;
}
ll pa[N];
ll find(ll x) { return pa[x]==x ? x : pa[x]=find(pa[x]); }
inline void merge(ll x,ll y) {
x = find(x); y = find(y);
if(x==y) return ;
pa[x] = y;
rt[y] = merge_tree(rt[x], rt[y], 1, ma_val);
}
ll tim,dfn[N],low[N],belong[N];
ll in[N],st[N],cnt;
void tarjan(ll u) {
dfn[u] = low[u] = ++tim;
st[++cnt] = u; in[u] = 1;
for(ll v : e[u]) {
if(!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
}
else if(in[v]) low[u] = min(low[u], dfn[v]);
}
if(low[u]==dfn[u]) {
while(1) {
ll v = st[cnt--]; in[v] = 0;
belong[v] = u;
if(v==u) break;
}
}
}
void calc(ll ti) {
for(ll i=g[ti].size()-1; i>=0; i--) {
Qr vv = g[ti][i];
if(vv.cz==2) {
insert(rt[find(vv.x)], 1, ma_val, a[vv.x], -1);
a[vv.x] -= vv.y;
insert(rt[find(vv.x)], 1, ma_val, a[vv.x], 1);
}
else {
ans[++cntq] = query(rt[find(vv.x)], 1, ma_val, vv.y);
}
}
}
void solve(ll now,ll l,ll r) {
if(l==r) {
for(E vv : d[now]) merge(vv.x, vv.y);
vector<E>().swap(d[now]);
calc(l);
return ;
}
ll mid = (l+r) >> 1;
for(E &vv : d[now]) {
e[vv.x = find(vv.x)].clear();
e[vv.y = find(vv.y)].clear();
dfn[vv.x] = dfn[vv.y] = 0;
}
for(E vv : d[now]) if(vv.ti<=mid) e[vv.x].push_back(vv.y);
for(E vv : d[now]) {
if(vv.ti<=mid) {
if(!dfn[vv.x]) tarjan(vv.x);
if(!dfn[vv.y]) tarjan(vv.y);
if(belong[vv.x]==belong[vv.y]) d[now<<1].push_back(vv);
else d[now<<1|1].push_back(vv);
}
else {
d[now<<1|1].push_back(vv);
}
}
vector<E>().swap(d[now]);
solve(now<<1, l, mid);
solve(now<<1|1, mid+1, r);
}
int main() {
ll cz,x,y;
n = read(); m = read(); Q = read();
ll nowtim = m;
for(ll i=1;i<=n;i++) a[i] = read(), pa[i] = i;
for(ll i=1;i<=m;i++) X[i] = read(), Y[i] = read();
for(ll i=1;i<=Q;i++) {
cz = read();
if(cz==1) {
x = read(); y = read();
f[x*n+y] = 1;
d[1].push_back({x,y,nowtim});
nowtim--;
}
if(cz==2) {
x = read(); y = read();
a[x] += y;
g[nowtim].push_back({2,x,y});
}
if(cz==3) {
x = read(); y = read();
g[nowtim].push_back({3,x,y});
}
}
for(ll i=1;i<=m;i++) {
if(f[X[i]*n+Y[i]]) continue;
d[1].push_back({X[i],Y[i],nowtim});
nowtim--;
}
for(ll i=1;i<=n;i++) {
insert(rt[i], 1, ma_val, a[i], 1);
}
calc(0);
solve(1, 1, m+1);
for(ll i=cntq;i>=1;i--) cout<<ans[i]<<"\n";
return 0;
}
