UVa 12529 Fix the Pond

原创于 2025-10-16 08:59:16 发布 · 809 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#算法

图遍历专栏收录该内容

41 篇文章

订阅专栏

题目描述

有一个矩形虾塘，尺寸为 $2 N$ 行 × $(2 N + 1)$ 列的正方形单元格。池塘中放置了 $\times N$ 个长度为 $2$ 米的屏障，这些屏障的中点固定在特定的整数坐标 $(a, b)$ 上，要求 $a$ 和 $b$ 同为奇数或同为偶数。

每个屏障可以绕其中点旋转，只能在垂直(V)或水平(H)两种方向之间切换。机器从左上角单元格 $(1, 1)$ 出发，需要遍历所有单元格恰好一次，最终到达左下角单元格 $(2 N, 1)$ 。

题目要求计算最少需要切换多少个屏障的方向，才能使得机器能够完成上述遍历任务。

常规思路分析

问题建模

这是一个典型的图论问题：

$1$ . 图的构建：将每个单元格视为图中的一个顶点
$2$ . 边的定义：相邻单元格之间如果没有屏障阻挡，则存在一条边
$3$ . 屏障的影响：屏障的方向决定了某些边是否存在
$4$ . 目标状态：寻找从 $(1, 1)$ 到 $(2 N, 1)$ 的哈密顿路径

可能的解法方向

$1$ . 搜索算法：

使用 $BFS\texttt{BFS}$ 或 $DFS\texttt{DFS}$ 搜索所有可能的屏障配置
但状态空间太大：每个屏障有 $2$ 种状态，共 $\times N$ 个屏障
状态数为 $2(2N−1)×N2^{(2N-1) \times N}$ ，对于 $\leq 300$ 不可行

$2$ . 动态规划：

按行或列进行状态转移
但状态设计复杂，需要记录当前行的连通性和屏障状态
实现难度大，状态数可能指数级增长

$3$ . 网络流/匹配：

将问题转化为最小费用流或二分图匹配
但建模复杂，需要处理度约束（路径中每个内部顶点度数为 $2$ ）

$4$ . 约束满足：

使用 $2-SAT\texttt{2-SAT}$ 或类似方法
但需要表达哈密顿路径的约束，较为困难

关键洞察与解法推导

问题转化的思考过程

是否可以通过其他方法解决本题呢？观察到题目要求机器遍历所有单元格恰好一次，这意味着最终需要形成一条从起点到终点的哈密顿路径。

我们知道，在哈密顿路径中，除了起点和终点外，每个内部顶点的度数必须为 $2$ 。然而，直接处理这种度约束比较复杂。

然后由于屏障切换操作的本质是改变图的连通性，我们可以从连通性的角度来思考这个问题：

$1$ . 初始状态分析：由于屏障的初始方向是任意的，整个网格可能被分割成多个连通分量
$2$ . 目标状态要求：最终需要整个网格形成一个单一的连通路径
$3$ . 操作效果分析：每次切换屏障方向可以改变局部的连通性，可能连接两个原本分离的连通分量

正确性证明

现在我们来分析为什么"连通块数减一"的方法是正确的：

观察 $1$ ：在目标状态下，整个网格必须是一个连通图，因为机器需要遍历所有单元格。

观察 $2$ ：每次屏障切换操作最多可以减少一个连通分量。这是因为切换一个屏障只能影响局部的连通性，最多将两个连通分量合并为一个。

观察 $3$ ：总是存在一种方式，通过切换屏障来连接任意两个相邻的连通分量。这是因为题目保证至少存在一种可行的重新配置方式。

推导：

设初始状态有 $k$ 个连通分量
目标状态需要 $1$ 个连通分量
每次操作最多减少 $1$ 个连通分量
因此至少需要 $k - 1$ 次操作
由于总是存在可行方案，所以 $k - 1$ 次操作是充分必要的

这个推理的关键在于认识到：屏障切换操作的主要作用是改变连通性，而目标状态对连通性的要求（单一连通分量）比度约束更容易处理。

参考代码

// Fix the Pond
// UVa ID: 12529
// Verdict: Accepted
// Submission Date: 2025-10-16
// UVa Run Time: 0.140s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>

using namespace std;

