hdu 4240(最大流+最大流量的路)

Route Redundancy

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 625 Accepted Submission(s): 367


[align=left]Problem Description[/align]
A
city is made up exclusively of one-way steets.each street in the city
has a capacity,which is the minimum of the capcities of the streets
along that route.

The redundancy ratio from point A to point B is
the ratio of the maximum number of cars that can get from point A to
point B in an hour using all routes simultaneously,to the maximum number
of cars thar can get from point A to point B in an hour using one
route.The minimum redundancy ratio is the number of capacity of the
single route with the laegest capacity.

[align=left]Input[/align]
The
first line of input contains asingle integer P,(1<=P<=1000),which
is the number of data sets that follow.Each data set consists of
several lines and represents a directed graph with positive integer
weights.

The first line of each data set contains five apace
separatde integers.The first integer,D is the data set number. The
second integer,N(2<=N<=1000),is the number of nodes inthe graph.
The thied integer,E,(E>=1),is the number of edges in the graph. The
fourth integer,A,(0<=A<N),is the index of point A.The fifth
integer,B,(o<=B<N,A!=B),is the index of point B.

The
remaining E lines desceibe each edge. Each line contains three space
separated in tegers.The First integer,U(0<=U<N),is the index of
node U. The second integer,V(0<=v<N,V!=U),is the node V.The third
integer,W (1<=W<=1000),is th capacity (weight) of path from U to
V.

[align=left]Output[/align]
For
each data set there is one line of output.It contains the date set
number(N) follow by a single space, followed by a floating-point value
which is the minimum redundancy ratio to 3 digits after the decimal
point.

[align=left]Sample Input[/align]

1
1 7 11 0 6
0 1 3
0 3 3
1 2 4
2 0 3
2 3 1
2 4 2
3 4 2
3 5 6
4 1 1
4 6 1
5 6 9

[align=left]Sample Output[/align]

1 1.667

题意:求解 最大流 / 图里面最大流量的那一条路 是多少??
http://www.cnblogs.com/yezekun/p/3925768.html正确题解提供者。
题解:此题正确解法不是在dfs时找增广路时更新,那样的话会出两个问题.所以需要先要预处理出最大流量的那条路.然后再求最大流。这样才是正确的。

#include<iostream>
#include<cstdio>
#include<cstring>
#include <algorithm>
#include <math.h>
#include <queue>
using namespace std;
const int N = 1005;
const int INF = 999999999;
struct Edge{
int v,w,next;
}edge[N*N];
int head
;
int level
;
int tot,max_increase;
void init()
{
memset(head,-1,sizeof(head));
tot=0;
}
void addEdge(int u,int v,int w,int &k)
{
edge[k].v = v,edge[k].w=w,edge[k].next=head[u],head[u]=k++;
edge[k].v = u,edge[k].w=0,edge[k].next=head[v],head[v]=k++;
}
int BFS(int src,int des)
{
queue<int>q;
memset(level,0,sizeof(level));
level[src]=1;
q.push(src);
while(!q.empty())
{
int u = q.front();
q.pop();
if(u==des) return 1;
for(int k = head[u]; k!=-1; k=edge[k].next)
{
int v = edge[k].v;
int w = edge[k].w;
if(level[v]==0&&w!=0)
{
level[v]=level[u]+1;
q.push(v);
}
}
}
return -1;
}
int dfs(int u,int des,int increaseRoad){
if(u==des||increaseRoad==0) {
return increaseRoad;
}
int ret=0;
for(int k=head[u];k!=-1;k=edge[k].next){
int v = edge[k].v,w=edge[k].w;
if(level[v]==level[u]+1&&w!=0){
int MIN = min(increaseRoad-ret,w);
w = dfs(v,des,MIN);
if(w > 0)
{
edge[k].w -=w;
edge[k^1].w+=w;
ret+=w;
if(ret==increaseRoad){
return ret;
}
}
else level[v] = -1;
if(increaseRoad==0) break;
}
}
if(ret==0) level[u]=-1;
return ret;
}
int Dinic(int src,int des)
{
int ans = 0;
while(BFS(src,des)!=-1) ans+=dfs(src,des,INF);
return ans;
}
int d,n,m,src,des;
bool vis
;
void dfs1(int u,int ans){
if(u==des){
max_increase = max(max_increase,ans);
return ;
}
for(int k=head[u];k!=-1;k=edge[k].next){
int v = edge[k].v,w = edge[k].w;
if(!vis[v]){
vis[v] = true;
dfs1(v,min(w,ans)); ///最大流量由最小容量边决定
vis[v] = false;
}
}
}
int main()
{
int tcase;
scanf("%d",&tcase);
while(tcase--){
init();
max_increase = -1;
scanf("%d%d%d%d%d",&d,&n,&m,&src,&des);
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
addEdge(u,v,w,tot);
}
memset(vis,false,sizeof(vis));
dfs1(src,99999999); ///deal
int max_flow = Dinic(src,des);
printf("%d %.3lf\n",d,max_flow*1.0/max_increase);
}
return 0;
}