【LA2531 训练指南】足球联赛 【最大流】

题意：

有n支队伍进行比赛，每支队伍需要打的比赛数目相同。每场比赛恰好一支队伍胜，另一支败。给出每支队伍目前胜的场数和败的场数，以及每两支队伍还剩下的比赛场数，确定所有可能的冠军的球队。（获胜场数最多的是冠军，可以并列）。

分析

一只队伍如果可能得冠军，那么就一定可以通过调整，未来的几场比赛的结果使自己赢得场次最多。否则便不可能成为冠军。

在判断第i支队伍有无可能成为冠军时：首先，第i支队伍得对局i全部取得胜利，得到i胜利的总场数为total。然后判断其他队伍的对局，能否互相限制使得，任何队伍胜利的场数都不超过total。

建模方法：

对每两支队伍(u,v)构造一个X结点，从S引一条弧过来，容量为这两支队伍还需要比赛的场数。对每支队伍u构造一个Y结点，引一条弧到T，容量为total-win[u].然后每个(u,v)结点向u和v结点个连一条无穷大得弧。这样当且仅当，从S出发得每条弧都是满载得时候，当前队伍才有可能得冠军。

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 #include <vector>

 using namespace std;
 const int maxn=+;
 const int MAXN=;
 const int maxm=+;
 const int INF=;
 struct Dinic{
     int head[maxn],Next[maxm],to[maxm],cap[maxm],flow[maxm],from[maxm];
     int sz,n,m,s,t;
     bool vis[maxn];
     int cur[maxn],d[maxn];
     void init(int n){
         this->n=n;
         memset(head,-,sizeof(head));
         this->sz=-;
     }
     void add_edge(int a,int b,int c){
         ++sz;
         to[sz]=b;
         cap[sz]=c;flow[sz]=;from[sz]=a;
         Next[sz]=head[a];head[a]=sz;
         ++sz;
         to[sz]=a;
         cap[sz]=c;flow[sz]=c;from[sz]=b;
         Next[sz]=head[b];head[b]=sz;
     }
     bool BFS(){
         memset(vis,,sizeof(vis));
         queue<int>Q;
         vis[s]=;
         d[s]=;
         Q.push(s);
         while(!Q.empty()){
             int u=Q.front();Q.pop();
             for(int i=head[u];i!=-;i=Next[i]){
                 int v=to[i];
                 if(!vis[v]&&cap[i]>flow[i]){
                     vis[v]=;
                     d[v]=d[u]+;
                     Q.push(v);
                 }
             }
         }
         return vis[t];
    }
     int DFS(int x,int a){
         if(x==t||a==)return a;
         int Flow=,f;
         for(int& i=cur[x];i!=-;i=Next[i]){
             int v=to[i];
             if(d[v]==d[x]+&&(f=DFS(v,min(a,cap[i]-flow[i])))>){
                 Flow+=f;
                 flow[i]+=f;
                 flow[i^]-=f;
                 a-=f;
                 if(a==)break;
             }
         }
         return Flow;
     }
     int Maxflow(int s,int t){
         this->s=s,this->t=t;
         int Flow=;
         while(BFS()){
             for(int i=;i<=n;i++)
              cur[i]=head[i];
             Flow+=DFS(s,INF);
         }
         return Flow;
     }
 }dinic;
 int T,n;
 int win[MAXN],lose[MAXN];
 int G[MAXN][MAXN];
 vector<int>ans;
 bool judge(int num){
     int total=win[num];
     for(int i=;i<=n;i++){
         total+=G[num][i];
     }
     //cout<<total<<endl;

     int allS=(n*n-*n+)/;
     int NUM=;
     dinic.init(allS+n+);
     dinic.s=,dinic.t=allS+n+;
     for(int i=;i<=n;i++){
             if(i==num)continue;
         for(int j=i+;j<=n;j++){
          //   cout<<i<<" "<<j<<" "<<G[i][j]<<endl;
             if(j==num)continue;
             NUM++;
             dinic.add_edge(,NUM,G[i][j]);
             dinic.add_edge(NUM,allS+i,INF);
             dinic.add_edge(NUM,allS+j,INF);
         }
     }

     for(int i=;i<=n;i++){
         if(i==num)continue;
         if(total<win[i])return false;
         dinic.add_edge(allS+i,dinic.t,total-win[i]);
     }
     dinic.Maxflow(,allS+n+);
     for(int i=;i<=dinic.sz;i+=){
         if(dinic.from[i]==){
             if(dinic.flow[i]<dinic.cap[i])
                 return false;
         }
     }
     return true;
 }
 int main(){
     scanf("%d",&T);
     for(int t=;t<=T;t++){
        // if(t!=1)printf("\n");
         ans.clear();
         scanf("%d",&n);
         for(int i=;i<=n;i++){
             scanf("%d%d",&win[i],&lose[i]);
         }
         for(int i=;i<=n;i++){
             for(int j=;j<=n;j++){
                 scanf("%d",&G[i][j]);
             }
         }
        /* if(judge(1))
             printf("Yes 1");*/

         for(int i=;i<=n;i++){
             if(judge(i))
                 ans.push_back(i);
         }
         sort(ans.begin(),ans.end());
         for(int i=;i<ans.size();i++){
             if(i!=)printf(" ");
             printf("%d",ans[i]);
         }
         printf("\n");
     }
 return ;
 }