const int MAX = 605;
char b[MAX][MAX];  // 存储屏障方向信息，b[i][j] 表示第 i 行第 j 列的屏障方向
bool v[MAX][MAX];  // 访问标记数组，v[i][j] 表示单元格 (i,j) 是否被访问过
int n, cnt;        // n: 输入参数，cnt: 连通分量计数器
int dx[4] = {0, -1, 0, 1};  // 方向数组: 左、上、右、下
int dy[4] = {-1, 0, 1, 0};  // 对应的列坐标变化

// 检查从单元格 (x,y) 向方向 dir 移动是否可行
bool canMove(int x, int y, int dir) {
    bool evenX = (x % 2 == 0), evenY = (y % 2 == 0);  // 判断行列奇偶性
    // 根据坐标奇偶性的 4 种组合情况分别处理
    if (evenX && evenY) {
        // 偶数行偶数列
        if (dir == 0) return x == 1 || y == 1 || b[x - 1][y / 2] == 'H';  // 向左
        if (dir == 1) return x == 1 || y == 1 || b[x - 1][y / 2] == 'V';  // 向上
        if (dir == 2) return y == 1 || x == 2 * n || b[x][y / 2] == 'H';  // 向右
        return y == 1 || x == 2 * n || b[x][y / 2] == 'V';  // 向下
    }
    else if (evenX && !evenY) {
        // 偶数行奇数列
        if (dir == 0) return x == 2 * n || y == 1 || b[x][y / 2] == 'H';  // 向左
        if (dir == 1) return x == 1 || y == 2 * n + 1 || b[x - 1][(y + 1) / 2] == 'V';  // 向上
        if (dir == 2) return x == 1 || y == 2 * n + 1 || b[x - 1][(y + 1) / 2] == 'H';  // 向右
        return x == 2 * n || y == 1 || b[x][y / 2] == 'V';  // 向下
    }
    else if (!evenX && evenY) {
        // 奇数行偶数列
        if (dir == 0) return x == 2 * n || y == 1 || b[x][y / 2] == 'H';  // 向左
        if (dir == 1) return x == 1 || y == 1 || b[x - 1][y / 2] == 'V';  // 向上
        if (dir == 2) return x == 1 || y == 1 || b[x - 1][y / 2] == 'H';  // 向右
        return x == 2 * n || y == 1 || b[x][y / 2] == 'V';  // 向下
    }
    else {
        // 奇数行奇数列
        if (dir == 0) return x == 1 || y == 1 || b[x - 1][y / 2] == 'H';  // 向左
        if (dir == 1) return x == 1 || y == 1 || b[x - 1][y / 2] == 'V';  // 向上
        if (dir == 2) return y == 2 * n + 1 || x == 2 * n || b[x][(y + 1) / 2] == 'H';  // 向右
        return y == 2 * n + 1 || x == 2 * n || b[x][(y + 1) / 2] == 'V';  // 向下
    }
}

// BFS 遍历连通分量
void bfs(int sx, int sy) {
    queue<pair<int, int>> q;
    q.push({sx, sy});
    v[sx][sy] = true;
    while (!q.empty()) {
        auto [x, y] = q.front(); q.pop();  // 结构化绑定，C++17 特性
        // 检查四个方向的移动可能性
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            // 检查新坐标是否在网格内、未被访问且可以移动
            if (nx >= 1 && nx <= 2 * n && ny >= 1 && ny <= 2 * n + 1 && !v[nx][ny] && canMove(x, y, i)) {
                v[nx][ny] = true;
                q.push({nx, ny});
            }
        }
    }
}

int main() {
    while (cin >> n) {
        memset(v, 0, sizeof(v));  // 重置访问标记
        cnt = 0;  // 重置连通分量计数器
        // 读取屏障方向信息
        for (int i = 1; i <= 2 * n - 1; i++) cin >> (b[i] + 1);
        // 遍历所有单元格，统计连通分量
        for (int i = 1; i <= 2 * n; i++)
            for (int j = 1; j <= 2 * n + 1; j++)
                if (!v[i][j]) {
                    cnt++;  // 发现新的连通分量
                    bfs(i, j);  // 遍历该连通分量
                }
        // 输出最小切换次数：连通分量数 - 1
        cout << cnt - 1 << endl;
    }
    return 0;
}