BZOJ 2597 [Wc2007]剪刀石头布（凸费用流问题）

2597: [Wc2007]剪刀石头布

Time Limit: 20 Sec Memory Limit: 128 MBSec Special Judge
Submit: 1464 Solved: 663
[Submit][Status][Discuss]
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。输出矩阵要保证合法，不能发生矛盾。
Sample Input

3

0 1 2

0 0 2

2 2 0

Sample Output

1

0 1 0

0 0 1

1 0 0
HINT

100%的数据中，N≤ 100。

题目大意：

　　给你一个竞赛图，有的边的方向确定，有的边没有确定，让你确定这些边的方向，使得图中有向三元环最多。

解题思路：

　　考虑三个点不能构成三元环的情况，一定是一个点入度为2，一个点出度为2，一个点入度出度都为1。再加上竞赛图的性质，我们也可以知道每个点每有一对出去的边，就有组不能构成三元环的三个点。那么整张图的三元环数就是：$C^{3}_{V}- \sum{C^{2}_{outdeg_{i}}}$，$C^{3}_{V}$是常数，所以我们的任务就是最小化$\sum{C^{2}_{outdeg_{i}}}$。这里就产生了凸费用函数$f(x)=C^{2}_{x}$，我们就可以使用凸费用流的方式建图。
　　建立源点$s$,汇点$t$。每场比赛作一个结点，每个人作一个结点。从源点到每场比赛连接一条容量为$1$费用为$0$的边。对于每场比赛如果已经确定结果，则向胜利者连一条容量为$1$费用为$0$的边，如果没有确定则向两个人各连一条容量为$1$费用为$0$的边。对于每个人向汇点连N条边，容量为$1$，第$i$条边的花费为$C^{2}_{i}-C^{2}_{i-1}$。答案就是$C^{3}_{V}-MCMF$。

AC代码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
#define INF 0x3f3f3f3f
#define LL long long
#define fi first
#define se second
#define mem(a,b) memset((a),(b),sizeof(a))
#define sqr(x) ((x)*(x))

const int MAXN=100+3;
const int MAXV=MAXN*MAXN;
const int MAXE=MAXV*10;

struct Edge
{
    int to,next,cap,cost;
    Edge(int t=0,int n=0,int ca=0,int f=0,int co=0):to(t),next(n),cap(ca),cost(co){}
}edge[MAXE];

int head[MAXV],tol;
int pre[MAXV],dis[MAXV];
bool vis[MAXV];
int V;//节点总个数，节点编号从0~V-1
int N, maze[MAXN][MAXN];

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

bool spfa(int s,int t)
{
    queue<int> que;
    for(int i=0;i<V;++i)
    {
        dis[i]=INF;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>0&&dis[v]>dis[u]+edge[i].cost)
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=true;
                    que.push(v);
                }
            }
        }
    }
    return pre[t]!=-1;
}

int min_cost_flow(int s,int t,int &cost)//返回的是最大流，cost存的是最小费用
{
    int flow=0;
    cost=0;
    while(spfa(s,t))
    {
        int the_min=INF;
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
            the_min=min(the_min,edge[i].cap);
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].cap-=the_min;
            edge[i^1].cap+=the_min;
            cost+=edge[i].cost*the_min;
        }
        flow+=the_min;
    }
    return flow;
}

void init()
{
    tol=0;
    mem(head, -1);
}

inline int f(const int &x)//返回C(x, 2)-C(x-1, 2)
{
    return x==1?0:x-1;
}

int main()
{
    // 0 ~ N*N-1      比赛
    // N*N ~ N*N+N-1  人
    // N*N+N          源点
    // N*N+N+1        汇点
    scanf("%d", &N);
    V=N*N+N+2;
    int s=V-2, t=V-1;
    init();
    for(int i=0;i<N;++i)
        for(int j=0;j<N;++j)
        {
            scanf("%d", &maze[i][j]);
            if(j>i)
            {
                add_edge(s, i*N+j, 1, 0);
                if(maze[i][j]==1)
                    add_edge(i*N+j, N*N+i, 1, 0);
                else if(maze[i][j]==0)
                    add_edge(i*N+j, N*N+j, 1, 0);
                else
                {
                    add_edge(i*N+j, N*N+i, 1, 0);
                    add_edge(i*N+j, N*N+j, 1, 0);
                }
            }
        }
    for(int i=0;i<N;++i)
        for(int j=1;j<=N;++j)
            add_edge(N*N+i, t, 1, f(j));
    int cost;
    min_cost_flow(s, t, cost);
    printf("%d\n", N*(N-1)*(N-2)/6-cost);
    for(int i=0;i<N;++i)//通过扫描残余网络，确定方向
        for(int j=i+1;j<N;++j)
            if(maze[i][j]==2)
            {
                int v=-1;
                for(int k=head[i*N+j];~k;k=edge[k].next)
                    if(edge[k].to>=N*N && edge[k].to<N*N+N && edge[k].cap==0)
                    {
                        v=edge[k].to-N*N;
                        break;
                    }
                maze[i][j]=(v==i);
                maze[j][i]=!(v==i);
            }
    for(int i=0;i<N;++i)
        for(int j=0;j<N;++j)
            printf("%d%c", maze[i][j], j==N-1?'\n':' ');

    return 0;
}