题解：SDOI2017 新生舞会

Description

学校组织了一次新生舞会，Cathy 作为经验丰富的老学姐，负责为同学们安排舞伴。

有 $n$ 个男生和 $n$ 个女生参加舞会。一个男生和一个女生一起跳舞，互为舞伴。

Cathy 收集了这些同学之间的关系，比如两个人之前认不认识，计算得出 $a_{i,j}$ ，表示第 $i$ 个男生和第 $j$ 个女生一起跳舞获得的愉快程度。

Cathy 还需要考虑两个人一起跳舞是否方便，比如身高体重差别会不会太大，计算得出 $b_{i,j}$ ，表示第 $i$ 个男生和第 $j$ 个女生一起跳舞时的不协调程度。

一个方案中有 $n$ 对舞伴，假设每对舞伴的愉快程度分别为 $a'_1,a'_2,\dots,a'_n$ ，不协调程度分别为 $b'_1,b'_2,\dots,b'_n$ ，

我们令

\[\large
C = \frac{\sum_{i = 1}^{n} a'_i}{\sum_{i = 1}^{n} b'_i}
\]

Cathy 希望方案的 C 值最大。

当然，还需要考虑许多其他问题。

Cathy 想先用一个程序通过 $a_{i,j}$ 和 $b_{i,j}$ 求出一种方案，再手动对方案进行微调。

Cathy 找到你，希望你帮她写那个程序。

$1 \leq n \leq 100, 1 \leq a_{i,j},b_{i,j} \leq 10^4$

Algorithm

看见题目给了个 $\large C = \frac{\sum_{i = 1}^{n} a'_i}{\sum_{i = 1}^{n} b'_i}$ 的式子，阅题无数的同学一定就知道怎么做了：分数规划嘛。

题目要求最优化地安排一种方案，使得给定的描述方案性价比的比例式取得最值。

除非你能证明某种贪心策略的正确性，否则从正面考虑这样的问题是极端困难的。

01分数规划的思路则是从反面入手，我们二分答案。

我们二分最终的比值 $C$ ，如果存在某种方案的比值更优，则存在：

\[\begin{align*}
&\frac{\sum_{i = 1}^{n} a'_i}{\sum_{i = 1}^{n} b'_i} > C \\
\Rightarrow &\sum_{i = 1}^{n} a'_i > C \cdot \sum_{i = 1}^{n} b'_i \\
\Rightarrow &\sum_{i = 1}^{n} (C \cdot b'_i - a'_i) < 0
\end{align*}
\]

反之同理。

于是问题变成了不断验证是否存在 $\sum_{i = 1}^{n} (C \cdot b'_i - a'_i) > 0$ 继而不断缩小 $C$ 的可能取值范围。

换言之，如果我们实现了一个 $check(c)$ 函数能实现对应功能的话，就只需要这样写：

double l = 0, r = 1e6, mid;
while(r - l > eps)
{
    mid = (l + r) / 2;
    if(check(mid) < 0)	l = mid;
    else				r = mid;
}

我以为分数规划是一个令人心潮澎湃的算法。它既有理性的色彩，又极富暴力的美感，而且简单得惊人。

接下来考虑如何实现这个 $check(c)$ 。

先把题面上那个 $a'_i,b'_i$ 的一撇的扒掉。

现在问题本质上是给定一个矩阵 $c$ ，满足 $c_{i,j} = (C \cdot b_{i,j} - a_{i,j})$ ，

要求要在矩阵中选出 $n$ 个数字，满足不存在任意两个选中的数组在同一行或同一列。

怎么做呢？

我会暴力！$O(n!)$ 全排列！

……那还分数规划干啥
我会状压 DP ！用 $dp_{i,j}$ 表示现在考虑到第 $i$ 行，所有列是否已经取数的状态压缩成数字 $j$ 。

……复杂度 $O(n^2 \cdot 2^n \cdot log 1e6)$ ，大概能过 $40\%$ ？

我会费用流！

可以发现问题本质上是个男女匹配问题，于是考虑建立费用流模型。

考虑样例

\[a=\begin{bmatrix}
19 & 17 & 16 \\
25 & 24 & 23 \\
35 & 36 & 31 \\
\end{bmatrix}
,~~
b = \begin{bmatrix}
9 & 5 & 6 \\
3 & 4 & 2 \\
7 & 8 & 9 \\
\end{bmatrix}
\]

假如我们要验证 $C = 1$ 的情况，那么有

