标签：
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3602
The administration of a well-known football team has made a study about the lack of support in
international away games. This study has concluded that the only reason for this lack of support is
the di?culty in organizing the travel arrangements. To help solving this problem, the administration
has asked you to build a program that computes the maximum number of people that can ?y from
a departure city to a destination city, using the available places in regular ?ights in a given day, and
arriving at or before a given time. When traveling from one city to another, a person may make multiple
transfers. Each transfer is, at least, 30 minutes long, i.e., the departure time should be, at least 30
minutes after the arrival time. Given a set of ?ights for a single day and the latest arrival time, your
program should compute the maximum number of persons that can ?y, directly or indirectly, from a
departure city to a destination city, arriving at or before the latest arrival time.
The input will contain several test cases, each of them as described below. Consecutive
test cases are separated by a single blank line.
The ?rst line contains an integer (smaller or equal to 150) indicating the number of cities that have
?ight connections. The second line contains a string indicating the city of departure. The third line
contains a string indicating the destination city. The fourth line contains the latest arrival time, in the
format HHMM, where HH is the hour in the day (from 00 to 23) and MM is the minute in the hour
(from 00 to 59). The ?fth line contains an integer N (smaller or equal to 5000), with the number of
existing ?ights. Each of the following N lines contains the info for each ?ight. Each such line contains
two strings and three integers, separated by blank spaces, O E C D A, where O and E are, respectively,
the origin and destination of a ?ight, C is the number of available places in the ?ight (from 0 to 300),
and D and A are the departure and arrival times in the previously de?ned format HHMM. All ?ights
start and end in the same day. City names may have up to 8 characters.
Output
For each test case, the output must follow the description below.
The output consists of one single line with an integer stating the maximum number of people that
can ?y from the origin to the destination city, using the given ?ights and arriving at or before the given
latest arrival time.
4
lisbon
berlin
1500
9
lisbon london 6 1000 1100
london lisbon 6 1130 1230
lisbon paris 5 1000 1100
paris lisbon 4 1130 1230
london paris 1 1130 1300
london berlin 2 1340 1510
berlin london 2 1300 1430
paris berlin 10 1330 1500
berlin paris 9 1300 1430
6
题目大概说有n个城市和m条航线，每条航线都是从某一时刻某一城市出发在某一时刻到达某一城市，且各条航线都有最多人数的限制。现在已知出发城市和目的地城市以及一个最终的时刻，问最多有多少人能在最终时刻前到达目的地。
这题自然会去想把城市看成点，航线看成边。这样的话城市需要按照时间拆点24*60*100=144000，太多了。。然而事实上有连边的点最多只会有2*m个，即10000个，其他10多W都是摆设，所以其实也OK吧。
这题的正解是：
其实，这个解法也能看成是把城市按时间拆点并离散化。
不过没想到真的是10000个点去跑网络流。。另外，思维不要局限，图中的点和边可以是各种东西。。要大胆建图跑网络流。。
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
using namespace std;
#define INF (1<<30)
#define MAXN 11111
#define MAXM 2222222
struct Edge{
int v,cap,flow,next;
}edge[MAXM];
int vs,vt,NE,NV;
int head[MAXN];
void addEdge(int u,int v,int cap){
edge[NE].v=v; edge[NE].cap=cap; edge[NE].flow=0;
edge[NE].next=head[u]; head[u]=NE++;
edge[NE].v=u; edge[NE].cap=0; edge[NE].flow=0;
edge[NE].next=head[v]; head[v]=NE++;
}
int level[MAXN];
int gap[MAXN];
void bfs(){
memset(level,-1,sizeof(level));
memset(gap,0,sizeof(gap));
level[vt]=0;
gap[level[vt]]++;
queue<int> que;
que.push(vt);
while(!que.empty()){
int u=que.front(); que.pop();
for(int i=head[u]; i!=-1; i=edge[i].next){
int v=edge[i].v;
if(level[v]!=-1) continue;
level[v]=level[u]+1;
gap[level[v]]++;
que.push(v);
}
}
}
int pre[MAXN];
int cur[MAXN];
int ISAP(){
bfs();
memset(pre,-1,sizeof(pre));
memcpy(cur,head,sizeof(head));
int u=pre[vs]=vs,flow=0,aug=INF;
gap[0]=NV;
while(level[vs]<NV){
bool flag=false;
for(int &i=cur[u]; i!=-1; i=edge[i].next){
int v=edge[i].v;
if(edge[i].cap!=edge[i].flow && level[u]==level[v]+1){
flag=true;
pre[v]=u;
u=v;
//aug=(aug==-1?edge[i].cap:min(aug,edge[i].cap));
aug=min(aug,edge[i].cap-edge[i].flow);
if(v==vt){
flow+=aug;
for(u=pre[v]; v!=vs; v=u,u=pre[u]){
edge[cur[u]].flow+=aug;
edge[cur[u]^1].flow-=aug;
}
//aug=-1;
aug=INF;
}
break;
}
}
if(flag) continue;
int minlevel=NV;
for(int i=head[u]; i!=-1; i=edge[i].next){
int v=edge[i].v;
if(edge[i].cap!=edge[i].flow && level[v]<minlevel){
minlevel=level[v];
cur[u]=i;
}
}
if(--gap[level[u]]==0) break;
level[u]=minlevel+1;
gap[level[u]]++;
u=pre[u];
}
return flow;
}
int covert_time(int t){
return t/100*60+t%100;
}
string city[111];
string from[5555],to[5555];
int cap[5555],s[5555],t[5555];
int main(){
int n,m;
while(cin>>n){
string s_city,t_city;
cin>>s_city>>t_city;
int deadline; cin>>deadline;
deadline=covert_time(deadline);
cin>>m;
for(int i=1; i<=m; ++i){
cin>>from[i]>>to[i]>>cap[i]>>s[i]>>t[i];
s[i]=covert_time(s[i]);
t[i]=covert_time(t[i]);
}
vs=0; vt=m*2+1; NV=vt+1; NE=0;
memset(head,-1,sizeof(head));
for(int i=1; i<=m; ++i){
if(from[i]==s_city) addEdge(vs,i,INF);
if(to[i]==t_city && t[i]<=deadline) addEdge(i+m,vt,INF);
addEdge(i,i+m,cap[i]);
}
for(int i=1; i<=m; ++i){
for(int j=1; j<=m; ++j){
if(i==j) continue;
if(to[i]==from[j] && t[i]+30<=s[j]) addEdge(i+m,j,INF);
}
}
printf("%d\n",ISAP());
}
return 0;
}
UVa1161 Objective: Berlin（最大流）
标签：
原文地址：http://www.cnblogs.com/WABoss/p/5742504.html
