UVA 1161&& UVALive 3645 Objective: Berlin （最大流 -- 时序模型）

大体题意：

给你一些航班，你要从s 城市到t 城市，中间可以倒航班，倒航班的时间不得小于30分钟！  告诉你最晚的到达时间，求最大客流量？

思路：

求最大客流量很明显是求最大流！

然后 加了时间 在赛场上就蒙蔽了！

其实是时序模型！

我们把航班看成一个点，然后拆成i和i + m，这样就考虑了时间的因素！ 表示i 的时间更早一些，i+m 的时间更晚一些！只能由i到i+m  ，容量为飞机上座位数，如果这个航线连接着起点，那么就让i 连接超级源点，容量为inf，如果这个航线连接着 终点，就让i + m 连接者超级终点 ，容量为inf 那么  超级原点和超级终点的最大流就是答案！

因为有反向弧的存在，注意数组大小要合理！

详细见代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <queue>
using namespace std;
const int maxn = 10000 + 7;
const int inf = 0x3f3f3f3f;
int cnt;
map<string,int> mp;
int ID(string s){
    if (!mp.count(s)) return mp[s] = ++cnt;
    return mp[s];
}

struct Edge{
    int from, to, cap, flow;
};

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 nn){
        edges.clear();
        for (int i = 0; i < nn; ++i)G[i].clear();
//        memset(vis,0,sizeof vis);
//        memset(d,0,sizeof d);
//        memset(cur,0,sizeof cur);
    }

    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(a,e.cap-e.flow))) > 0){
                e.flow += f;
                edges[G[x][i]^1 ].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 = 0;
        while(BFS()){
            memset(cur,0,sizeof cur);
            flow += DFS(s,inf);
        }
        return flow;
    }

}dic;
char name1[10],name2[10], t1[10];
int rev(char *s){
    return 60*((s[0]-48) * 10 + s[1] - 48) + 10*(s[2]-48)+s[3]-48;
}
struct Node{
    int u,v,t,t1,t2;

}p[maxn];
int main(){
    int n;
    while(~scanf("%d",&n)){
        cnt = 0;
        mp.clear();
        scanf("%s%s",name1,name2);
        ID(name1); ID(name2);
        scanf("%s",t1);
        int Time = rev(t1);
        int m;
        scanf("%d",&m);
        char Start[10],End[10];
        for (int i = 1; i <= m; ++i){
            scanf("%s%s",Start,End);
            p[i].u = ID(Start);
            p[i].v = ID(End);
            scanf("%d",&p[i].t);
            scanf("%s%s",Start,End);
            p[i].t1 = rev(Start);
            p[i].t2 = rev(End);
        }
        dic.init(2*m+10);
        for (int i = 1; i <= m; ++i){
            dic.AddEdge(i,i+m,p[i].t);
            if (p[i].u == 1){
                dic.AddEdge(0,i,inf);
            }
            if (p[i].v == 2 && p[i].t2 <= Time) dic.AddEdge(i+m,2*m+1,inf);
            for (int j = 1; j <= m; ++j){
                if (p[i].v == p[j].u && p[i].t2 + 30 <= p[j].t1 && i != j){
                    dic.AddEdge(i+m,j,inf);
                }
            }
        }
        printf("%d\n",dic.Maxflow(0,2*m+1));
    }
    return 0;
}
/**
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

**/