\[c = \begin{bmatrix}
10 & 12 & 10 \\
22 & 20 & 21 \\
28 & 28 & 22 \\
\end{bmatrix}
\]

建立这样一个图（本来想标注权值的，但是太糊了还是算了吧）：

令图上所有边的流量上限都是 1 ，这就保证了最大流只能跑过图中的一些匹配。

令图中 $M_i \to F_j$ 的边权为 $c_{i,j}$ ，与 $s,t$ 连接的所有边权都为 0，那么我们需要验证的值就是跑最大流所经边权之和的最小值，也就是最小费用最大流。

有关最小费用最大流的实现，我是使用 $Dijkstra$ 配合势能函数魔改dinic的版本。

代码：

#include<bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
template<const int N, const int M>
class Graph {
private:
	typedef pair<double, int> Node;
	priority_queue<Node> que;
	const double INF = 1e7;
	int beg[N], nex[M], tar[M], cap[M], ite[N], len;
	double pot[N], dis[N], cst[M];
	bool vis[N];
public:
	int n, s, t;
	inline void clear() {
		memset(pot, 0, sizeof(pot));
		memset(beg, 0, sizeof(beg));
		memset(nex, 0, sizeof(nex));
		len = 1;
	}
	Graph() {
		clear();
	}
	inline void add_edge(int a, int b, int c, double d)
	{
		++len, tar[len] = b, cap[len] = c, cst[len] = d;
		nex[len] = beg[a], beg[a] = len;
	}
	inline void add_pipe(int a, int b, int c, double d)
	{
		add_edge(a, b, c, +d);
		add_edge(b, a, 0, -d);
	}
	inline bool dijkstra(int s, int t)
	{
		fill(dis, dis + n + 1, INF);
		que.push(Node(dis[s] = 0, s));
		while(!que.empty())
		{
			Node cur = que.top();	que.pop();
			int u = cur.second;
			if(-cur.first > dis[u])	continue;
			for(int i = beg[u]; i; i = nex[i])
			{
				int v = tar[i];
				double tmp = dis[u] + cst[i] + pot[u] - pot[v];
				if(cap[i] && dis[v]- tmp > eps)
					que.push(Node(-(dis[v] = tmp), v));
			}
		}
		return dis[t] < INF;
	}
	int dfs(int u, int flo)
	{
		if(u == t)	return flo;
		int rst = flo;
		vis[u] = true;
		for(int &i = ite[u]; i; i = nex[i])
		{
			int v = tar[i];
			if(vis[v] || !cap[i])	continue;
			double tmp = dis[u] + cst[i] + pot[u] - pot[v];
			if(fabs(tmp - dis[v]) < eps)
			{
				int res = dfs(v, min(rst, cap[i]));
				rst -= res;
				cap[i] -= res;
				cap[i ^ 1] += res;
			}
		}
		vis[u] = false;
		return flo - rst;
	}
	inline Node costflow()
	{
		Node ret = Node(0, 0);
		while(dijkstra(s, t))
		{
			memcpy(ite, beg, sizeof(ite));
			int res = dfs(s, INF);
			for(int i = 1; i <= n; ++i)
				if(dis[i] < INF)	pot[i] += dis[i];
			ret.first += res * pot[t];
			ret.second += res;
		}
		return ret;
	}
};
template<class T>
inline void read(T &x)
{
	char c = getchar();	x = 0;
	while(c < '0' || '9' < c)	c = getchar();
	while('0' <= c && c <= '9')
	{
		x = (x << 1) + (x << 3) + c - 48;
		c = getchar();
	}
}
int n, a[128][128], b[128][128];
Graph<256, 32768> G;
double check(double c)
{
	G.clear();
	G.s = n + n + 2, G.n = G.t = G.s + 1;
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			G.add_pipe(i, j + n, 1, - a[i][j] + c * b[i][j]);
	for(int i = 1; i <= n; ++i)
	{
		G.add_pipe(G.s, i, 1, 0);
		G.add_pipe(i + n, G.t, 1, 0);
	}
	return G.costflow().first;
}
int main()
{
	read(n);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			read(a[i][j]);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			read(b[i][j]);
	double l = 0, r = 1e6, mid;
	while(r - l > eps)
	{
		mid = (l + r) / 2;
		if(check(mid) < 0)	l = mid;
		else				r = mid;
	}
	cout << fixed << setprecision(6) << mid << endl;
	return 0;
}