题意：已知n（n <= 150）个城市和m（m <= 5000）个航班，每个航班有出发地、到达地、乘坐人数、起飞时间和降落时间（时间用时和分表示），求从一个指定城市出发，去往另一个指定城市在规定的最晚时间前（包括最晚时间）可以到达的最大人数（换航班的间隔至少需要30分钟）。
分析：
1、首先最大流模板中是不考虑时间因素的，从一个点分别向不同的方向出发是同时的，所以不能以城市为最大流模板中的顶点。
2、为了考虑时间因素，以航班为顶点，以城市为边，将同一个航班拆成两个点i与i + m（拆点法），则i -> i + m的容量为航班的乘坐人数。（以航班为顶点，忽视了容量，因此要补充。）
3、若两趟航班之间可以转（即第一个航班的降落时间与第二个航班的起飞时间至少相差30分钟），那么就将第一个航班的i + m连到第二个航班的i上去，容量为正无穷。（此处因为不确定容量，但是有同一航班间的容量限制，所以可以设为正无穷）
4、出发城市和到达城市也视为顶点，则：所有出发点为出发城市的航班，将出发城市与该航班的i间建边，所有终点为到达城市的航班，且到达时间在规定最晚时间之前的，将该航班的i + m与到达城市间建边。容量均为正无穷；（可视为城市中可以有很多人上这个航班，因此不确定容量，但是有同一航班间的容量限制，所以可以设为正无穷）
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<iostream>
#include<sstream>
#include<iterator>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<stack>
#include<deque>
#include<queue>
#include<list>
#define Min(a, b) a < b ? a : b
#define Max(a, b) a < b ? b : a
typedef long long ll;
typedef unsigned long long llu;
const int INT_INF = 0x3f3f3f3f;
const int INT_M_INF = 0x7f7f7f7f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const ll LL_M_INF = 0x7f7f7f7f7f7f7f7f;
const int dr[] = {, , -, };
const int dc[] = {-, , , };
const double pi = acos(-1.0);
const double eps = 1e-;
const int MAXN = + ;
const int MAXT = + ;
using namespace std;
struct Edge{
int from, to, cap, flow;
Edge(int f, int t, int c, int fl):from(f), to(t), cap(c), flow(fl){}
};
struct Dinic{
int n, m, s, t;
vector<Edge> edges;
vector<int> G[MAXN];
bool vis[MAXN];
int d[MAXN];
int cur[MAXN];
void init(int w){//d数组可以不初始化
edges.clear();
for(int i = ; i < w; ++i) G[i].clear();
}
void AddEdge(int from, int to, int cap){
edges.push_back(Edge(from, to, cap, ));
edges.push_back(Edge(to, from, , ));
m = edges.size();
G[from].push_back(m - );
G[to].push_back(m - );
}
bool BFS(){
memset(vis, false, sizeof vis);
queue<int> Q;
Q.push(s);
d[s] = ;
vis[s] = ;
while(!Q.empty()){
int x = Q.front(); Q.pop();
for(int i = ; i < G[x].size(); ++i){
Edge& e = edges[G[x][i]];
if(!vis[e.to] && e.cap > e.flow){
vis[e.to] = true;
d[e.to] = d[x] + ;
Q.push(e.to);
}
}
}
return vis[t];
}
int DFS(int x, int a){
if(x == t || a == ) return a;
int flow = , f;
for(int& i = cur[x]; i < G[x].size(); ++i){
Edge& e = edges[G[x][i]];
if(d[x] + == d[e.to] && (f = DFS(e.to, Min(a, e.cap - e.flow))) > ){
e.flow += f;
edges[G[x][i] ^ ].flow -= f;
flow += f;
a -= f;
if(a == ) break;
}
}
return flow;
}
int Maxflow(int s, int t){
this -> s = s;
this -> t = t;
int flow = ;
while(BFS()){
memset(cur, , sizeof cur);
flow += DFS(s, INT_INF);
}
return flow;
}
}di;//#
map<string, int> ma;
int id;
int get_id(string x){
if(!ma.count(x)) return ma[x] = id++;//加return更快
return ma[x];//#ma.count()
}
int get_time(char s[]){
return ((s[] - '') * + s[] - '') * + (s[] - '') * + s[] - '';
}
struct Node{
int aid, bid, c, atime, btime;
}num[MAXN];
int main(){
int n;
while(scanf("%d", &n) == )
{
ma.clear();
id = ;
char st[], en[];
scanf("%s%s", st, en);
int stid = get_id(st);//string对char*的构造函数
int enid = get_id(en);
scanf("%s", st);
int m;
scanf("%d", &m);
int t = get_time(st);
int cnt = ;
for(int i = ; i <= m; ++i){
scanf("%s%s", st, en);
num[i].aid = get_id(st);
num[i].bid = get_id(en);
scanf("%d%s%s", &num[i].c, st, en);
num[i].atime = get_time(st);
num[i].btime = get_time(en);
}
di.init( * m + );
for(int i = ; i <= m; ++i){
di.AddEdge(i, i + m, num[i].c);//每个航班拆成两个点，i和i+m
if(num[i].aid == stid) di.AddEdge(, i, INT_INF);//源点和汇点也看做点，标号为0和2*m+1
if(num[i].bid == enid && num[i].btime <= t) di.AddEdge(i + m, * m + , INT_INF);
for(int j = ; j <= m; ++j){
if(i == j) continue;
if(num[i].bid == num[j].aid && num[j].atime - num[i].btime >= ){
di.AddEdge(i + m, j, INT_INF);//i+m
}
}
}
printf("%d\n", di.Maxflow(, * m + ));
}
return ;
}