cogs426血帆海盗（网络流打法）

　　这道题基本上来就能看的出来是网络流但难点在于它的结果貌似与最大流，最小割都没啥关系，我猜不少萌新像我一样想暴力枚举边（要是考试我就真这么做了），但很明显，出题人没打算让你这么水过，100000的数据不是闹着玩的。因此我们需要更深的思考。

　　不知道有没有人和我一样，想最大流跑一边，然后再统计已匹配上的点，看它是否有能连接的点未被连接。但很容易举出反例，如:

　　　　　　　　　　　　　　2

　　　　　　　　 　　　　　  1 3

　　　　　　　　　　　　　   1 4

　　　　　　　　　　 　　　  2 3

　　　　　　　　　　　          2 4

　　有些边是可以互相替换的，对于这点我们是束手无策了，那么能否通过搜索查证呢？

　　这就是本题的关键了，tarjan大法，直接用tarjan求出强联通分量，若有一些边可互相替换则他们一定在一个强联通分量里（原因留给读者思考）否则就说明该边无可替代，也就是我们要求的解得一部分。

　　在这里膜拜一下呵呵酵母菌神犇，是他告诉我一个“坑”（对我来说），我们所枚举的边一定在求最大流的时候被清算过，因此对于没有出现在最大流中的边需要直接忽略。

 #include<iostream>
 #include<cstdlib>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 int n,m,zz=,a[];
 struct ro{
     bool zr;
     int to,l,next;
     int from;
 }road[];
 void build(int x,int y){
     zz++;
     road[zz].zr=;
     road[zz].to=y;
     road[zz].next=a[x];
     road[zz].from=x;
     road[zz].l=;
     a[x]=zz;
     zz++;
     road[zz].zr=;
     road[zz].to=x;
     road[zz].next=a[y];
     road[zz].from=y;
     road[zz].l=;
     a[y]=zz;
 }
 int s,t;
 int deep[];
 bool bfs(){
     memset(deep,,sizeof(deep));
     deep[s]=;
     queue<int> q1;
     q1.push(s);
     while(!q1.empty())
     {
         int x=q1.front();
         q1.pop();
         for(int i=a[x];i>;i=road[i].next)
         {
             int y=road[i].to;
             if((!deep[y])&&road[i].l>)
             {
                 deep[y]=deep[x]+;
                 q1.push(y);
             }
         }
     }
     if(!deep[t])return ;
     else return ;
 }
 int cur[];
 int dfs(int x,int sum){
     if(x==t||!sum)return sum;
     for(int i=cur[x];i>;i=road[i].next)
     {
         int y=road[i].to;
         cur[x]=i;
         if(road[i].l>&&deep[y]==deep[x]+)
         {
             int k=dfs(y,min(sum,road[i].l));
             if(k)
             {
                 road[i].l-=k;
                 road[i^].l+=k;
                 return k;
             }
         }
     }
     return ;
 }
 int work(){
     int ans=;
     while(bfs())
     {
         int x;
         memcpy(cur,a,sizeof(a));
         while(x=dfs(s,0x7fffffff))
             ans+=x;
     }
     return ans;
 }
 int st[],top,zz3,belong[];
 bool rz[],rz2[];
 int dfn[],low[],zz2;
 void tarjan(int x){
     zz2++;
     dfn[x]=low[x]=zz2;
     rz[x]=rz2[x]=;
     top++;
     st[top]=x;
     for(int i=a[x];i>;i=road[i].next)
     {
         int y=road[i].to;
         if(road[i].l>)
         {
             if(!rz2[y])
             {
                 tarjan(y);
                 low[x]=min(low[x],low[y]);
             }
             else if(rz[y])
             {
                 low[x]=min(low[x],dfn[y]);
             }
         }
     }
     if(low[x]==dfn[x])
     {
         int v;
         zz3++;
         do{
             v=st[top];
             top--;
             belong[v]=zz3;
             rz[v]=;
         }while(dfn[v]!=low[v]);
     }
 }
 int sum;
 int main(){
     freopen("bloodsail.in","r",stdin);
     freopen("bloodsail.out","w",stdout);
     scanf("%d%d",&n,&m);
     t=n+;
     for(int i=;i<=m;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         build(x,y);
     }
     for(int i=;i<=n;i++)
     {
         if(i<=n/) build(s,i);
         else build(i,t);
     }
     int an=work();
     for(int i=;i<=n+;i++)
     {
         if(!rz2[i])
             tarjan(i);
     }
     for(int i=;i<=*m+;i+=)
     {
         if(!road[i].l&&belong[road[i].from]!=belong[road[i].to]) sum++;
     }
     printf("%d\n",sum);
 //    while(1);
     return ;
 }

安利一发，“共荣圈”也是本题。