题意:给你n个地区 每个地区有两个值 分别是下雨前能容纳的人数和下雨后能容纳的人数 再给你m条边 代表两个地区有一条无向路 问你下雨后该怎么走才能使每个地区不超负荷且总用时最少
思路:对于每一个点有两个状态 于是我们可以将每一个点拆点 表示这两个状态 将源点与每一个点连边 容量为下雨前能容纳的人数 将拆完后的点与汇点连边 容量为下雨后能容纳的人数 然后二分总时间 之前先用floyed预处理出任意两点间的最小时间 如果连点之间的时间小于等于二分时间 则将这两个点连边 容量为inf 判断最大流即可
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define REP( i, a, b ) for( int i = a; i < b; i++ )
#define FOR( i, a, b ) for( int i = a; i <= b; i++ )
#define CLR( a, x ) memset( a, x, sizeof a )
#define CPY( a, x ) memcpy( a, x, sizeof a )
#define BUG puts( "*****BUG****" )
typedef long long LL;
const int maxn = 500 + 10;
const int maxe = 100000 + 10;
const LL INF = 1LL<<45;
const int inf = 1e9;
struct Edge{
int v, c, f;
int next;
Edge() {}
Edge(int v, int c, int f, int next) : v(v), c(c), f(f), next(next) {}
};
struct ISAP{
int n, s, t;
int num[maxn], cur[maxn], d[maxn], p[maxn];
int Head[maxn], cntE;
int Q[maxn], head, tail;
Edge edge[maxe];
void Init(int n){
this -> n = n;
cntE = 0;
CLR(Head, -1);
}
void Add(int u, int v, int c){
edge[cntE] = Edge(v, c, 0, Head[u]);
Head[u] = cntE++;
edge[cntE] = Edge(u, 0, 0, Head[v]);
Head[v] = cntE++;
}
void Bfs(){
CLR(d, -1);
CLR(num, 0);
d[t] = 0;
head = tail = 0;
Q[tail++] = t;
num[0] = 1;
while(head != tail){
int u = Q[head++];
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(~d[e.v]) continue;
d[e.v] = d[u] + 1;
Q[tail++] = e.v;
num[d[e.v]] ++;
}
}
}
int Maxflow(int s, int t){
this -> s = s;
this -> t = t;
CPY(cur, Head);
Bfs();
int u = p[s] = s, flow = 0;
while(d[s] < n){
if(u == t){
int f = inf, neck;
for(int i = s; i != t; i = edge[cur[i]].v){
if(f > edge[cur[i]].c - edge[cur[i]].f){
f = edge[cur[i]].c - edge[cur[i]].f;
neck = i;
}
}
for(int i = s; i != t; i = edge[cur[i]].v){
edge[cur[i]].f += f;
edge[cur[i]^1].f -= f;
}
flow += f;
u = neck;
}
int ok = 0;
for(int i = cur[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c > e.f && d[e.v] + 1 == d[u]){
ok = 1;
cur[u] = i;
p[e.v] = u;
u = e.v;
break;
}
}
if(!ok){
int m = n - 1;
if(--num[d[u]] == 0) break;
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c - e.f > 0 && m > d[e.v]){
cur[u] = i;
m = d[e.v];
}
}
++num[d[u] = m + 1];
u = p[u];
}
}
return flow;
}
}solver;
int n, m, a[maxn], b[maxn], sum, S, T;
LL floyed[maxn][maxn], l, r, ans;
void input(){
sum = 0;
FOR(i, 1, n) scanf("%d%d", &a[i], &b[i]), sum += a[i];
FOR(i, 1, n) FOR(j, 1, n)
if(i == j) floyed[i][j] = 0LL;
else floyed[i][j] = INF;
REP(i, 0, m){
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
floyed[u][v] = min((LL)d, floyed[u][v]);
floyed[v][u] = floyed[u][v];
}
}
bool build(LL m){
S = 0, T = n * 2 + 1;
solver.Init(T + 1);
FOR(i, 1, n){
solver.Add(S, i, a[i]);
solver.Add(i + n, T, b[i]);
}
FOR(i, 1, n) FOR(j, 1, n) if(floyed[i][j] <= m)
solver.Add(i, j + n, inf);
return sum == solver.Maxflow(S,T);
}
void solve(){
l = r = 0LL;
ans = -1;
FOR(k, 1, n) FOR(i, 1, n) FOR(j, 1, n)
floyed[i][j] = min(floyed[i][j], floyed[i][k] + floyed[k][j]);
FOR(i, 1, n) FOR(j, 1, n) if(floyed[i][j] != INF) r = max(r, floyed[i][j]);
while(l <= r){
LL mid = (l + r) / 2;
if(build(mid)){
ans = mid;
r = mid - 1;
}
else l = mid + 1;
}
printf("%I64d\n", ans);
}
int main()
{
//freopen("in.txt", "r", stdin);
while(~scanf("%d%d", &n, &m)){
input();
solve();
}
return 0;
}