POJ 2391 思维建图 + dinic + 二分

和POJ 2112的思路差不多，看见求最大时间的最小值，就是二分算法。然后每个点都有容量，就是拆点建边，自己加个源点和汇点，把每个避雨场拆成两个点，然后连有向图。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;

const int maxv = 410;
const int maxe = 320010;
const long long INF_LL=1e16;
const int INF_INT=0x3f3f3f3f;

int n, m, src, dst, sum;
long long w[maxv], c[maxv], mmap[maxv][maxv];

/*******************Dinic模板**********************/
struct Edge {//因为有的时候（比如求最小割）外部需要用到遍信息，为了方便，把边放到class外面
    int from, to, cap, flow, next;
} edge[maxe];
int cnt, head[maxv];
void edgeinit() {
    cnt = 0;
    memset(head, -1, sizeof head);
}
void addedge(int from, int to, int cap) {
    edge[cnt].from = from;
    edge[cnt].to = to;
    edge[cnt].cap = cap;
    edge[cnt].next = head[from];
    head[from] = cnt++;
    ;
    edge[cnt].from = to;
    edge[cnt].to = from;
    edge[cnt].cap = 0;
    edge[cnt].next = head[to];
    head[to] = cnt++;
}
/***************上面为建边，下面为Dinic**********************/
class Dinic {
private:
    int s, t, n, depth[maxv], cur[maxe]; //cur为当前狐优化
public:
    void init(int _s, int _t) {//这个模板只需要接受两个参数，一个是源点一个是汇点
        s = _s, t = _t;
    }
    int Dfs(int u, int dist) {
        if (u == t)
            return dist;
        for (int& i = cur[u]; i != -1; i = edge[i].next) {//注意这里的取址符
            if (depth[edge[i].to] == depth[u] + 1 && edge[i].cap != 0) {
                int delta = Dfs(edge[i].to, min(dist, edge[i].cap));
                if (delta > 0) {
                    edge[i].cap -= delta;
                    edge[i ^ 1].cap += delta;
                    return delta;
                }
            }
        }
        return false;
    }
    int Bfs() {
        queue<int> Q;
        memset(depth, 0, sizeof depth);
        depth[s] = 1;
        Q.push(s);
        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            for (int i = head[u]; i != -1; i = edge[i].next) {
                if (edge[i].cap > 0 && depth[edge[i].to] == 0) {
                    depth[edge[i].to] = depth[u] + 1;
                    Q.push(edge[i].to);
                }
            }
        }
        if (depth[t] > 0)
            return true;
        return false;
    }
    int maxFlow() {
        int ans = 0;
        while (Bfs()) {
            for (int i = 0; i < cnt; i++)
                cur[i] = head[i];//cur是当前弧度优化，可以优化dfs的速度，但是dfs完后要初始化
            while (int delta = Dfs(s, INF_INT))
                ans += delta;
        }
        return ans;
    }
} DC;
/*******************Dinic模板**********************/

void init() {
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            mmap[i][j] = INF_LL;
}
void Floyd() {
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (mmap[i][j] > mmap[i][k] + mmap[k][j])
                    mmap[i][j] = mmap[i][k] + mmap[k][j];
}
void buildGraph(long long limit) {
    edgeinit();
    for (int i = 1; i <= n; i++) {
        addedge(src, i, w[i]);
        addedge(i + n, dst, c[i]);
        addedge(i, i + n, INF_INT);
        for (int j = i + 1; j <= n; j++) {
            if (mmap[i][j] <= limit) {
                addedge(i, j + n, INF_INT);
                addedge(j, i + n, INF_INT);
            }
        }
    }
}
void solve() {
    long long ans=-1, l = 0, r = INF_LL - 1;
    while (l <= r) {
        long long m = (l + r) / 2;
        buildGraph(m);
        DC.init(src, dst);
        int maxflow = DC.maxFlow();
        if (maxflow >= sum) {
            ans = m;
            r = m - 1;
        }
        else
            l = m + 1;
    }
    cout << ans << endl;

}
int main(void) {
    while (cin >> n >> m) {
        src = 0, dst = n * 2 + 1, sum = 0;
        for (int i = 1; i <= n; i++) {
            cin >> w[i] >> c[i];
            sum += w[i];
        }
        init();//初始化矩阵
        for (int i = 1; i <= m; i++) {
            int t1, t2, t3;
            cin >> t1 >> t2 >> t3;
            if (t3 < mmap[t1][t2])
                mmap[t2][t1] = mmap[t1][t2] = t3;
        }
        Floyd();
        solve();
    }
    return 0;
}