bzoj 1191: [HNOI2006]超级英雄Hero 网络流 + 残量网络

题目描述： 

现在电视台有一种节目叫做超级英雄,大概的流程就是每位选手到台上回答主持人的几个问题,然后根据回答问题的

多少获得不同数目的奖品或奖金。主持人问题准备了若干道题目，只有当选手正确回答一道题后，才能进入下一题

，否则就被淘汰。为了增加节目的趣味性并适当降低难度，主持人总提供给选手几个“锦囊妙计”，比如求助现场

观众，或者去掉若干个错误答案（选择题）等等。这里，我们把规则稍微改变一下。假设主持人总共有m道题，选

手有n种不同的“锦囊妙计”。主持人规定，每道题都可以从两种“锦囊妙计”中选择一种，而每种“锦囊妙计”

只能用一次。我们又假设一道题使用了它允许的锦囊妙计后，就一定能正确回答，顺利进入下一题。现在我来到了

节目现场，可是我实在是太笨了，以至于一道题也不会做，每道题只好借助使用“锦囊妙计”来通过。如果我事先

就知道了每道题能够使用哪两种“锦囊妙计”，那么你能告诉我怎样选择才能通过最多的题数吗？

 

 

题解： 

 

首先，二分肯定是可以的.

不过，我们用残量网络做更优美一些.

依次枚举每一个人，并将该人对应的边都连上.

如果每次在残量网络上都能增广出一个流量，那么就说明新加入的是可以的.

为什么在残量网络上跑是正确的呢 ？ 

我们关注这个函数： 

int maxflow(){         
     memset(current,0,sizeof(current));            
     int ans=0; 
     while(BFS()) ans+=dfs(st,inf); 
     return ans; 
}    

这意味着，Dinic 求最大流过程中每次都是试图从起点向终点找出一条增广路. 

而每次增广出的流量是可以累加的. 

所以，在新增的残量网络上求出的流量也就可以和先前的流量累加了，互不干扰. 

最后，一定特判一下重边的情况！！！

Code:

// luogu-judger-enable-o2
// luogu-judger-enable-o2
// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include<bits/stdc++.h>
#define maxn 100000 
#define inf 20000 
#define setIO(s) freopen(s".in","r",stdin) 
#define nex 1303 
using namespace std; 
int A[maxn],B[maxn]; 
namespace Dinic{
    int st,ed;           
    struct Edge{
        int from,to,cap; 
        Edge(int u,int v,int c):from(u),to(v),cap(c){}; 
    }; 
    vector<Edge>edges; 
    vector<int>G[maxn];
    void add(int u,int v,int c){
        edges.push_back(Edge(u,v,c)); 
        edges.push_back(Edge(v,u,0)); 
        int m=edges.size(); 
        G[u].push_back(m-2); 
        G[v].push_back(m-1); 
    } 
    int d[maxn],vis[maxn],current[maxn]; 
    queue<int>Q;          
    int BFS(){
        memset(vis,0,sizeof(vis)); 
        d[st]=0,vis[st]=1; Q.push(st);
        while(!Q.empty()) { 
            int u=Q.front(); Q.pop();       
            int sz=G[u].size();         
            for(int i=0;i<sz;++i){ 
                Edge r = edges[G[u][i]]; 
                if(r.cap>0 && !vis[r.to]) {
                    vis[r.to]=1,d[r.to]=d[u]+1; 
                    Q.push(r.to); 
                } 
            }
        }
        return vis[ed]; 
    } 
    int dfs(int x,int cur){
        if(x==ed) return cur; 
        int f,flow=0; 
        for(int v=G[x].size(),i=current[x];i<v;++i){
            current[x]=i;  
            Edge r = edges[G[x][i]]; 
            if(r.cap>0 && d[r.to]==d[x]+1) {
                f=dfs(r.to,min(cur,r.cap)); 
                cur-=f,flow+=f;
                edges[G[x][i]].cap-=f,edges[G[x][i]^1].cap+=f; 
            }
            if(cur==0) break; 
        }
        return flow; 
    }
    int maxflow(){         
        memset(current,0,sizeof(current));            
        int ans=0; 
        while(BFS()) ans+=dfs(st,1); 
        return ans; 
    }
    void re(){
        edges.clear(); 
        for(int i=0;i<maxn;++i) G[i].clear();
        memset(current,0,sizeof(current)); 
        memset(d,0,sizeof(d)); 
        memset(vis,0,sizeof(vis));  
    } 
};
int C[maxn],D[maxn]; 
int check[maxn]; 
int main(){
    // setIO("input");
    int n,m; 
    scanf("%d%d",&n,&m);  
    int ans=0; 
    Dinic::st=0,Dinic::ed=3000;       
    for(int i=1;i<=m;++i) Dinic::add(0,i,1); 
    for(int i=0;i<n;++i) Dinic::add(i+nex,3000,1);   
    for(int i=1;i<=m;++i){
        scanf("%d%d",&A[i],&B[i]);  
        Dinic::add(i,A[i]+nex,1), C[i]=Dinic::edges.size()-2; 
        if(A[i]!=B[i]) Dinic::add(i,B[i]+nex,1); 
        if(Dinic::maxflow()<1) break; 
        ans=i;          
    }                        
     printf("%d
",ans); 
    for(int i=1;i<=ans;++i) {
        if(Dinic::edges[C[i]].cap==0) printf("%d
",A[i]);
        else printf("%d
",B[i]); 
    }
     
    return 0;  
}