The K-League （网络流，建图难）

                                    The K-League

 

题目：

   给出N给人，两两之间进行比赛。现在已经确定第i个人赢得场数和输的场数，让你通过其与N-1个之间在进行比赛他是否有可能赢得冠军。

 

算法：

  可以知道要让第i个人获得冠军那个其与n-1人的比赛他要都赢。既，他能赢得最大场数为win[i] + a[i][j].如果，这个总的场数都大不了别人的已经确定赢得场数那么其肯定获得不了冠军，是吧？。而对与一场比赛只有两种结果，要么i赢要么j赢。这时候我们就可以想到了如何建图，即把某两个人在某一场比赛分别当作一个节点。这里有显然的对应关系，即比赛是对应着两个人的。

 

建图：

   所以，这时候我们可以想到把起点跟比赛相连，容量为这场比赛的次数，对吧？。

然后，把比赛分别跟着场比赛的两个人相连，因为这场比赛只跟着两个人有关系，这也对吧？。

最后，在把每个人与汇点相连，而容量是多少？这里我们假设现在是第x个人是会得到冠军的所以我们建图当然也要围绕着他会赢的最优结果进行。所以，要让他尽可能的赢。因此，每个人能赢得最大可能就是tot[x] - win[now]。是吧？。就是当前这人在比赛中能在获胜的场数不能超过tot[x] - win[now]，因为他已超过，就表明x这个人就不是冠军了。图就这样建完了。懂了吧？！

 

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

const int INF = 1 << 20;
const int MAXN = 1000;

//
struct Edge{
    int from,to,cap,flow;
    Edge(){};
    Edge(int _from,int _to,int _cap,int _flow)
        :from(_from),to(_to),cap(_cap),flow(_flow){};
};
vector<Edge> edges;
vector<int> G[MAXN];
int d[MAXN],cur[MAXN];
int N,M,src,sink;

///

int a[MAXN][MAXN],w[MAXN];
int tot[MAXN];

void init(){
   src = N * N + N + 2; sink = src + 1;
   for(int i = 0;i < sink + 2;++i)
     G[i].clear();
   edges.clear();
}

void addEdge(int from,int to,int cap){
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int sz = edges.size();
    G[from].push_back(sz - 2);
    G[to].push_back(sz - 1);
}

bool build(int x){
     for(int i = 0;i < N;++i){
        for(int j = i + 1;j < N;++j){
            addEdge(src,i * N + j,a[i][j]);  //第几场比赛
            addEdge(i * N + j,i + N*N,INF);   //是哪两个人进行比赛
            addEdge(i * N + j,j + N*N,INF);
        }
     }

     int sum = 0;
     for(int i = 0;i < N;++i){
        if(tot[x] < w[i]){  //当前这个人所有能赢得场数都胜不了别人确定的场数
            return false;
        }
        sum += tot[x] - w[i];
        addEdge(i + N*N,sink,tot[x] - w[i]); //最多还可以胜的场数
     }

     return true;
}

bool check(){
    for(int i = 0;i < (int)G[src].size();++i){
        if(G[src][i] & 1) continue;
        Edge& e = edges[G[src][i]];
        if(e.cap != e.flow)
          return false;
    }
    return true;
}



///

bool BFS(){
    fill(d,d + sink + 2,-1);
    queue<int> Q;
    d[src] = 0;
    Q.push(src);

    while(!Q.empty()){
        int x = Q.front(); Q.pop();
        for(int i = 0;i < (int)G[x].size();++i){
            Edge& e = edges[G[x][i]];
            if(d[e.to] == -1 && e.cap > e.flow){
                d[e.to] = d[x] + 1;
                Q.push(e.to);
            }
        }
    }

    return d[sink] > 0;
}

int DFS(int x,int a){
    if(x == sink || a == 0)
        return a;

    int flow = 0,f;
    for(int& i = cur[x];i < (int)G[x].size();++i){
        Edge& e = edges[G[x][i]];
        if(d[e.to] == d[x] + 1 && (f = DFS(e.to,min(a,e.cap - e.flow))) > 0){
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }

    return flow;
}

int maxFlow(){
   int flow = 0;
   while(BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(src,INF);
   }
   return flow;
}

//


int main()
{
    //freopen("Input.txt","r",stdin);

     int T;
     scanf("%d",&T);
     while(T--){
        int x;
        scanf("%d",&N);

        for(int i = 0;i < N;++i)
            scanf("%d%d",&w[i],&x);
        for(int i = 0;i < N;++i){
            tot[i] = w[i];
            for(int j = 0;j < N;++j){
                scanf("%d",&a[i][j]);
                tot[i] += a[i][j];
            }
        }
        bool first = true;
        for(int i = 0;i < N;++i){
            init();
            if(!build(i))
               continue;

            maxFlow();

            if(check()){
                if(first)
                    printf("%d",i+1);
                else
                    printf(" %d",i+1);
                first = false;
            }
        }
        puts("");
     }
     return 0;
}