BZOJ 2597 剪刀石头布（最小费用最大流）（WC2007）

Description

在一些一对一游戏的比赛（如下棋、乒乓球和羽毛球的单打）中，我们经常会遇到A胜过B，B胜过C而C又胜过A的有趣情况，不妨形象的称之为剪刀石头布情况。有的时候，无聊的人们会津津乐道于统计有多少这样的剪刀石头布情况发生，即有多少对无序三元组(A, B, C)，满足其中的一个人在比赛中赢了另一个人，另一个人赢了第三个人而第三个人又胜过了第一个人。注意这里无序的意思是说三元组中元素的顺序并不重要，将(A, B, C)、(A, C, B)、(B, A, C)、(B, C, A)、(C, A, B)和(C, B, A)视为相同的情况。

有N个人参加一场这样的游戏的比赛，赛程规定任意两个人之间都要进行一场比赛：这样总共有场比赛。比赛已经进行了一部分，我们想知道在极端情况下，比赛结束后最多会发生多少剪刀石头布情况。即给出已经发生的比赛结果，而你可以任意安排剩下的比赛的结果，以得到尽量多的剪刀石头布情况。

Input

输入文件的第1行是一个整数N，表示参加比赛的人数。

之后是一个N行N列的数字矩阵：一共N行，每行N列，数字间用空格隔开。

在第(i+1)行的第j列的数字如果是1，则表示i在已经发生的比赛中赢了j；该数字若是0，则表示在已经发生的比赛中i败于j；该数字是2，表示i和j之间的比赛尚未发生。数字矩阵对角线上的数字，即第(i+1)行第i列的数字都是0，它们仅仅是占位符号，没有任何意义。

输入文件保证合法，不会发生矛盾，当i≠j时，第(i+1)行第j列和第(j+1)行第i列的两个数字要么都是2，要么一个是0一个是1。

Output

输出文件的第1行是一个整数，表示在你安排的比赛结果中，出现了多少剪刀石头布情况。

输出文件的第2行开始有一个和输入文件中格式相同的N行N列的数字矩阵。第(i+1)行第j个数字描述了i和j之间的比赛结果，1表示i赢了j，0表示i负于j，与输入矩阵不同的是，在这个矩阵中没有表示比赛尚未进行的数字2；对角线上的数字都是0。输出矩阵要保证合法，不能发生矛盾。

 

题解：http://blog.csdn.net/pouy94/article/details/5972444

PS：这题太牛叉了值得一做……

 

代码（896MS）：

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

const int MAXN = 110;
const int MAXV = MAXN * MAXN;
const int MAXE = MAXN * MAXV;
const int INF = 0x7f7f7f7f;

struct ZWK_FLOW {
    int head[MAXV], dis[MAXV];
    int to[MAXE], next[MAXE], flow[MAXE], cost[MAXE];
    int n, ecnt, st, ed;

    void init() {
        memset(head, 0, sizeof(head));
        ecnt = 2;
    }

    void add_edge(int u, int v, int c, int w) {
        to[ecnt] = v; flow[ecnt] = c; cost[ecnt] = w; next[ecnt] = head[u]; head[u] = ecnt++;
        to[ecnt] = u; flow[ecnt] = 0; cost[ecnt] = -w; next[ecnt] = head[v]; head[v] = ecnt++;
        //printf("%d %d %d %d
", u, v, c, w);
    }

    void spfa() {
        for(int i = 1; i <= n; ++i) dis[i] = INF;
        priority_queue<pair<int, int> > que;
        dis[st] = 0; que.push(make_pair(0, st));
        while(!que.empty()) {
            int u = que.top().second, d = -que.top().first; que.pop();
            if(d != dis[u]) continue;
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && dis[v] > d + cost[p]) {
                    dis[v] = d + cost[p];
                    que.push(make_pair(-dis[v], v));
                }
            }
        }
        int t = dis[ed];
        for(int i = 1; i <= n; ++i) dis[i] = t - dis[i];
    }

    int minCost, maxFlow;
    bool vis[MAXV];

    int add_flow(int u, int aug) {
        if(u == ed) {
            maxFlow += aug;
            minCost += dis[st] * aug;
            return aug;
        }
        vis[u] = true;
        int now = aug;
        for(int p = head[u]; p; p = next[p]) {
            int &v = to[p];
            if(flow[p] && !vis[v] && dis[u] == dis[v] + cost[p]) {
                int t = add_flow(v, min(now, flow[p]));
                flow[p] -= t;
                flow[p ^ 1] += t;
                now -= t;
                if(!now) break;
            }
        }
        return aug - now;
    }

    bool modify_label() {
        int d = INF;
        for(int u = 1; u <= n; ++u) if(vis[u]) {
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && !vis[v]) d = min(d, dis[v] + cost[p] - dis[u]);
            }
        }
        if(d == INF) return false;
        for(int i = 1; i <= n; ++i) if(vis[i]) dis[i] += d;
        return true;
    }

    int min_cost_flow(int ss, int tt, int nn) {
        st = ss, ed = tt, n = nn;
        minCost = maxFlow = 0;
        spfa();
        while(true) {
            while(true) {
                for(int i = 1; i <= n; ++i) vis[i] = false;
                if(!add_flow(st, INF)) break;
            }
            if(!modify_label()) break;
        }
        return minCost;
    }
} G;

int n, m;
int mat[MAXN][MAXN], ans[MAXN][MAXN];

inline int encode(int i, int j) {
    if(i > j) swap(i, j);
    return i * n + j;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) for(int j = 1; j <= n; ++j) scanf("%d", &mat[i][j]);
    m = n * n;
    int ss = n + m + 1, tt = ss + 1;
    G.init();
    int sum = n * (n - 1) * (n - 2) / 6;
    for(int i = 1; i <= n; ++i) {
        for(int j = 1, tmp = 1; j < n; ++j, tmp += 2) G.add_edge(ss, i, 1, tmp);
        for(int j = 1; j <= n; ++j) if(mat[i][j] != 0)
            ans[i][j] = G.ecnt, G.add_edge(i, encode(i, j), 1, 0);
    }
    for(int i = 1; i <= m; ++i) G.add_edge(i + n, tt, 1, 0);
    int x = G.min_cost_flow(ss, tt, tt);
    printf("%d
", sum - (x - n * (n - 1) / 2) / 2);
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= n; ++j) {
            if(j != 1) printf(" ");
            if(mat[i][j] != 2) printf("%d", mat[i][j]);
            else {
                if(G.flow[ans[i][j]] == 0) printf("1");
                else printf("0");
            }
        }
        puts("");
    }
}