POJ-2455-无向图网络流

题目大意：给定一张无向图，注意可能两点间可能有重边，一个人从地点1到地点n要有t次，问所有路中的最大值最小是多少；

题目解析：首先重边的话图就不可以用邻接矩阵来表示了，要用邻接表来表示，无向图的加边反向边不需要初始化为0应该和正向边一样（看成一对反向边即可）；最大值的最小值直接二分即可；

AC代码：

#include<iostream>      
#include<cstdio>      
#include<algorithm>      
#include<cstring>      
#include<string>      
#include<vector>      
#include<queue>    
using namespace std;      
const int inf=0x3fffffff;      
const int maxn=4000;      
struct node      
{      
    int to,cap,rev;       
    node(int a,int b,int c)      
    {      
        to=a;      
        cap=b;      
        rev=c;      
    }      
};   
struct edge
{
	int to,cap;
	edge(int a,int b)
	{
		to=a;
		cap=b;
	}
};
vector<node>vec[maxn];   
vector<edge>tor[maxn];     
int pre[maxn],iter[maxn],graph[301][301],n,t;    
bool vis[maxn];    
bool used[301][301];
void add_edge(int from,int to,int cost)      
{      
    vec[from].push_back(node(to,cost,vec[to].size()));      
    vec[to].push_back(node(from,cost,vec[from].size()-1));      
}      
void bfs(int s){      
    memset(pre,-1,sizeof(pre));      
    queue<int>que;      
    pre[s]=0;que.push(s);      
    while(!que.empty()){      
        int v=que.front();que.pop();      
        for(int i=0;i<vec[v].size();i++){      
            node &e=vec[v][i];      
            if(e.cap>0&&pre[e.to]<0){      
                pre[e.to]=pre[v]+1;      
                que.push(e.to);      
            }      
        }      
    }      
}      
int dfs(int v,int t,int f){      
    if(v==t) return f;      
    for(int &i=iter[v];i<vec[v].size();i++){      
        node &e=vec[v][i];      
        if(e.cap>0&&pre[v]<pre[e.to]){      
            int d=dfs(e.to,t,min(f,e.cap));      
            if(d>0){      
                e.cap-=d;      
                vec[e.to][e.rev].cap+=d;      
                return d;      
            }      
        }      
    }      
    return 0;      
}      
int max_flow(int u,int v)      
{      
    int flow=0;      
    while(1)          
    {      
        bfs(u);    
        if(pre[v]<0)    return flow;    
        memset(iter,0,sizeof(iter));      
        int f;      
        while((f=dfs(u,v,inf))>0) flow+=f;      
    }      
}     
bool ok(int pos)  
{  
    int i,j;  
    for(i=0;i<maxn;i++)    
        vec[i].clear(); 
	add_edge(0,1,t); 
	memset(used,0,sizeof(used));
    for(i=1;i<=n;i++)
    {
    	for(j=0;j<tor[i].size();j++)
    	{
    		if(tor[i][j].cap<=pos)
	    	add_edge(i,tor[i][j].to,1);
	    }
    }
    if(max_flow(0,n)>=t)    return 1;  
    else return 0;  
}  
int main()  
{  
	int p,i,j;
	while(scanf("%d%d%d",&n,&p,&t)!=EOF)
	{
		for(i=0;i<maxn;i++)
			vec[i].clear();
		for(i=0;i<maxn;i++)
			tor[i].clear();
		memset(graph,-1,sizeof(graph));
		int l=0,r=-1;
		for(i=1;i<=p;i++)
		{
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			tor[u].push_back(edge(v,w));
			r=max(w,r);	
		}
		int ans;
		while(l<=r)
		{
			int m=(l+r)>>1;
			if(!ok(m))
			{
				l=m+1;
			}
			else 
			{
				r=m-1;
				ans=m;
			}
		}
		printf("%d\n",ans);
	} 
    return 0;  
}