【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=1000+10;
const int MAXN=30;
const int maxm=30000+100;
const int INF=2147000000;
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,-1,sizeof(head));
        this->sz=-1;
    }
    void add_edge(int a,int b,int c){
        ++sz;
        to[sz]=b;
        cap[sz]=c;flow[sz]=0;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,0,sizeof(vis));
        queue<int>Q;
        vis[s]=1;
        d[s]=0;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(!vis[v]&&cap[i]>flow[i]){
                    vis[v]=1;
                    d[v]=d[u]+1;
                    Q.push(v);
                }
            }
        }
        return vis[t];
   }
    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int Flow=0,f;
        for(int& i=cur[x];i!=-1;i=Next[i]){
            int v=to[i];
            if(d[v]==d[x]+1&&(f=DFS(v,min(a,cap[i]-flow[i])))>0){
                Flow+=f;
                flow[i]+=f;
                flow[i^1]-=f;
                a-=f;
                if(a==0)break;
            }
        }
        return Flow;
    }
    int Maxflow(int s,int t){
        this->s=s,this->t=t;
        int Flow=0;
        while(BFS()){
            for(int i=0;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=1;i<=n;i++){
        total+=G[num][i];
    }
    //cout<<total<<endl;

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

    for(int i=1;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(0,allS+n+1);
    for(int i=0;i<=dinic.sz;i+=2){
        if(dinic.from[i]==0){
            if(dinic.flow[i]<dinic.cap[i])
                return false;
        }
    }
    return true;
}
int main(){
    scanf("%d",&T);
    for(int t=1;t<=T;t++){
       // if(t!=1)printf("
");
        ans.clear();
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d%d",&win[i],&lose[i]);
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                scanf("%d",&G[i][j]);
            }
        }
       /* if(judge(1))
            printf("Yes 1");*/

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