\(\mathcal{Description}\)
Link.
在一个 \(n\times n\) 的方格图中，有一些格子已经放了零件，有一些格子可以放零件，其余格子不能放零件。求至多放多少个零件，满足第 \(i\) 行与第 \(i\) 列中零件个数相等；任意一行或一列的零件数量不超过总数量的 \(\frac{A}{B}\)。\(n\le40\)。
\(\mathcal{Solution}\)
能猜测是行列连边的二分图网络模型，但注意到网络流很难处理 \(\frac{A}{B}\) 这个比较“全局性”的限制，这提示我们可以直接枚举行列个数上限 \(x\)，若能求出在此上限下最多放置的零件个数就能判断是否合法了。
进一步，对于每个方格“放不放零件”这一问题，在网络中必须保证只有两种状态。即，每个方格都明确“放”还是“不放”。黑白染色的最小割在这里不使用，我们转而考虑用“流最大”来限制每个方格都明确选择，用网络流的另一个维度——费用，来得到答案最大。
我已经尽力描述这题的 motivation 了 qwq，接下来直接给出建图模型：
-
\(S\) 连向行点 \(r_i\)，流量为第 \(i\) 行已放和能放的零件数量，费用为 \(0\)；
-
\(r_i\) 连向列点 \(c_i\)，流量为枚举的 \(x\)，费用为 \(0\)；
-
\(c_i\) 连向 \(T\)，流量为第 \(i\) 列已放和能放的零件数量，费用为 \(0\)；
-
对于能放但未放的格子 \((i,j)\)，连接 \(r_i,c_j\)，流量为 \(1\)，费用为 \(1\)。
注意把“放的最大”转为“不放的最小”，再用最小费用流。
\(\mathcal{Code}\)
/*+Rainybunny+*/
#include <bits/stdc++.h>
#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)
typedef std::pair<int, int> PII;
#define fi first
#define se second
inline int imax(const int u, const int v) { return u < v ? v : u; }
inline int imin(const int u, const int v) { return u < v ? u : v; }
const int MAXN = 40, IINF = 0x3f3f3f3f;
int n, A, B, row[MAXN + 5], col[MAXN + 5];
char str[MAXN + 5][MAXN + 5];
namespace CFG { // cost flow graph.
const int MAXND = MAXN * 2 + 2, MAXEG = MAXN * (MAXN + 3);
int S, T, ecnt = 1, head[MAXND + 5], curh[MAXND + 5];
int dis[MAXND + 5], hig[MAXND + 5];
bool instk[MAXND + 5];
struct Edge { int to, flw, cst, nxt; } graph[MAXEG * 2 + 5];
inline void clear() {
ecnt = 1;
rep (i, S, T) head[i] = hig[i] = dis[i] = instk[i] = 0;
}
inline void link(const int s, const int t, const int f, const int c) {
// printf("%d %d %d %d\n", s, t, f, c);
graph[++ecnt] = { t, f, c, head[s] }, head[s] = ecnt;
graph[++ecnt] = { s, 0, -c, head[t] }, head[t] = ecnt;
}
inline bool dijkstra() {
static std::priority_queue<PII, std::vector<PII>, std::greater<PII> > heap;
rep (i, S, T) hig[i] += dis[i], dis[i] = IINF;
heap.push({ dis[S] = 0, S });
while (!heap.empty()) {
PII p(heap.top()); heap.pop();
if (dis[p.se] != p.fi) continue;
for (int i = head[p.se], v; i; i = graph[i].nxt) {
int d = p.fi + graph[i].cst + hig[p.se] - hig[v = graph[i].to];
assert(!graph[i].flw || graph[i].cst + hig[p.se] - hig[v] >= 0);
if (graph[i].flw && dis[v] > d) heap.push({ dis[v] = d, v });
}
}
return dis[T] != IINF;
}
inline PII augment(const int u, int iflw) {
if (u == T) return { iflw, 0 };
PII ret(0, 0); instk[u] = true;
for (int &i = curh[u], v; i; i = graph[i].nxt) {
if (graph[i].flw && !instk[v = graph[i].to]
&& dis[v] == dis[u] + hig[u] - hig[v] + graph[i].cst) {
PII tmp(augment(v, imin(iflw, graph[i].flw)));
ret.fi += tmp.fi, ret.se += graph[i].cst * tmp.fi + tmp.se;
iflw -= tmp.fi, graph[i].flw -= tmp.fi, graph[i ^ 1].flw += tmp.fi;
if (!iflw) break;
}
}
if (ret.fi) instk[u] = false;
return ret;
}
inline PII dinic() {
PII ret(0, 0);
while (dijkstra()) {
rep (i, S, T) curh[i] = head[i], instk[i] = false;
PII tmp(augment(S, IINF));
ret.fi += tmp.fi, ret.se += tmp.se;
}
return ret;
}
} // namespace CFG.
int main() {
while (~scanf("%d %d %d", &n, &A, &B) && n | A | B) {
static int cas = 0; printf("Case %d: ", ++cas);
rep (i, 1, n) scanf("%s", str[i] + 1), row[i] = col[i] = 0;
int all = 0, own = 0;
rep (i, 1, n) rep (j, 1, n) {
bool f = str[i][j] == '.' || str[i][j] == 'C';
row[i] += f, col[j] += f, all += f, own += str[i][j] == 'C';
}
int ans = -1;
rep (x, 0, n) {
CFG::S = 0, CFG::T = n << 1 | 1, CFG::clear();
rep (i, 1, n) {
CFG::link(CFG::S, i, row[i], 0);
CFG::link(i + n, CFG::T, col[i], 0);
CFG::link(i, i + n, x, 0);
}
rep (i, 1, n) rep (j, 1, n) if (str[i][j] == '.') {
CFG::link(i, j + n, 1, 1);
}
PII res(CFG::dinic());
// printf("%d: %d %d\n", x, res.fi, res.se);
if (res.fi == all && (all - res.se) * A >= x * B) {
ans = imax(ans, all - res.se);
}
}
if (~ans) printf("%d\n", ans - own);
else puts("impossible");
}
return 0;
}