LOJ2276 [HAOI2017] 新型城市化 【二分图匹配】【tarjan】

题目分析：

这题出的好！

首先问题肯定是二分图的最大独立集，如果删去某条匹配边之后独立集是否会变大。

跑出最大流之后流满的边就是匹配边。

如果一个匹配边的两个端点在一个强连通分量里，那这条边删掉之后我们就可以找到一个替代方案使得匹配不变小。

具体的，假设这两个点是x,y。因为两者之间连的是匹配边，那么存在一个路径从t->y->x->s。那只要从s有另一条路径到y或者从x有另一条路径到t那就构成一个强连通分量，我们只考虑s到y的情况。

如果存在一条这样的路，我们会发现每次从X集合跳到Y集合的时候走的是黑边，从Y集合跳到X集合的时候走的是红遍，因为我们的目标节点在Y集合，所以采用匈牙利树的分析方法，黑边总比红边多1，所以可以把这条路径翻转达到我们的目的。

代码:

 #include<bits/stdc++.h>
 using namespace std;

 const int maxm = ,maxn = ;

 struct edge{int from,to,flow;}edges[maxm];
 int num,n,m,arr[maxn];
 vector <int> g[maxn];
 int color[maxn];

 namespace BioGraph{
     vector<int> T[maxn];
     queue<int> Q;
     void pd(){
     for(int i=;i<=n;i++){
         if(arr[i]) continue;
         Q.push(i); arr[i] = ; color[i] = ;
         while(!Q.empty()){
         int k = Q.front(); Q.pop();
         for(int i=;i<T[k].size();i++){
             int z = T[k][i];
             if(arr[z]) continue;
             Q.push(z); color[z] = (color[k]^); arr[z] = ;
         }
         }
     }
     }
 }
 namespace SCC{
     int dfn[maxn],low[maxn],scc[maxn],sccnum,cl;
     stack<int> sta;
     void Tarjan(int now){
     low[now] = dfn[now] = ++cl;
     sta.push(now);
     for(int i=;i<g[now].size();i++){
         if(edges[g[now][i]].flow == ) continue;
         int to = edges[g[now][i]].to;
         if(arr[to]) continue;
         if(dfn[to]) low[now] = min(low[now],dfn[to]);
         else{Tarjan(to);low[now] = min(low[now],low[to]);}
     }
     if(low[now]==dfn[now]){
         sccnum++;
         while(true){
         int pi = sta.top(); sta.pop();
         arr[pi] = ; scc[pi] = sccnum;
         if(now == pi) break;
         }
     }
     }
 }

 void AddEdge(int x,int y,int v){
     edges[num++] = (edge){x,y,v};
     edges[num++] = (edge){y,x,};
     g[x].push_back(num-);
     g[y].push_back(num-);
 }

 int dis[maxn],cur[maxn];
 queue<int> qq;
 int BFS(){
     qq.push(); memset(dis,-,sizeof(dis)); dis[] = ;
     while(!qq.empty()){
     int k = qq.front(); qq.pop();
     for(int i=;i<g[k].size();i++){
         edge sm = edges[g[k][i]];
         if(sm.flow && dis[sm.to]== -){
         dis[sm.to] = dis[k]+;
         qq.push(sm.to);
         }
     }
     }
     return dis[n+];
 }

 int dfs(int x,int a){
     if(x == n+ || a == ) return a;
     int flow = ,f;
     for(int &i=cur[x];i<g[x].size();i++){
     edge &xx = edges[g[x][i]];
     if(dis[xx.to]>dis[x]&&(f=dfs(xx.to,min(a,xx.flow)))){
         xx.flow -= f;
         flow += f;
         a -= f;
         edges[g[x][i]^].flow+=f;
         if(a == ) return flow;
     }
     }
     return flow;
 }

 void read(){
     scanf("%d%d",&n,&m);
     for(int i=;i<=m;i++){
     int x,y; scanf("%d%d",&x,&y);
     BioGraph::T[x].push_back(y);
     BioGraph::T[y].push_back(x);
     }
     BioGraph::pd();
     for(int i=;i<=n;i++){
     if(color[i]) {AddEdge(i,n+,);continue;}
     else AddEdge(,i,);
     for(int j=;j<BioGraph::T[i].size();j++){
         int z = BioGraph::T[i][j];
         AddEdge(i,z,);
     }
     }
 }

 vector<pair<int,int> > res;
 void work(){
     int flow = ;
     while(BFS() != -){
     memset(cur,,sizeof(cur));
     flow += dfs(,);
     }
     memset(arr,,sizeof(arr));
     for(int i=;i<=n+;i++){
     if(arr[i]) continue;
     SCC::Tarjan(i);
     }
     for(int i=;i<num;i++){
     if(edges[i].from ==  || edges[i].to == n+) continue;
     if(edges[i].from == n+ || edges[i].to == ) continue;
     if(color[edges[i].from]) continue;
     if(edges[i].flow) continue;
     if(SCC::scc[edges[i].from] == SCC::scc[edges[i].to]) continue;
     int x=min(edges[i].from,edges[i].to),y=max(edges[i].from,edges[i].to);
     res.push_back(make_pair(x,y));
     }
     sort(res.begin(),res.end());
     int z = res.size(); printf("%d\n",z);
     for(int i=;i<z;i++){ printf("%d %d\n",res[i].first,res[i].second); }
 }

 int main(){
     read();
     work();
     return ;
 }