[省选前题目整理][POJ 2699]The Maximum Number of Strong Kings(暴力枚举+最大流)

题目链接

http://poj.org/problem?id=2699

题目大意

n个人比赛, 两两比，共n(n-1)场比赛, 赢的人得1分, n<=10。如果一个人打败了所有比自己分数高的人, 或者他本身就是分数最高的, 那么他就是StrongKing。可能有多个Strong King, 现在按非降的顺序给你每个人的得分(不难道想到容量把), 问Strong King最多能有几个。

思路

显然n个人之间的比赛关系可以构成一个竞赛图。竞赛图问题往往可以用网络流解决，此题也是如此。鉴于某个答案的猜测值的可行性随着答案大小单调改变，很自然地想到用二分来解决此题。那么我们就要二分Strong King的个数ans。下面的问题变成了，已知Strong King的个数ans，求这个答案是否大于实际答案（不成立）。

不妨把每个人看成一个个点（如下图的蓝色点），每个比赛也看成一个个点（如下图的绿色点）。每个比赛向T连容量为1的边（表示赢得一场比赛能得到1分），S向每个人连容量为该人获得分数的边（表示这个人最多只能赢这么多分）。

然后对于后ans个人来说，由于输入的分数是升序的，因此它们是我们假定的Strong Kings。在这些人中，如果人i的分比人j低，那么就从人i向这两个人的比赛对应的点连容量为1的边(显然i和j的胜负已定，根据规则，i比j的分低，而i也是Strong King，那么一定是i赢了这场比赛)。对于所有人来说，任意两个人a、b，分别向他们之间的比赛对应的点连容量为1的边（表明对于其他人来说，他们既可以赢，也可以输）。
最终这个图的最大流就是在Strong Kings个数为ans的情况下能够进行的比赛场数（所有人的分数之和），显然比赛场数是n*(n-1)场，若最大流不等于n*(n-1)，那么就表明Strong Kings个数为ans的情况是不合法的。

代码

#include <sstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXV 1000
#define MAXE 3000
#define MAXN 1000
#define INF 0x3f3f3f3f

using namespace std;

int S,T;

struct edge
{
    int u,v,cap,next;
}edges[MAXE];

int head[MAXV],nCount=1;

void AddEdge(int U,int V,int C)
{
    edges[++nCount].u=U;
    edges[nCount].v=V;
    edges[nCount].cap=C;
    edges[nCount].next=head[U];
    head[U]=nCount;
}

void add(int U,int V,int C)
{
    AddEdge(U,V,C);
    AddEdge(V,U,0);
}

int layer[MAXV],q[MAXE*2];

bool CountLayer()
{
    memset(layer,-1,sizeof(layer));
    int h=0,t=1;
    q[h]=S;
    layer[S]=1;
    while(h<t)
    {
        int u=q[h++];
        for(int p=head[u];p!=-1;p=edges[p].next)
        {
            int v=edges[p].v;
            if(layer[v]==-1&&edges[p].cap)
            {
                layer[v]=layer[u]+1;
                q[t++]=v;
            }
        }
    }
    return layer[T]!=-1;
}

int DFS(int u,int flow)
{
    if(u==T) return flow;
    int used=0;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(layer[v]==layer[u]+1&&edges[p].cap)
        {
            int tmp=DFS(v,min(flow-used,edges[p].cap));
            used+=tmp;
            edges[p].cap-=tmp;
            edges[p^1].cap+=tmp;
            if(used==flow) return used;
        }
    }
    if(!used) layer[u]=-1;
    return used;
}

int Dinic()
{
    int maxflow=0;
    while(CountLayer())
        maxflow+=DFS(S,INF);
    return maxflow;
}

int n=0,tot=0;
int match[MAXN][MAXN],score[MAXN];
bool matched[MAXN*MAXN];
char s[MAXN];

bool check(int x) //已知有x个Strong Kings
{
    S=MAXV-2,T=MAXV-1;
    nCount=1;
    memset(head,-1,sizeof(head));
    memset(matched,false,sizeof(matched));
    for(int i=1;i<=n;i++)
        add(S,i,score[i]);
    for(int i=1;i<=tot;i++)
        add(i+n,T,1);
    for(int i=n-x+1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
            if(score[j]>score[i])
            {
                matched[match[i][j]]=true;
                add(i,match[i][j]+n,1);
            }
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
            if(!matched[match[i][j]])
            {
                add(i,match[i][j]+n,1);
                add(j,match[i][j]+n,1);
            }
    return Dinic()==(n*(n-1)/2);
}

int main()
{
    int TestCase;
    scanf("%d",&TestCase);
    getchar(); //!!!!
    while(TestCase--)
    {
        memset(head,-1,sizeof(head));
        nCount=1;
        n=0,tot=0;
        int tmp;
        gets(s);
        stringstream str(s);
        while(str>>tmp) score[++n]=tmp;
        for(int i=1;i<=n;i++)
            for(int j=i+1;j<=n;j++)
                match[i][j]=++tot;
        int ans;
        for(int i=n;i>=1;i--)
            if(check(i))
            {
                ans=i;
                break;
            }
        printf("%d\n",ans);
    }
    return 0;
}