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\n",ans);
for(int i=1;i<=ans;++i) {
if(Dinic::edges[C[i]].cap==0) printf("%d\n",A[i]);
else printf("%d\n",B[i]);
}
return 0;
}
