SGU 326 Perspective（最大流）

Description

Breaking news! A Russian billionaire has bought a yet undisclosed NBA team. He's planning to invest huge effort and money into making that team the best. And in fact he's been very specific about the expected result: the first place. 
Being his advisor, you need to determine whether it's possible for your team to finish first in its division or not. 
More formally, the NBA regular season is organized as follows: all teams play some games, in each game one team wins and one team loses. Teams are grouped into divisions, some games are between the teams in the same division, and some are between the teams in different divisions. 
Given the current score and the total number of remaining games for each team of your division, and the number of remaining games between each pair of teams in your division, determine if it's possible for your team to score at least as much wins as any other team in your division.

Input

The first line of input contains N (2 ≤ N ≤ 20) — the number of teams in your division. They are numbered from 1 to N, your team has number 1. 
The second line of input contains N integers w₁, w₂,..., w_N, where w_i is the total number of games that i^th team has won to the moment. 
The third line of input contains N integers r₁, r₂,..., r_N, where r_i is the total number of remaining games for the i^th team (including the games inside the division). 
The next N lines contain N integers each. The j^th integer in the i^th line of those contains a_ij — the number of games remaining between teams i and j. It is always true that a_ij=a _ji and a_ii=0, for all ia_i1+ a_i2 +... + a_iN ≤ r_i. 
All the numbers in input are non-negative and don't exceed 10\,000.

Output

On the only line of output, print "

YES

" (without quotes) if it's possible for the team 1 to score at least as much wins as any other team of its division, and "

NO

" (without quotes) otherwise.

题目大意：某小组有n支队伍要比赛，现在每支队伍已经赢了w[i]场，每支队伍还要比r[i]场，每场分同小组竞赛和不同小组竞赛，然后给一个矩阵（小组内竞赛），i行j列为队伍i与队伍j还要比多少场比赛，问队伍1有没有在小组内拿最高分（假设赢一场得一分）的可能性（可以跟其他队伍同分）

思路：首先，队伍1要赢，最好是要1把所有比赛都赢了（包括小组内和小组外），然后其他小组的分都要尽量低，所以其他队伍都要输掉小组外的比赛。那么设小组1能赢max_score场。那么怎么分配其他比赛的获胜方呢？这里就要用到网络流建图。从源点到每支队伍间的比赛连一条边，容量为该竞赛的场数，然后该竞赛再向该比赛的两支队伍连一条容量为无穷大的边（你喜欢容量为场数也可以o(╯□╰)o）。然后，每支队伍（不包括1），连一条容量为max_score - w[i]的边到汇点（不能让这支队伍赢太多啊会超过1的o(╯□╰)o）。如果最大流等于小组内比赛数，那就是YES（分配了所有比赛的结果，还是没人能超过max_score，有可行解），否则输出NO。

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

 const int INF = 0x7fff7fff;
 const int MAX = ;
 const int MAXN = MAX * MAX;
 const int MAXE =  * MAXN;

 struct Dinic {
     int head[MAXN], cur[MAXN], dis[MAXN];
     int to[MAXE], next[MAXE], cap[MAXE], flow[MAXE];
     int n, st, ed, ecnt;

     void init() {
         memset(head, , sizeof(head));
         ecnt = ;
     }

     void add_edge(int u, int v, int c) {
         to[ecnt] = v; cap[ecnt] = c; flow[ecnt] = ; next[ecnt] = head[u]; head[u] = ecnt++;
         to[ecnt] = u; cap[ecnt] = ; flow[ecnt] = ; next[ecnt] = head[v]; head[v] = ecnt++;
     }

     bool bfs() {
         memset(dis, , sizeof(dis));
         queue<int> que; que.push(st);
         dis[st] = ;
         while(!que.empty()) {
             int u = que.front(); que.pop();
             for(int p = head[u]; p; p = next[p]) {
                 int v = to[p];
                 if(!dis[v] && cap[p] > flow[p]) {
                     dis[v] = dis[u] + ;
                     que.push(v);
                     if(v == ed) return true;
                 }
             }
         }
         return dis[ed];
     }

     int dfs(int u, int a) {
         if(u == ed || a == ) return a;
         int outflow = , f;
         for(int &p = cur[u]; p; p = next[p]) {
             int v = to[p];
             if(dis[u] +  == dis[v] && (f = dfs(v, min(a, cap[p] - flow[p]))) > ) {
                 flow[p] += f;
                 flow[p ^ ] -= f;
                 outflow += f;
                 a -= f;
                 if(a == ) break;
             }
         }
         return outflow;
     }

     int Maxflow(int ss, int tt, int nn) {
         st = ss; ed = tt; n = nn;
         int ans = ;
         while(bfs()) {
             for(int i = ; i <= n; ++i) cur[i] = head[i];
             ans += dfs(st, INF);
         }
         return ans;
     }
 } G;

 int r[MAX], w[MAX];
 int n;

 int main() {
     scanf("%d", &n);
     for(int i = ; i <= n; ++i) scanf("%d", &w[i]);
     for(int i = ; i <= n; ++i) scanf("%d", &r[i]);
     int max_score = w[] + r[], node_cnt = n, game_cnt = ;
     for(int i = ; i <= n; ++i)
         if(max_score < w[i]) {puts("NO"); return ;}
     G.init();
     int ss = ;
     for(int i = ; i <= n; ++i) for(int j = ; j <= n; ++j) {
         int x; scanf("%d", &x);
         if(i ==  || i >= j || x == ) continue;
         game_cnt += x;
         G.add_edge(ss, ++node_cnt, x);
         G.add_edge(node_cnt, i, INF);
         G.add_edge(node_cnt, j, INF);
     }
     int tt = ++node_cnt;
     for(int i = ; i <= n; ++i) G.add_edge(i, tt, max_score - w[i]);
     if(G.Maxflow(ss, tt, node_cnt) == game_cnt) puts("YES");
     else puts("NO");
 }