SGU 326 Perspective最大流

题意：NBA某小组内有N支球队，小组内以及小组间已经进行了若干场比赛。现在给出这N支球队目前胜利的场数、还剩多少场没有比（包括小组内和小组间），以及小组内任意两支球队之间还剩多少场没有比，问能否合理安排剩下的所有比赛，使得球队1最后胜利的场数大于或等于最终胜场数最大的球队。

分析：这题的建图不好想。首先，最好的策略肯定是让1队赢下所有的比赛，1队的胜场数为tot=已有的胜场+剩下的场数。

建图：对于组内的第i个比赛作为源点的连接点，流量为两支队伍比赛的场数,add(S,i,maze[i][j])。第i个比赛分别与两支队伍（u,v）建边

add(i,u,INF),add(i,v,INF)。最后每支队伍与汇点建边add(j,T,tot-vec[j]),vec[j]为第j支队已有的胜场。最后，只要最大流等于源点流出的流量，则“YES”，否则为“NO”。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 1005
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
struct Edge
{
    int from,to,cap,flow;
    Edge(int from=0,int to=0,int cap=0,int flow=0):from(from),to(to),cap(cap),flow(flow){}
};
vector<Edge>edges;
vector<int>g[MAXN];
bool vis[MAXN];
int d[MAXN];
int cur[MAXN];
int s,t;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        g[i].clear();
    }
    edges.clear();
}
void add(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int m=edges.size();
    g[from].push_back(m-2);
    g[to].push_back(m-1);
}
bool bfs()
{
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!q.empty())
    {
        int tx=q.front();
        q.pop();
        int sz=g[tx].size();
        for(int i=0;i<sz;i++)
        {
            Edge e=edges[g[tx][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[tx]+1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
int dfs(int x,int a)
{
    if(x==t||a==0)
        return a;
    int flow=0,f;
    int sz=g[x].size();
    for(int &i=cur[x];i<sz;i++)
    {
        Edge &e=edges[g[x][i]];
        if(d[x]+1==d[e.to])
        {
            f=dfs(e.to,min(a,e.cap-e.flow));
            if(f>0)
            {
                e.flow+=f;
                edges[g[x][i]^1].flow-=f;
              	// Edge E=edges[g[x][i]^1];
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
    }
    return flow;
}
int maxFlow()
{
    int flow=0;
    while(bfs())
    {
        memset(cur,0,sizeof(cur));
        flow+=dfs(s,INF);
    }
    return flow;
}
int vec[MAXN],re[MAXN],maze[MAXN][MAXN],N;
int main()
{
    int i,j,tot;
    while(scanf("%d",&N)!=EOF)
    {
        init();
        s=0;
        for(i=1;i<=N;i++)
            cin>>vec[i];
        for(i=1;i<=N;i++)
            cin>>re[i];
        tot=re[1]+vec[1];
        for(i=1;i<=N;i++)
            for(j=1;j<=N;j++)
            cin>>maze[i][j];
        int flag=0;
        for(i=1;i<=N;i++)
            if(tot<vec[i])
        {
            flag=1;break;
        }
        if(flag)
        {
            puts("NO");
            continue;
        }
        int cnt=N,sum=0;;
        for(i=2;i<=N;i++)
        {
            for(j=i+1;j<=N;j++)
            {
                if(maze[i][j]!=0)
                {
                    cnt++;
                    add(s,cnt,maze[i][j]);
                    add(cnt,i,INF);
                    add(cnt,j,INF);
                    sum+=maze[i][j];
                }
            }
        }
        t=cnt+1;
        for(i=2;i<=N;i++)
        {
            add(i,t,tot-vec[i]);
        }
        int flow=maxFlow();
     //   cout<<tot<<" "<<sum<<" "<<flow<<endl;
        if(flow==sum)
            printf("YES\n");
        else puts("NO");


    }

    return 0;
}