CCPC Finals 2021 H Harie Programming Contest （网络流&支配树的妙用）
题意： 给一个二分图，求有多少种方案删去恰好两个点，使得最大匹配数不变。\(n,m\le 2\times 10^5\)。
二话不说先跑一遍 Dinic 网络流，设残量网络形成的图为 \(G\)。
然后开始分类讨论：
1. 删去的两个点分别在两侧
设左边删去了 \(u\)，右边删去了 \(v'\)。（以下称左部点为 $\alpha $，右部点为 \(\alpha '\)，字母对应则互相匹配）
1.1 两边删去的均为匹配点
此时需要分别从 \(u'\) 与 \(v\) 开始找一条增广路，并且这两条路不能相交。
很开心地发现这两条路其实并不会相交，否则假设在边 \((a,a')\) 相交，那么 \(u'\) 有一条增广路 \(u'\rightarrow a\rightarrow a'\rightarrow x\)，\(v\) 有一条增广路 \(v\rightarrow a'\rightarrow a\rightarrow y'\)，会发现原图就会有一条增广路 \(x\rightarrow a'\rightarrow a\rightarrow y'\)，与原图是最大匹配矛盾。
于是此时 \(u\) 与 \(v'\) 独立。
1.2 一边删去匹配点，一边删去未配点
不妨设 \(u\) 为匹配点，发现从 \(u\) 开始找增广路的过程中，找到的右部点均为匹配点，于是 \(u\) 不会找到 \(v'\)。
于是此时 \(u\) 与 \(v'\) 独立。
1.3 两边均为未配点
此时 \(u\) 与 \(v'\) 显然独立。
综上所述，\(u\) 是否合法与 \(v'\) 是否合法相互独立，于是可以分开计算再乘起来即可。
以左部点 \(u\) 为例，要求其为未配点或其匹配点 \(u'\) 能找到一条增广路。这等价于 \(G\) 中存在一条从 \(S\) 到 \(u'\) 的路径，直接从 \(S\) 开始搜一遍即可。右部点同理。
2. 删去的两个点在同一侧
不妨设删的都是左部点 \(u\) 和 \(v\)。注意，以下部分开始才需用到支配树。
2.1 删掉的两个均为匹配点
现在 \(u'\) 和 \(v'\) 都要找到一条增广路，并且这两条路不相交。这等价于 \(G\) 中存在从 \(S\) 分别到 \(u'\) 和 \(v'\) 的两条不相交的路径，等价于无法删掉某一个点能同时断掉从 \(S\) 到 \(u'\) 和 \(v'\) 的所有路径，等价于 \(u'\) 和 \(v'\) 在以 \(S\) 为起点支配树上的 LCA 恰好为根（第一个等价于可以手推或用最大流最小割定理）。求出支配树然后子树内随便数一数即可。
2.2 删掉一个匹配点和一个未配点
不妨设 \(u\) 为匹配点。
此时我们要求 \(G\) 中存在一条从 \(S\) 到 \(u'\) 的路径且不经过 \(v\)，这即为 \(v\) 不支配 \(u'\)，也即为 \(v\) 在以 \(S\) 为起点的支配树中不是 \(u'\) 的祖先。于是求出支配树还是在每个 \(v\) 的子树内数一数即可。
2.3 删掉两个未配点
trivial.
综上所述，以 \(S\) 为根跑一遍支配树然后子树计数就可以处理左部点的情况，右部点从 \(T\) 也类似跑一遍即可。注意一些连边的细节。
时间复杂度 \(O(m\sqrt{n}+n\log n)\)。
上一份代码：
Code
#include <bits/stdc++.h>
#define For(i,a,b) for(int i=a;i<=b;i++)
#define Rev(i,a,b) for(int i=a;i>=b;i--)
#define Fin(file) freopen(file,"r",stdin)
#define Fout(file) freopen(file,"w",stdout)
using namespace std;
// N is the number of vertices, M is the number of edges you're about to add
template<int N,int M,typename cst_type=int>
class Dinic{
public:
int n,S,T,head[N],nxt[M*2],to[M*2],tot;
cst_type cap[M*2],maxflow;
int q[N],h,t,dep[N],now[N];
bool bfs(){
h=t=0; q[t++]=S; For(i,1,n) dep[i]=0;
dep[S]=1; now[S]=head[S];
while(h<t){
int u=q[h++];
for(int e=head[u];e;e=nxt[e]){
if(cap[e]==0) continue;
int v=to[e]; if(!dep[v]){
dep[v]=dep[u]+1; now[v]=head[v]; q[t++]=v;
if(v==T) return true;
}
}
}
return false;
}
cst_type dfs(int u,cst_type flow){
if(u==T) return flow;
cst_type fw=0;
for(int& e=now[u];e;e=nxt[e]){
if(cap[e]==0) continue;
int v=to[e];
if(dep[v]!=dep[u]+1) continue;
cst_type res=dfs(v,min(flow,cap[e]));
if(res==0) { dep[v]=0; continue; }
cap[e]-=res; cap[e^1]+=res; fw+=res; flow-=res;
if(flow==0) break;
}
return fw;
}
public:
void init(int _n) { n=_n; memset(head,0,sizeof(head)); tot=1; }
int add_edge(int x,int y,cst_type z) {
nxt[++tot]=head[x]; head[x]=tot; to[tot]=y; cap[tot]=z;
nxt[++tot]=head[y]; head[y]=tot; to[tot]=x; cap[tot]=0; return tot-1;
}
cst_type solve(int _S,int _T,cst_type inf=numeric_limits<cst_type>::max()) {
S=_S; T=_T; maxflow=0;
while(bfs()) { cst_type res=-1; while((res=dfs(S,inf))!=0) maxflow+=res; }
return maxflow;
}
bool is_full(int e) { return cap[e]==0; }
cst_type get_flow(int e) { return cap[e^1]; }
};
template<int N>
class DominatorTree{
int n,dfn[N],raw[N],dfscnt,semi[N],fa[N],pa[N],ffa[N][18],dep[N],in[N];
vector<int> to[N],from[N],cp[N],cv[N];
void dfs(int u){
raw[dfn[u]=++dfscnt]=u; for(int v:to[u]) if(!dfn[v]) { cp[u].push_back(v); pa[v]=u; dfs(v); }
}
int getfa(int x){
if(x!=fa[x]) { int t=getfa(fa[x]); semi[x]=min(semi[x],semi[fa[x]]); fa[x]=t; } return fa[x];
}
int lca(int x,int y){
if(x==0||y==0) return x^y;
if(dep[x]<dep[y]) swap(x,y);
Rev(i,17,0) if(dep[ffa[x][i]]>=dep[y]) x=ffa[x][i];
if(x==y) return x;
Rev(i,17,0) if(ffa[x][i]!=ffa[y][i]) { x=ffa[x][i]; y=ffa[y][i]; }
return ffa[x][0];
}
public:
void init(int _n) { n=_n; }
void add_edge(int x,int y) { to[x].push_back(y); from[y].push_back(x); }
void solve(int S,int* ans){
dfs(S); //assert(dfscnt==n);
For(i,1,n) { fa[i]=i; semi[i]=dfn[i]; }
Rev(i,dfscnt,2){
int u=raw[i]; if(!dfn[u]) continue;
for(int w:from[u]) if(dfn[w]) { getfa(w); semi[u]=min(semi[u],semi[w]); }
fa[u]=pa[u]; cp[raw[semi[u]]].push_back(u); // Must do it right now!
}
For(u,1,n) for(int v:cp[u]) { cv[v].push_back(u); in[v]++; }
static int q[N],h,t; h=t=0; q[t++]=S;
while(h<t){
int u=q[h++]; ans[u]=0;
for(int v:cv[u]) if(ans[u]==0) ans[u]=v; else ans[u]=lca(ans[u],v);
dep[u]=dep[ffa[u][0]=ans[u]]+1; For(i,1,17) ffa[u][i]=ffa[ffa[u][i-1]][i-1];
for(int v:cp[u]) if((--in[v])==0) q[t++]=v;
}
}
};
const int N=2e5+5; typedef long long ll;
Dinic<N*2,N*2,int> G;
DominatorTree<N*2> T1,T2; ll ans;
int n,m,S,T,col[N],cp[N],ed[N],visS[N],visT[N],fa[N],cnt[N],Scnt,Tcnt;
vector<int> to[N],from[N],clis[N],son[N];
void dfs(int u){
for(int v:to[u]) if(!col[v]) { col[v]=3-col[u]; dfs(v); }
}
void dfsS(int u) { visS[u]=1; if(col[u]==2) Scnt++; for(int v:to[u]) if(!visS[v]) dfsS(v); }
void dfsT(int u) { visT[u]=1; if(col[u]==1) Tcnt++; for(int v:from[u]) if(!visT[v]) dfsT(v); }
void dp1(int u){
cnt[u]=(col[u]==2&&visS[u]);
for(int v:son[u]) { dp1(v); cnt[u]+=cnt[v]; }
if(col[u]==1&&!cp[u]) ans+=Scnt-cnt[u];
}
void dp2(int u){
cnt[u]=(col[u]==1&&visT[u]);
for(int v:son[u]) { dp2(v); cnt[u]+=cnt[v]; }
if(col[u]==2&&!cp[u]) ans+=Tcnt-cnt[u];
}
ll C2(int x) { return 1ll*x*(x-1)/2; }
signed main(){
cin>>n>>m; For(i,1,m) { int x,y; cin>>x>>y; to[x].push_back(y); to[y].push_back(x); }
For(i,1,n) if(!col[i]) { col[i]=1; dfs(i); }
G.init(n+2); S=n+1; T=n+2;
For(u,1,n){
if(col[u]==1) { ed[u]=G.add_edge(S,u,1); for(int v:to[u]) clis[u].push_back(G.add_edge(u,v,1)); }
else ed[u]=G.add_edge(u,T,1);
}
G.solve(S,T);
For(u,1,n){
if(col[u]==1){
if(G.is_full(ed[u])){
int sz=to[u].size();
For(i,0,sz-1) if(G.is_full(clis[u][i])) { cp[u]=to[u][i]; cp[to[u][i]]=u; break; }
}
}
}
For(u,1,n+2) to[u].clear();
for(int e=2;e<=G.tot;e+=2){
if(G.cap[e]) { to[G.to[e^1]].push_back(G.to[e]); from[G.to[e]].push_back(G.to[e^1]); }
else { to[G.to[e]].push_back(G.to[e^1]); from[G.to[e^1]].push_back(G.to[e]); }
}
dfsS(S); dfsT(T); ll t1=0,t2=0;
For(i,1,n){
if(col[i]==1) { if(!cp[i]||visS[cp[i]]) t1++; }
else { if(!cp[i]||visT[cp[i]]) t2++; }
}
ans=t1*t2;
T1.init(n+2); For(u,1,n+2) for(int v:to[u]) T1.add_edge(u,v);
T1.solve(S,fa); For(u,1,n+2) son[fa[u]].push_back(u);
dp1(S); int o1=0; For(i,1,n) if(col[i]==1&&!cp[i]) o1++; ans+=C2(o1);
ans+=C2(cnt[S]); for(int v:son[S]) ans-=C2(cnt[v]);
For(i,1,n+2) { fa[i]=cnt[i]=0; son[i].clear(); }
T2.init(n+2); For(u,1,n+2) for(int v:to[u]) T2.add_edge(v,u);
T2.solve(T,fa); For(u,1,n+2) son[fa[u]].push_back(u);
dp2(T); int o2=0; For(i,1,n) if(col[i]==2&&!cp[i]) o2++; ans+=C2(o2);
ans+=C2(cnt[T]); for(int v:son[T]) ans-=C2(cnt[v]);
cout<<ans<<'\n';
cerr<<"Time = "<<clock()<<" ms\n";
return 0;
}
// START TYPING IF YOU DON'T KNOW WHAT TO DO
