Note -「拟阵交」& Solution -「CF 1284G」Seollal

$\mathscr{Description}$

  Link.

  给定张含空格和障碍格的 $n\times m$ 的地图。构造在四连通的空格中间放置墙壁的方案，使得：

• 所有空格在四连通意义下构成树；
• 除 $(1,1)$ 外，所有满足 $2\mid(i+j)$ 的空格 $(i,j)$ 不是树的叶子。

  $n,m\le20$，其实有多测，但根据数据规则可忽略。

$\mathscr{Solution}$

  草，这个 motivation 我实在编不下去了。总之看到 $n,m$ 很小，而且是“双限制”的构造，也许你能想到拟阵交。

  不妨称被钦定非叶的格子为黑格。发现直接翻译限制并不太拟阵，特别是“黑格不是叶子”，即黑格度数 $\ge2$ 这种限制。另一方面，若已经得到了一片满足黑格度数 $=2$ 的森林，在此基础上尝试让森林连通是非常简单的。因此，令 $U$ 为所有可能存在的四连通关系，构造：

$$\mathcal M_1=(U,\mathcal I_1),~\mathcal I_1=\{S\subseteq U\mid \text{no circle in }G'=(V,S)\};\\ \mathcal M_2=(U,\mathcal I_2),~\mathcal I_2=\{S\subseteq U\mid \forall u\in V_{\text{black}},d_u\le 2\}.$$

  不难证明 $\mathcal M_1$ 和 $\mathcal M_2$ 是拟阵，取它们的交中最大的一个集合 $S$。若 $S$ 中仍有某个 $u\in V_{\text{black}},d_u<2$，根据 $|S|$ 的最大性，一定不存在解。否则我们在 $S$ 的基础上加入额外的边让生成森林连通即可。复杂度为 $\mathcal O((nm)^3\alpha(nm))$。（虽然这里摆个 $\alpha$ 显得很矫情，但我觉得是得有的嘛。）

---

  然后是本题的主要矛盾：神 tm CF 摆道拟阵交，根本不会啊！

  于是，这里记一下拟阵交算法。拟阵相关问题属于前置知识。

  形式化地，对于定义在 $U$ 上的 $k$ 个拟阵 $\mathcal M_{1..k}$，它们的交为

$$\mathcal N=(U,\mathcal I_1\cap\cdots\cap\mathcal I_2).$$

为什么记作 $\mathcal N$？因为这一交的结果很可能不是拟阵。而对 $\mathcal N$ 的集族中最大集合的求解，就是所谓 $k-$拟阵交问题，不妨记作 $k-\text{MI}$。$k-\text{MI}$ 可以描述为：输入 $\mathcal M_{1..k}$ 与整数 $n$，判断是否存在 $|S|\ge n,S\in\mathcal N$。

  当 $k\ge3$ 时，喜闻乐见，$k-\text{MI}$ 是 NPC 问题。

证明

  当然，我们仅需证明 $3-\text{MI}$ 是 NPC 的。尝试将「二分图上的 Hamilton 路径问题」（已知的 NPC 问题）向其规约。

  对于一个二分连通图 $G=(V=V^{\text L}\cup V^{\text R},E)$，构造三个 $E$ 上的集族

$$\mathcal I_G=\{S\subseteq E\mid \text{no circle in }G'=(V,S)\},\\ \mathcal I_L=\{S\subseteq E\mid \forall u\in V_{G'}^{\text L},d_u\le 2\},\\ \mathcal I_R=\{S\subseteq E\mid \forall u\in V_{G'}^{\text R},d_u\le 2\}.$$

$\mathcal M_G=(E,\mathcal I_G)$ 即图拟阵，亦不难证明 $\mathcal M_L=(E,\mathcal I_L)$，$\mathcal M_R=(E,\mathcal I_R)$ 为拟阵。令 $\mathcal N=(E,\mathcal I_G\cap\mathcal I_L\cap\mathcal I_R)$，我们断言，$G$ 存在 Hamilton 回路，当且仅当 $\exists S\in\mathcal N,|S|=|V|-1$。

  充分性：$S$ 显然是 Hamilton 路的边集。

  必要性：Hamilton 路的边集显然一定是一个 $S$。

$\square$

  注：我对 NP-complete，NP-hard 这些概念辨析暂时不深刻。若对此有质疑，麻烦参考一下其他资料 w。

 

  不过，当 $k=2$ 时，拟阵交是 P 的，下面来构建这个算法。算法的核心是，对于当前解 $I$，构造一个有向二分图——交换图 $G_{\mathcal M_1,\mathcal M_2}(I)=(V=V^{\text{L}}\cup V^{\text{R}},E)$，其中

$$V^{\text{L}}=I,~V^{\text{R}}=U\setminus I;\\ \begin{aligned} E&=\{\langle x,y\rangle\in V^{\text{L}}\times V^{\text{R}}\mid (I\setminus\{x\})\cup\{y\}\in\mathcal I_1\}\\ &\cup~\{\langle x,y\rangle\in V^{\text{R}}\times V^{\text{L}}\mid (I\setminus\{x\})\cup\{y\}\in\mathcal I_2\}. \end{aligned}$$

  算法的其他部分比较平凡。给出算法：

$$\begin{array}{} \text{Algorithm: }2-\text{MI}.\\ \text{Input: two matroid }\mathcal M_1=(U,\mathcal I_1)\text{ and }\mathcal M_2=(U,\mathcal I_2).\\ \text{Output: an intersection }I\text{ of }\mathcal M_1\text{ and }\mathcal M_2\text{ of max size}. \end{array}\\ \begin{array}{r|l} 1& I\leftarrow\varnothing\\ 2& \textbf{repeat}:\\ 3& \quad G\leftarrow G_{\mathcal M_1,\mathcal M_2}(I)\\ 4& \quad X_1\leftarrow \{e\in U\setminus I\mid I\cup\{e\}\in\mathcal I_1\}\\ 5& \quad X_2\leftarrow \{e\in U\setminus I\mid I\cup\{e\}\in\mathcal I_2\}\\ 6& \quad P\leftarrow\text{the shortest path from }X_1\text{ to }X_2\text{ in }G\\ 7& \quad I\leftarrow I~\Delta~P\\ 8& \textbf{until }P\text{ does not exist.}\\ 9& \textbf{return }I. \end{array}$$

其中 $I~\Delta~P$ 为集合对称差，可以理解作集合异或。

  设 $r=\min\{r_1(U),r_2(U)\}$，不难得到该算法的复杂度为 $\mathcal O(r^2|U|)$，当然这里假设“属于独立集”的判定是 $\mathcal O(1)$ 的。

  等等，这玩意儿为什么是对的呢？

证明

  给出一个定理：

  最大最小定理 对于上述的 $\mathcal M_1,\mathcal M_2$，有

$$\max_{I\in\mathcal I_1\cap\mathcal I_2}\{|I|\}=\min_{S\subseteq U}\{r_1(S)+r_2(U\setminus S)\}.$$

  我们指出，该算法所输出的 $I$ 就是上式的一个 $\arg\max$。以下同时证明这两件事。

  首先，$\text{LHS}\le\text{RHS}$ 是显然的，我们只需要证明不等式的取等。令 $I$ 为上述算法的输出，$S$ 为 $G_{\mathcal M_1,\mathcal M_2}(I)$ 上所有可达 $X_2$ 的点集。尝试证明：$r_1(S)\le|I\cap S|$。

  反证。若 $r_1(S)>|I\cap S|$，则 $\exists x\in S\setminus I$，使得 $(I\cap S)\cup\{x\}\in\mathcal I_1$。另一方面，由于 $X_1,X_2$ 不连通，所以 $I\cup\{x\}\notin\mathcal I_1$。注意到 $I\in\mathcal I_1$，所以 $I\cup\{x\}$ 含有恰一个环 $C$。如果 $\forall y\in C\setminus\{x\},~y\in S$，那么 $C\subseteq (I\cap S)\cup\{x\}$，这与其 $\in\mathcal I_1$ 矛盾。因此 $\exists y\in C,~y\notin S$。此时，$(I\setminus\{y\})\cup\{x\}\in\mathcal I_1$。进一步地 $\lang y,x\rang\in E_G$，则 $y\in S$，矛盾。

  $r_2(U\setminus S)\le|I\cup(U\setminus S)|$ 同理。又由于

$$|I|=|I\cap S|+|I\cap(U\setminus S)|\le r_1(S)+r_2(U\setminus S),$$

所以 $I$ 取等啦。我们已经证明了最大最小定理。

  此外，我们还需要证明 $I~\Delta~P$ 恒为独立集。这里先偷个懒，去读论文嘛。不过值得一提的是，$P$ 是最短路保证了 $P$ 除起点外的 $|P|-1$ 个点在二分图上有唯一完美匹配，因而才能保证 $I~\Delta~P$ 独立。

$\square$

  写的时候注意分清 $\mathcal I_1,\mathcal I_2$，一个集合到底需要在谁中的独立。调麻了 qwq。

$\mathscr{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

const int MAXN = 20, IINF = 0x3f3f3f3f;
const int MOVE[4][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
int n, m, deg[MAXN * MAXN + 5];
char maz[MAXN + 5][MAXN + 5], str[MAXN * 2 + 5][MAXN * 2 + 5];

inline bool inside(const int i, const int j) {
    return 1 <= i && i <= n && 1 <= j && j <= m;
}

inline int id(const int i, const int j) {
    return (i - 1) * m + j;
}

struct DSU {
    int fa[MAXN * MAXN + 5], siz[MAXN * MAXN + 5];
    inline void init() { rep (i, 1, n * m) siz[fa[i] = i] = 1; }
    inline int find(const int x) {
        return x == fa[x] ? x : fa[x] = find(fa[x]);
    }
    inline bool unite(int x, int y) {
        if ((x = find(x)) == (y = find(y))) return false;
        if (siz[x] < siz[y]) x ^= y ^= x ^= y;
        return siz[fa[y] = x] += siz[y], true;
    }
};

namespace MI { // Matroid Intersection.

std::vector<PII> U;
std::vector<int> ans, dis, L, R, T;
std::queue<int> que;
DSU dsu;

inline void initInd() {
    dsu.init();
    rep (i, 1, n) rep (j, 1, m) deg[id(i, j)] = (i + j) & 1 ? -IINF : 0;
    deg[1] = -IINF;
    rep (i, 0, int(U.size()) - 1) if (ans[i]) {
        dsu.unite(U[i].fi, U[i].se), ++deg[U[i].fi], ++deg[U[i].se];
    }
}

inline void build() {
    initInd();
    L.clear(), R.clear();
    T.clear(), T.resize(U.size());
    dis.clear(), dis.resize(U.size(), IINF);
    rep (i, 0, int(U.size()) - 1) {
        if (ans[i]) L.push_back(i);
        else {
            R.push_back(i);
            if (deg[U[i].fi] < 2 && deg[U[i].se] < 2) T[i] = true;
            if (dsu.find(U[i].fi) != dsu.find(U[i].se)) {
                que.push(i), dis[i] = 0;
            }
        }
    }
}

inline std::vector<int> augment() {
    int fin = -1;
    std::vector<int> pre(U.size(), -1);
    while (!que.empty()) {
        int u = que.front(); que.pop();
        if (T[u]) { fin = u; break; }
        if (ans[u]) {
            dsu.init();
            for (int x: L) if (x != u) dsu.unite(U[x].fi, U[x].se);
            for (int v: R) {
                if (dis[v] == IINF && dsu.find(U[v].fi) != dsu.find(U[v].se)) {
                    dis[v] = dis[u] + 1, pre[v] = u, que.push(v);
                }
            }
        } else {
            for (int v: L) if (dis[v] == IINF) {
                ++deg[U[u].fi], ++deg[U[u].se];
                --deg[U[v].fi], --deg[U[v].se];
                if (deg[U[u].fi] <= 2 && deg[U[u].se] <= 2
                  && deg[U[v].fi] <= 2 && deg[U[v].se] <= 2) {
                    dis[v] = dis[u] + 1, pre[v] = u, que.push(v);
                }
                --deg[U[u].fi], --deg[U[u].se];
                ++deg[U[v].fi], ++deg[U[v].se];
            }
        }
    }
    if (!~fin) return {};
    while (!que.empty()) que.pop();
    std::vector<int> ret;
    ret.push_back(fin);
    while (~pre[fin]) ret.push_back(fin = pre[fin]);
    return ret;
}

inline void solve() {
    ans.clear(), ans.resize(U.size());
    while (true) {
        build();
        auto&& res(augment());
        if (res.empty()) break;
        for (int id: res) ans[id] ^= 1;
    }
}

} // namespace MI.

int main() {
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &n, &m);
        rep (i, 1, n) scanf("%s", maz[i] + 1);

        MI::U.clear();
        rep (i, 1, n) rep (j, 1, m) {
            if (~(i + j) & 1 && id(i, j) != 1 && maz[i][j] == 'O') {
                rep (k, 0, 3) {
                    int x = i + MOVE[k][0], y = j + MOVE[k][1];
                    if (inside(x, y) && maz[x][y] == 'O') {
                        MI::U.emplace_back(id(i, j), id(x, y));
                    }
                }
            }
        }

        MI::solve();
        MI::initInd();
        rep (i, 1, n) rep (j, 1, m) {
            if (~(i + j) & 1 && id(i, j) != 1
              && maz[i][j] == 'O' && deg[id(i, j)] != 2) {
                puts("NO"); goto FIN;
            }
        }
        rep (i, 1, 2 * n - 1) {
            rep (j, 1, 2 * m - 1) {
                str[i][j] = i & 1 && j & 1 ? maz[i + 1 >> 1][j + 1 >> 1] : ' ';
            }
            str[i][2 * m] = '\0';
        }

        
        if (maz[1][2] == 'O') {
            MI::U.emplace_back(id(1, 1), id(1, 2)), MI::ans.push_back(0);
        }
        if (maz[2][1] == 'O') {
            MI::U.emplace_back(id(1, 1), id(2, 1)), MI::ans.push_back(0);
        }
        rep (i, 0, int(MI::U.size()) - 1) {
            if (MI::dsu.find(MI::U[i].fi) != MI::dsu.find(MI::U[i].se)) {
                MI::dsu.unite(MI::U[i].fi, MI::U[i].se);
                MI::ans[i] = true;
            }
        }
        rep (i, 1, n) rep (j, 1, m) {
            if (maz[i][j] == 'O' && MI::dsu.find(id(i, j))
              != MI::dsu.find(id(1, 1))) {
                puts("NO"); goto FIN;
            }
        }

        rep (i, 0, int(MI::U.size()) - 1) if (MI::ans[i]) {
            int b = (MI::U[i].fi - 1) % m + 1, a = (MI::U[i].fi - b) / m + 1;
            int d = (MI::U[i].se - 1) % m + 1, c = (MI::U[i].se - d) / m + 1;
            str[a + c - 1][b + d - 1] = 'O';
        }
        puts("YES");
        rep (i, 1, 2 * n - 1) puts(str[i] + 1);
        FIN: ;
    }
    return 0;
}