HAOI2017 新型城市化 二分图的最大独立集+最大流+强连通缩点

题目链接（洛谷）：https://www.luogu.org/problemnew/show/P3731

题意概述：给出一张二分图，询问删掉哪些边之后可以使这张二分图的最大独立集变大。N<=10000,0<=M<=min (150000,N(N-1)/2).

这个题首先你得总结出题意就是这个样子不然就是凉的。。。。。

二分图的最大独立集，可以想到网络流完成（定理：二分图的最大独立集=二分图点数-二分图最大匹配）。当最小割边小的时候独立集就变大了，因此问题变删掉哪些边可以让最小割变小。

这个问题就有经典的做法：先求出最小割，然后在残量网络上面跑tarjan强连通缩点，考察所有的满流的边，如果一条边满流并且两个端点不在同一个强连通分量中，那么这条边就存在与某个最小割中，删掉之后就相当于没有花代价把这条边割掉了，使得最小割变小（最大流变大）。

简单证明：

必要性：首先某一条边如果不满流，那么一定不是最小割中的边；如果一条满流边的反向边（它包含在残量网络中）在某个强连通分量中则可以视作给这条边找到了一个退流的方法，使得这条边（原图中）的起点处的流量可以绕过这条边到达这条边的终点。由于最小割是割掉之后源点汇点无法流通，这条边也显然不在最小割中。

充分性：当一条边满流并且反向边不在一个残量网络的强连通分量中的时候，这条边可能在最小割中，又由于这条边的反向边不在强连通分量中，我们没有办法找到一种方案使得这条边上的流量退去之后源点到汇点的流量不变。因此这条边一定在某个最小割之中，当这条边割掉之后，就相当于采用了这个最小割的方案，最小割变小。

注意一下一开始的建图，现在无向图上跑二分图确定好集合，如果用网络流跑二分图一定要注意连边必须是有向边，不然你会发现无向二分图跑最小流根本就不是匹配的意义。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
using namespace std;
const int MAXN=150005;

int N,M;
struct data{
    int a,b;
    friend bool operator < (data x,data y){
        return x.a<y.a||x.a==y.a&&x.b<y.b;
    }
}D[MAXN]; int ans;
struct graph{
    static const int maxn=10005;
    static const int maxm=150005;
    struct edge{ int to,next; }E[maxm<<1];
    int first[maxn],np,color[maxn];
    graph(){ np=0; }
    void add_edge(int u,int v){
        E[++np]=(edge){v,first[u]};
        first[u]=np;
    }
    void DFS(int i,int c){
        color[i]=3-c;
        for(int p=first[i];p;p=E[p].next){
            int j=E[p].to;
            if(color[j]) continue;
            DFS(j,color[i]);
        }
    }
}gp;
struct NET{
    static const int maxn=10005;
    static const int maxm=150005;
    static const int inf=1e6;
    struct edge{ int from,to,next,cap,flow; }E[(maxm+maxn*2)<<1];
    int S,T,tot,first[maxn],np,cur[maxn],fl[maxn],d[maxn],gap[maxn];
    int dfn[maxn],low[maxn],dfs_clock,sccno[maxn],scc_cnt,stk[maxn],top;
    NET(){ np=dfs_clock=scc_cnt=0; }
    void add_edge(int u,int v,int c){
        E[++np]=(edge){u,v,first[u],c,0};
        first[u]=np;
        E[++np]=(edge){v,u,first[v],0,0};
        first[v]=np;
    }
    void BFS(){
        queue<int>q;
        for(int i=1;i<=tot;i++) d[i]=tot;
        d[T]=0; q.push(T);
        while(!q.empty()){
            int i=q.front(); q.pop();
            for(int p=first[i];p;p=E[p].next){
                int j=E[p].to;
                if(d[j]==tot) d[j]=d[i]+1,q.push(j);
            }
        }
    }
    int augment(){
        int now=T,flow=inf;
        while(now!=S){
            flow=min(flow,E[fl[now]].cap-E[fl[now]].flow);
            now=E[fl[now]].from;
        }
        now=T;
        while(now!=S){
            E[fl[now]].flow+=flow,E[(fl[now]-1^1)+1].flow-=flow;
            now=E[fl[now]].from;
        }
        return flow;
    }
    int ISAP(){
        memcpy(cur,first,sizeof(first));
        BFS();
        for(int i=1;i<=tot;i++) gap[d[i]]++;
        int now=S,flow=0;
        while(d[S]<tot){
            if(now==T) flow+=augment(),now=S;
            bool ok=0;
            for(int p=cur[now];p;p=E[p].next){
                int j=E[p].to;
                if(E[p].cap>E[p].flow&&d[j]+1==d[now]){
                    ok=1,cur[now]=fl[j]=p,now=j;
                    break;
                }
            }
            if(!ok){
                int minl=tot;
                for(int p=first[now];p;p=E[p].next){
                    int j=E[p].to;
                    if(E[p].cap>E[p].flow&&d[j]+1<minl) minl=d[j]+1;
                }
                if(--gap[d[now]]==0) break;
                gap[d[now]=minl]++;
                cur[now]=first[now];
                if(now!=S) now=E[fl[now]].from;
            }
        }
        return flow;
    }
    void tarjan_scc(int i){
        dfn[i]=low[i]=++dfs_clock;
        stk[++top]=i;
        for(int p=first[i];p;p=E[p].next){
            if(E[p].cap==E[p].flow) continue;
            int j=E[p].to;
            if(dfn[j]){
                if(!sccno[j]) low[i]=min(low[i],dfn[j]);
                continue;
            }
            tarjan_scc(j);
            low[i]=min(low[i],low[j]);
        }
        if(low[i]==dfn[i]){
            scc_cnt++;
            while(stk[top]!=i) sccno[stk[top--]]=scc_cnt;
            sccno[stk[top--]]=scc_cnt;
        }
    }
}net;

void data_in()
{
    scanf("%d%d",&N,&M);
    int x,y;
    net.S=N+1,net.T=N+2,net.tot=N+2;
    for(int i=1;i<=M;i++){
        scanf("%d%d",&x,&y);
        gp.add_edge(x,y); gp.add_edge(y,x);
    }
    for(int i=1;i<=N;i++)
        if(!gp.color[i]) gp.DFS(i,2);
    for(int i=1;i<=M*2;i+=2){
        x=gp.E[i].to,y=gp.E[i+1].to;
        if(gp.color[x]==1) net.add_edge(x,y,1);
        else net.add_edge(y,x,1);
    }
    for(int i=1;i<=N;i++){
        if(gp.color[i]==1) net.add_edge(net.S,i,1);
        else net.add_edge(i,net.T,1);
    }
}
void work()
{
    net.ISAP();
    for(int i=1;i<=net.tot;i++)
        if(!net.dfn[i]) net.tarjan_scc(i);
    for(int i=1;i<=2*M;i++){
        if(net.E[i].cap>net.E[i].flow||net.E[i].flow==0) continue;
        int x=net.E[i].from,y=net.E[i].to;
        if(net.sccno[x]!=net.sccno[y])
            D[++ans]=(data){min(x,y),max(x,y)};
    }
    sort(D+1,D+ans+1);
    printf("%d
",ans);
    for(int i=1;i<=ans;i++)
        printf("%d %d
",D[i].a,D[i].b);
}
int main()
{
    data_in();
    work();
    return 0;
}