HDU 6445 Search for Answer（最小费用最大流-mcmf）

Description

给出一个$n$个点的完全图的邻接矩阵$a$，其中$a_{i,j}=1$表示$i,j$之间边的方向是$i$到$j$，$a_{i,j}=0$表示$i,j$之间边的方向是$j$到$i$，$a_{i,j}=a_{j,i}=2$表示$i,j$之间边的方向尚未确定，要求给不确定方向的边定向使得对该矩阵运行下面代码所得结果最大

Input

第一行一整数$T$表示用例组数，每组用例首先输入一整数$n$表示点数，之后输入一个$n\times n$的矩阵表示该图的邻接矩阵，其中$a_{i,j}=a_{j,i}=2$的位置至多$200$个

$(2\le T\le 10,5\le n\le 200)$

Output

输出定向后所给代码运行结果最大值

Sample Input

2
5
02112
20221
02001
02102
20020
5
01112
00022
01012
02002
22220

Sample Output

40
24

Solution

对于每个四元团$a,b,c,d$，有三种情况：

1.四点成环，也即没有出度为$2$的点，对答案贡献为$1$

2.有两个点的出度为$2$，对答案贡献为$-1$

3.只有一个点的出度为$1$，对答案贡献为$0$

假设所有四元团贡献均为$1$，这样的贡献为$A_n^4$，之后考虑负贡献，如果一个四元团只有一个出度为$2$的点则负贡献$1$，如果一个四元团有两个出度为$2$的点则负贡献为$2$，故只要对每个点累加考虑其作为$2$出度点时的情况数即为所有负贡献

假设没有不确定的边，考虑每个点对答案的贡献，对于点$a$，假设其出度为$du(a)$，从其出度点中任选两个点$b,d$的方案数为$A_{du(a)}^2$，从剩余$n-3$个点中任选一个点$c$即可，注意到选出的这四个点只是给出了相对顺序，而绝对顺序（也就是循环中的先后顺序）有四种，进而有
$$ans=A_n^4-\sum _{a=1}^{n}4\cdot (n-3)\cdot A_{du(a)}^2=A_n^4-8\cdot (n-3)\cdot \sum _{a=1}^n{C}_{du(a)}^2$$
故我们需要给边定向使得$\sum _{a=1}^n{C}_{du(a)}^2$最小，对于点$a$，设与其相连的边中有$x$条不确定方向的边，$a$已确定的出度依旧记为$du(a)$，如果这$x$条边中有$y$条确定从$a$出发，那么$a$对答案的贡献即为
$$C_{du(a)+y}^2=C_{du(a)}^2+\sum _{i=0}^{y-1}(du(a)+i)$$
如果用$y$个流的限制来表示$a$会多出$y$个出度，从$a$向汇点建$x$条边，每条边流量为$1$，费用依次为$du(a),du(a)+1,...,du(a)+x-1$，那么满流下的最小费用即为$a$在保证多出$y$个出度时对答案的最小贡献

进一步的，考虑所有点对答案的最小贡献和，一排点表示没有确定方向的边，一排点表示这$n$个点，每条边向其两个端点建流量为$1$费用为$0$的边，源点向每条边建流量为$1$费用为$0$的边，每个点向汇点建边如前，那么该网络的最大流即为给每条边确定方向，最小费用即为确定方向后所有点对答案的贡献和最小值

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
#define maxn 405
#define maxm 100005
#define INF 0x3f3f3f3f
int head[maxn],d[maxn],s,e,no,vis[maxn],pre[maxn];//s为源点,e为汇点 
struct point
{
    int u,v,flow,next,cost;
    point(){};
    point(int _u,int _v,int _next,int _flow,int _cost)
	{
		u=_u,v=_v,next=_next,flow=_flow,cost=_cost;
	} 
}p[maxm];
void add(int x,int y,int z,int c)//从x到y建一条容量为z,花费为c的边 
{
    p[no]=point(x,y,head[x],z,c);   
    head[x]=no++;
    p[no]=point(y,x,head[y],0,-c);  
    head[y]=no++;
}
void init()//初始化 
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool spfa()
{
    int i,x,y;
    queue<int>q;
    memset(d,0x3f,sizeof(d));
    memset(vis,false,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    d[s]=0;   
    vis[s]=true;  
    q.push(s);
    while(!q.empty())
    {
        x=q.front();  
        q.pop();    
        vis[x]=false;
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
            {
                d[y]=d[x]+p[i].cost;   
                pre[y]=i;
                if(vis[y])  
                    continue;
                vis[y]=true;  
                q.push(y);
            }  
        }  
    }
    return d[e]!=d[e+1];
}
int mcmf()//最小费用最大流 
{
    int mincost=0,maxflow=0,minflow,i;
    while(spfa())
    {
    	//if(d[e]>=0)break;//可行流 
        minflow=INF;
        for(i=pre[e];i!=-1;i=pre[p[i].u])
            minflow=min(minflow,p[i].flow);
        for(i=pre[e];i!=-1;i=pre[p[i].u])
        {
            p[i].flow-=minflow;
            p[i^1].flow+=minflow;
        }
        mincost+=d[e]*minflow; 
        maxflow+=minflow;
    }
    return mincost;//最小费用,最大流为maxflow 
}
int T,n,m,num[205],du[205];
char c[205];
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++)num[i]=du[i]=0;
		init();
		m=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%s",c+1);
			for(int j=1;j<=n;j++)
			{
				int x=c[j]-'0';
				if(x==1)du[i]++;
				else if(x==2&&i<j)
				{
					m++,num[i]++,num[j]++;
					add(n+m,i,1,0);
					add(n+m,j,1,0);
				}
			}
		}
		s=0,e=n+m+1;
		for(int i=1;i<=m;i++)add(s,n+i,1,0);
		int res=0;
		for(int i=1;i<=n;i++)
		{
			res+=du[i]*(du[i]-1)/2;
			for(int j=0;j<num[i];j++)add(i,e,1,du[i]++);
		}
		res=8*(n-3)*(res+mcmf());
		printf("%d\n",n*(n-1)*(n-2)*(n-3)-res);
	}
	return 0;
}