POJ 2699 The Maximum Number of Strong Kings 最大流

题意就是给你一个完全图和每个人胜利的场数，我们知道在完全图中胜利的场数之和一定等于边数（因为一条边必定有一个人胜一个人负）。一个人是strong king，当且仅当他赢过所有分数比他高的人，问最多有几个strong king。

这题主要就是胜利场数的分配问题，当strong king多起来之后，首先可以判断出当比一个人分高的人数大于他的胜场时，他一定不是strong king。并且strong king一定是从分高的人里面更容易出。因为分高的人胜场多而且分比他更高的人少，更容易满足strong king的条件。

为什么strong king多了之后就不能满足了呢？因为本来是分高的人的某些胜场，被分低的人拿走了，结果高分的人的胜场数无法满足题目所给。

所以我们可以枚举strongking的个数。然后根据下图建图

从源点给所有比赛连边容量为1，
从每个比赛出发，每个比赛对应着两个选手u和v
如果选手u是strong king，且选手u胜场小于v胜场，那么直接从当前比赛连到u，容量为1，表示必须u赢。
否则连到u和v，容量都为1，表示谁赢都行
每个选手i连到汇点T，容量为胜场num。
判断最大流是否等于胜场总数即可。
最后要说的是这题读入的空格貌似很乱，所以还是用stringstream好了，莫名TLE了几次。

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

using namespace std;
const int MAXN = 1000;
const int MAXM = 1e6;
const int INF = 0x3f3f3f3f;
int dis[MAXN],n,up[MAXN],num[MAXN],head[MAXN],tol,cnt,sov;
char ch;
struct Edge
{
    int to,cap,flow,nex;
    Edge() {}
    Edge(int to,int cap,int flow,int nex):to(to),cap(cap),flow(flow),nex(nex) {}
}edge[MAXM] ;

void init()
{
    memset(num,0,sizeof num);
    memset(up,0,sizeof up);
    memset(head,-1,sizeof head);
    tol=cnt=0;
    sov=n=0;
}

void addedge(int u,int v,int cap)
{
    edge[tol]=Edge(v,cap,0,head[u]); head[u]=tol++;
    edge[tol]=Edge(u,0,0,head[v]); head[v]=tol++;
}

bool bfs(int s,int t)
{
    memset(dis,-1,sizeof dis);
    dis[s]=0;
    queue<int> que;
    que.push(s);
    while (!que.empty())
    {
        int u=que.front();que.pop();
        for (int i=head[u];~i;i=edge[i].nex)
        {
            int v=edge[i].to;
            if (dis[v]==-1 && edge[i].cap>edge[i].flow)
            {
                dis[v] =dis[u]+1;
                if (v==t) return true;
                que.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int t,int cap)
{
    if (u==t) return cap;
    int flow=0,f;
    for (int i=head[u];~i;i=edge[i].nex)
    {
        int v=edge[i].to;
        if (dis[v]==dis[u]+1 && edge[i].cap>edge[i].flow)
        {
            f=dfs(v,t,min(cap-flow,edge[i].cap-edge[i].flow));
            edge[i].flow += f;
            edge[i^1].flow -= f;
            flow += f;
            if (flow == cap) break;
        }
    }
    if (!flow) dis[u]=-1;
    return flow;
}

int dicnic(int s,int t)
{
    int flow=0,f;
    while (bfs(s,t))
        while ((f=dfs(s,t,INF)) > 0)
            flow += f;
    return flow;
}

string s;
int main()
{
    int t;
    scanf("%d",&t);
    getchar();
    while (t--)
    {
        init();
        getline(cin,s);
        stringstream ss(s);
        int k;
        while (ss>>k)
        {
            num[++n]=k;
        }
        for (int i=1;i<=n;i++)
            for (int j=i+1;j<=n;j++)
                if (num[j] > num[i])
                    up[i]++;
        int lim=n;
        for (int i=n;i>=1;i--)
            if (up[i] > num[i])
            {
                lim=n-i;
                break;
            }
        int edgnum = n*(n-1)/2;
        int ans;
        for (ans=1;ans<=lim;ans++)
        {
            memset(head,-1,sizeof head);
            cnt=0;
            tol=0;
            for (int i=1;i<=n;i++)
            {
                for (int j=i+1;j<=n;j++)
                {
                    cnt++;
                    addedge(0,cnt,1);
                    if (num[i] < num[j] && i>=n-ans+1)//is strong king
                        addedge(cnt,i+edgnum,1);//cnt i
                    else
                    {
                        addedge(cnt,i+edgnum,1);//cnt i'
                        addedge(cnt,j+edgnum,1);//cnt j'
                    }
                }
            }
            for (int i=1;i<=n;i++) addedge(i+edgnum,500,num[i]);//i t
            if (dicnic(0,500) == n*(n-1)/2)  sov=ans;
        }
        printf("%d\n",sov);
    }
    return 0;
}