大致题意：给你一个竞赛图，告诉你一个记数方法，也即所有边同向的四元组加一，所有相邻两边方向相反的四元组减一。现在让你最大化这个结果。
说实话，不看题解应该很难想到是一个费用流……题解给的也真是简单，个人感觉还可能有错？
我们可以这么考虑，观察它给的计数算法，我们可以发现，他的总的循环次数是。于是我们不妨假设每一次循环都产生贡献，然后减去那些实际上不产生贡献和产生负贡献的东西。考虑什么样的情况下不会产生贡献，我们发现如果一个点，我选择了任意两条它的出边以及对应的点，那么不管第四个点是什么，显然构成的四元组一定不会有正的贡献。而这样的一个四元组在它的计数算法中总共会被计算8次，正着循环4次，反着循环4次。如此一来，不会产生正的贡献的方案数就是：
我们再来考虑重复的情况。根据我的算法，会重复的没有正贡献的四元组，只有形如：a->b<-c->d<-a或a<-b->c<-d->a两种形式。观察这两种形式发现，这两种形式正好是会产生一个负贡献的情况，而重复计算也正好知识重复计算了一次，也就是说这个重复正好帮我们处理的负贡献的情况，可以不管这个重复。
如此，我们就有了大致的方法。对于已经确定的边，我计算每个点的出度，然后带入上式计算答案，不妨设为res。然后我们考虑那些不确定的边。考虑构图，把每一个不确定方向的边(i,j)记录一个编号x，连边<i,x>和<j,x>，分别表示i->j和j->i，流量为1，费用为0。也即每条边要么正向，要么反向。对于点i，如果新增加一条边，那么产生的贡献就是deg[i]*(n-3)*8，即新产生的边与之前每一条搭配一次，对应连边<i',i>，流量为1，费用为deg[i]*(n-3)*8，同时更新度数。最后源点连接每一个i'，汇点连接每一个x。构图完毕，跑一边最小费用最大流即可。
关于证明的话，其实可以yy一下。一个点i'->i的次数越多，对应的费用就越高，我们要最大化ans，那么就是要最小化费用，所以要在满足每条边都有确定方向的同时费用最小，对应就是最小费用流了。然后在实际操作中，*(n-3)*8是一个公因子，可以考虑最后再乘以它。设最小费用是cost，则最后的答案就是：
具体操作见代码：
#include<bits/stdc++.h>
#define LL long long
#define mod 998244353
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define INF 0x3f3f3f3f
#define sf(x) scanf("%d",&x)
#define sc(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define clr(x,n) memset(x,0,sizeof(x[0])*(n+5))
#define file(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)
using namespace std;
const int N = 1e3 + 10;
struct Edge{int from,to,cap,flow,cost;};
int n,m,s,t,d[N];
int num[N][N],tot;
namespace MCMF
{
int n,m,s,t,d[N],p[N],a[N];
vector<Edge>edges;
vector<int>g[N];
bool inq[N];
void init(int a,int b,int c)
{
n=a; s=b; t=c;
edges.clear();
for(int i = 0;i<=n;i++)g[i].clear();
}
void AddEdge(int from,int to,int cap,int cost)
{
edges.push_back(Edge{from,to,cap,0,cost});
edges.push_back(Edge{to,from,0,0,-cost});
m=edges.size(); g[from].push_back(m-2); g[to].push_back(m-1);
}
bool BeintmanFord(int &flow,int &cost)
{
for(int i = 0;i<=t;i++)d[i]=INF;
memset(inq,0,sizeof(inq));
d[s]=0,a[s]=INF,inq[s]=1,p[s]=0;
queue<int> q; q.push(s);
while(!q.empty())
{
int u = q.front(); q.pop(); inq[u]=0;
for(int i = 0;i<g[u].size();i++)
{
Edge &e = edges[g[u][i]];
if(e.cap>e.flow&&d[e.to]>d[u]+e.cost)
{
d[e.to]=d[u]+e.cost; p[e.to]=g[u][i];
a[e.to]=min(a[u],e.cap-e.flow);
if(!inq[e.to]) {q.push(e.to); inq[e.to]=1;}
}
}
}
if(d[t]==INF)return false;
flow+=a[t]; cost+=a[t]*d[t];
int u = t;
while(u!=s)
{
edges[p[u]].flow+=a[t];
edges[p[u]^1].flow-=a[t];
u=edges[p[u]].from;
}
return true;
}
int Min_cost(int &flow,int &cost)
{
flow=0,cost=0;
while(BeintmanFord(flow,cost));
return cost;
}
}
char ss[N][N];
int main()
{
int T; sf(T);
while(T--)
{
sf(n); tot=0;
clr(d,n);
for(int i=0;i<n;i++)
{
scanf("%s",ss[i]);
for(int j=0;j<i;j++)
{
if (ss[i][j]=='2'&&ss[j][i]=='2') num[i][j]=2*n+(++tot);
if (ss[i][j]=='1') d[i]++;
if (ss[i][j]=='0') d[j]++;
}
}
int res=0;
for(int i=0;i<n;i++)
res+=d[i]*(d[i]-1)/2;
int s=2*n+tot+1,t=s+1;
MCMF::init(t,s,t);
for(int i=0;i<n;i++)
for(int j=0;j<i;j++)
if (ss[i][j]=='2')
{
d[i]++; d[j]++;
MCMF::AddEdge(i,i+n,1,d[i]-1);
MCMF::AddEdge(j,j+n,1,d[j]-1);
MCMF::AddEdge(i+n,num[i][j],1,0);
MCMF::AddEdge(j+n,num[i][j],1,0);
MCMF::AddEdge(num[i][j],t,1,0);
}
for(int i=0;i<n;i++)
MCMF::AddEdge(s,i,INF,0);
int flow,cost;
MCMF::Min_cost(flow,cost);
cost=(cost+res)*(n-3)*8;
printf("%d\n",n*(n-1)*(n-2)*(n-3)-cost);
}
return 0;
}