poj 2699 最大流+枚举

poj 2699

题意：这题废话真多。。就是说有n个选手，每个选手有一个比赛分数，比赛分数是他打败的选手的数量，每两名选手之间有一个比赛胜负关系，具体关系未知，现在定义一个Strong King的东西：如果没有比这名选手分数更高的选手或者这名选手打败了所有分数比他高的选手，那么这名选手就是Strong King。问最多有多少名Strong King。

思路：好像有人用贪心水过了，这题的正确解法应该是跑最大流，建图也比较简单直观：以每场比赛为点，与源点建边，边的容量为1；以每个选手为点，与汇点建边，边的容量为选手分数；选手与比赛建边，容量为1。这样就形成了“每场比赛获胜的一方会获得1点流量通过选手流入汇点”的网络。

然后我们就可以枚举Strong King的数量：

1.分数最高的几人一定是Strong King；

2.分数不是最高的人一定要打败分数比他高的人；

3.如果选手的分数<分数高于他的选手数量，那么他一定不是Strong King。

其中第2条可以通过删边来实现，形象地说，如果A赢了B，那么对于比赛（A，B）只需要A和（A，B）建边就可以了。

P.s. 这题最坑爹的地方是数据的读入部分，可能有若干空格。。。。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

const int MAXN = 200;//点数的最大值
const int MAXM = 20000;//边数的最大值
const int INF = 0x3f3f3f3f;
struct Edge{
    int to,next,cap,flow;
}edge[MAXM];//注意是MAXM
int tol;
int head[MAXN];
int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN];
void init(){
    tol = 0;
    memset(head,-1,sizeof(head));
}
//加边，单向图三个参数，双向图四个参数
void addedge(int u,int v,int w,int rw=0){
    edge[tol].to = v;edge[tol].cap = w;edge[tol].next = head[u];
    edge[tol].flow = 0;head[u] = tol++;
    edge[tol].to = u;edge[tol].cap = rw;edge[tol].next = head[v];
    edge[tol].flow = 0;head[v]=tol++;
}
int sap(int start,int end,int N){
    memset(gap,0,sizeof(gap));
    memset(dep,0,sizeof(dep));
    memcpy(cur,head,sizeof(head));
    int u = start;
    pre[u] = -1;
    gap[0] = N;
    int ans = 0;
    while(dep[start] < N){
        if(u == end){
            int Min = INF;
            for(int i = pre[u];i != -1; i = pre[edge[i^1].to])
                if(Min > edge[i].cap - edge[i].flow)
                        Min = edge[i].cap - edge[i].flow;
            for(int i = pre[u];i != -1; i = pre[edge[i^1].to]){
                edge[i].flow += Min;
                edge[i^1].flow -= Min;
            }
            u = start;
            ans += Min;
            continue;
        }
        bool flag = false;
        int v;
        for(int i = cur[u]; i != -1;i = edge[i].next){
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u]){
                flag = true;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if(flag){
            u = v;
            continue;
        }
        int Min = N;
        for(int i = head[u]; i != -1;i = edge[i].next)
            if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min){
                Min = dep[edge[i].to];
                cur[u] = i;
            }
        gap[dep[u]]--;
        if(!gap[dep[u]])return ans;
        dep[u] = Min+1;
        gap[dep[u]]++;
        if(u != start) u = edge[pre[u]^1].to;
    }
    return ans;
}
const int M = 12;
int score[M], match[M][M], large[M];
bool link[M][M];
char str[1000];
main() {
    int t;
    scanf("%d", &t);
    getchar();
    while(t--){
        memset(link, -1, sizeof link);
        gets(str);
        int n = 0;
        bool flag = false;
        for(int i = 0;str[i]; i++){
            if(str[i] >= '0' && str[i] <= '9')
                score[++n] = str[i] - '0';
        }
        int idx = n;
        for(int i = 1; i <= n; i++)
            for(int j = i + 1; j <= n; j++)
                match[i][j] = match[j][i] = ++idx;
        int src = 0, sink = ++idx;
        for(int i = 1; i <= n; i++){
            int cnt = 0;
            for(int j = i + 1; j <= n; j++){
                if(score[j] > score[i]) cnt++;
            }
            large[i] = cnt;
        }
        int ans = 0;
        for(int i = n; i >= 1; i--){
            if(score[i] == score[n]){
                ans++;
                continue;
            }
            if(large[i] > score[i]) break;
            init();
            int now = n;
            while(score[now] > score[i] && now >= 1){
                link[now][i] = false;
                now--;
            }
            for(int k = 1; k <= n; k++)
                for(int j = 1; j <= n; j++)
                    if(link[k][j])
                        addedge(k, match[k][j], 1);
            for(int k = n + 1; k < sink; k++)
                addedge(k, sink, 1);
            for(int k = 1; k <= n; k++)
                addedge(src, k, score[k]);
            if(sap(src, sink, sink + 1) == n * (n - 1) / 2) ans++;
            else break;
        }
        printf("%d\n", ans);
    }
}