题目链接

floyd+最大流+二分答案

题目类似 POJ 2112

建图：
和 POJ 2112 不同的是，建图要多加F个虚点。
源点和F个点连一条边，容量为牛的初始数量，每一个点i和自己对应的虚点F+i连一条容量为INF的边(容量表示的是牛能通过的数量)，虚点F+i与汇点 2*F+1 连一条边，容量为避雨容量。

floyd求出任意两点之间的最短路，通过两点之间的最短路是否小于或者等于枚举的时间建边
如果u和v满足条件，那么给点u和v的虚点F+v建边。
1F之间的点与虚点F+1F+F之间通过二分枚举的时间判断是否连边，容量为INF。

为什么需要虚点？
假设我们不设置虚点，按照题目给的样例建图。
那么假设二分枚举的时间为 70, 实际点1到点3需要消耗的时间应该是 40+70 = 110，但是在跑最大流的时候，即使1和3没有设置边，但是点1的牛却可以间接通过点2流向点3，最终会得到一个70的答案，显然这个答案是错误的。
所以我们需要设置一个虚点，防止这种间接流动的可能。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int Maxn = 500+10;
const int INF = 0x3f3f3f3f;
const long long LINF = 1e18;

struct Edge {
    int v, cap, flow, next;
} edge[Maxn*Maxn*2];

int h[Maxn], edge_cnt;
int indx[Maxn], deep[Maxn], qu[Maxn];
int c1[Maxn], c2[Maxn], sum;
ll G[Maxn][Maxn];

void add(int u, int v, int c) {
    edge[edge_cnt].v = v;
    edge[edge_cnt].cap = c;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[u];
    h[u] = edge_cnt++;

    edge[edge_cnt].v = u;
    edge[edge_cnt].cap = 0;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[v];
    h[v] = edge_cnt++;
}

bool bfs(int s, int t) {
    int head = 0, tail = 0;
    memset(deep, 0, sizeof(deep));
    deep[s] = 1; qu[tail++] = s;
    while(head < tail) {
        int u = qu[head++];
        for(int i = h[u]; i != -2; i = edge[i].next) {
            Edge &e = edge[i];
            if(deep[e.v] == 0 && e.cap-e.flow > 0) {
                deep[e.v] = deep[u]+1;
                qu[tail++] = e.v;
            }
        }
    }
    if(deep[t] > 0) return true;
    else return false;
}

int dfs(int cur, int t, int a) {
    if(cur == t || a == 0) return a;
    int flow = 0, f;
    if(indx[cur] == -1) indx[cur] = h[cur];
    for(int &i = indx[cur]; i != -2; i = edge[i].next) {
        Edge &e = edge[i];
        if(deep[e.v] == deep[cur]+1) {
            f = dfs(e.v, t, min(a, e.cap-e.flow));
            if(f > 0) {
                e.flow += f;
                edge[i^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
    }
    return flow;
}

int dinic(int s, int t) {
    int ans = 0;
    while(bfs(s, t)) {
        memset(indx, -1, sizeof(indx));
        ans += dfs(s, t, INF);
    }
    return ans;
}

void floyd(int n) {
    for(int k = 1; k <= n; ++k) {
        for(int i = 1; i <= n; ++i) {
            if(i == k) continue;
            for(int j = 1; j <= n; ++j) {
                if(j == k || i == j) continue;
                if(G[i][k] != LINF && G[k][j] != LINF) {
                    G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
                }
            }
        }
    }
}

bool ok(ll t, int F) {
    for(int i = 0; i <= 2*F+1; ++i) h[i] = -2;
    edge_cnt = 0;
    for(int i = 1; i <= F; ++i) {
        add(0, i, c1[i]);
        add(i, F+i, INF);
        add(F+i, 2*F+1, c2[i]);
    }
    for(int u = 1; u <= F; ++u) {
        for(int v = 1; v <= F; ++v) {
            if(u == v) continue;
            if(G[u][v] <= t) {
                add(u, F+v, INF);
            }
        }
    }
    if(dinic(0, 2*F+1) == sum) return true;
    else return false;
}

int main(void)
{
	int F, P;
	scanf("%d%d", &F, &P);
	for(int i = 0; i <= F+1; ++i) {
        for(int j = 0; j <= F+1; ++j) G[i][j] = LINF;
	}
	sum = 0;
	for(int i = 1; i <= F; ++i) {
        scanf("%d%d", &c1[i], &c2[i]);
        sum += c1[i];
	}
	int u, v, c;
	for(int i = 1; i <= P; ++i) {
        scanf("%d%d%d", &u, &v, &c);
        G[u][v] = G[v][u] = min(G[u][v], (ll)c);
	}
	floyd(F);

	ll L = 0, R = LINF, mid;
	while(L < R) {
        mid = (L+R)/2;
        if(ok(mid, F)) R = mid;
        else L = mid+1;
	}
	if(R == LINF) printf("-1\n");
	else printf("%lld\n", R);
	return 0;
}