UVALive 3645 Objective: Berlin (最大流，拆点法）

题目链接：http://vjudge.net/contest/138956#problem/B

       把每条航线看做一个点，因为每条航线涉及两个时间点，所以把每个点拆成两个（u和u'），分别对应较早的和较晚的那个时间，之间连一条弧，容量为该航线的载客量。若航线i可以与航线j相连，则将航线i的u'向航线j的u之间连一条弧，容量为无穷大。并增加源点s和汇点t，由s向每个出发点（u）连一条弧，每个到达点（u'）向t连一条弧，容量均为无穷大。最后求一遍最大流即可。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<map>
using namespace std;
const int maxn = 12000 + 10;
const int INF = 0x3f3f3f3f;
struct Edge {
  int from, to, cap, flow;
  Edge(int u, int v, int c, int f):from(u),to(v),cap(c),flow(f) {}
};
struct Node {
  int u, v;
  int cap, st, ed;
}node[maxn];

struct Dinic {
   int n, m, s, t;
   vector<Edge> edges;
   vector<int> G[maxn];
   bool vis[maxn];
   int d[maxn], cur[maxn];

   void init(int n) {
     for(int i = 0; i <= n; i++) G[i].clear();
     edges.clear();
   }

   void AddEdge(int from, int to, int cap) {
     edges.push_back(Edge(from, to, cap, 0));
     edges.push_back(Edge(to, from, 0, 0));
     m = edges.size();
     G[from].push_back(m-2);
     G[to].push_back(m-1);
   }

   bool BFS() {
     memset(vis, 0, sizeof vis);
     queue<int> Q;
     Q.push(s);
     d[s] = 0;
     vis[s] = 1;
     while(!Q.empty()) {
        int x = Q.front(); Q.pop();
        for(int i = 0; i < G[x].size(); i++) {
           Edge& e = edges[G[x][i]];
           if(!vis[e.to] && e.cap > e.flow) {
              vis[e.to] = 1;
              d[e.to] = d[x] + 1;
              Q.push(e.to);
           }
        }
     }
     return vis[t];
   }

   int DFS(int x, int a) {
      if(x == t || a == 0) return a;
      int flow = 0, f;
      for(int& i = cur[x]; i < G[x].size(); i++) {
         Edge& e = edges[G[x][i]];
         if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(e.to, min(a, e.cap-e.flow)))) > 0) {
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
         }
      }
      return flow;
   }

   int Maxflow(int s, int t) {
     this->s = s; this->t = t;
     int flow = 0;
     while(BFS()) {
        memset(cur, 0, sizeof cur);
        flow += DFS(s, INF);
     }
     return flow;
   }
};

Dinic dinic;
map<string, int> ha;
char str[100];

int ID(char* s)
{
   if (!ha.count(s)) ha[s] = ha.size();
   return ha[s];
}

int TransTime(int t)
{
    return t/100*60+t%100;
}

int main()
{
    int n;
    char str[10];
    while(scanf("%d",&n) == 1) {
        ha.clear();
        int First, End, T;
        scanf("%s", str); First = ID(str);
        scanf("%s", str); End = ID(str);
        scanf("%d", &T); T = TransTime(T);
        int m;
        scanf("%d", &m);
        for(int i = 1; i <= m; i++) {
           scanf("%s", str); node[i].u = ID(str);
           scanf("%s", str); node[i].v = ID(str);
           scanf("%d", &node[i].cap);
           scanf("%d%d", &node[i].st, &node[i].ed);
           node[i].st = TransTime(node[i].st);
           node[i].ed = TransTime(node[i].ed);
        }
        dinic.init(2*m+1);
        //奇数代表到达点，偶数代表出发点
        for(int i = 1; i <= m; i++)
          for(int j = 1; j <= m; j++) {
             if(i == j) {
                dinic.AddEdge(2*i-1, 2*i, node[i].cap);
                if(node[i].u == First) dinic.AddEdge(0, 2*i-1, INF);
                if(node[i].v == End && node[i].ed <= T) dinic.AddEdge(2*i, 2*m+1, INF);
             }
             else if (node[i].v == node[j].u && node[j].st - node[i].ed >= 30)
                dinic.AddEdge(2*i, 2*j-1, INF);
          }
        printf("%d\n", dinic.Maxflow(0,2*m+1));
    }
    return 0;
}