机试题——农田修复

题目描述

小明的农田受到地震的破坏，农田中的一些网点断开了联系。假设原本的农田网构成一个矩形，其中未被破坏的网点标记为1，被破坏的网点标记为0。标记为1的网点连在一起构成一个子网。现在，小明需要找到一个目标网点，并找出离它最近的其他子网。请注意，两个网点相连只能通过上下左右四个方向，不可以通过斜对角相连。两个网点的距离定义为从一个网点（假设网点名为C）到达另一个网点（假设网点名为D）需要经过相连网点的最小数目（C和D这两个网点不计算在内）。两个子网（假设分别为A网和B网）不相连，A网中所有的网点与B网中所有的网点的距离中最小的那个即为A网和B网的最小距离。

输入描述

1. 第一行：两个正整数x和y，表示目标网点的坐标位置（x表示行号，y表示列号）。
2. 第二行：两个正整数n和m，表示农田矩形的行数n和列数m。
3. 接下来n行：每行包含m个以空格分隔的整数0或1，表示农田网点的破坏情况。

输出描述

输出一个整数，表示最近的未被破坏子网的距离。如果整网中只有一个子网，则返回-1。

用例输入

1 1
6 6
1 1 0 0 1 0
1 1 0 0 1 1
0 0 0 0 1 0
0 1 0 1 0 0
1 1 0 0 0 0
1 1 1 0 1 1

1

解题思路

1. 问题建模
   该问题可以看作是一个图论问题，目标是找到目标网点所在子网到其他子网的最短距离。具体步骤如下：

• 标记子网：将每个连通的子网标记为不同的编号。
• 计算最短距离：从目标网点开始，计算目标子网到其他子网的最短距离。

2. 数据结构

• 二维数组mp：存储农田网点的破坏情况，1表示未破坏，0表示破坏。
• 队列queue：用于实现广度优先搜索（BFS）。
• 二维数组dis：记录每个网点到目标子网的最短距离。

3. 标记子网
   使用BFS遍历整个农田，将每个连通的子网标记为不同的编号：

4. 初始化：

   • 创建一个编号变量num，从2开始，用于标记不同的子网。

5. 遍历农田：

   • 遍历每个网点，如果当前网点为1且未被标记，则启动BFS。
   • 在BFS中，将当前子网的所有网点标记为num，并将这些网点加入队列。
   • 每次BFS完成后，num加1。

6. 结束条件：

   • 遍历完整个农田后，所有子网都被标记。

7. 计算最短距离
   从目标网点开始，使用BFS计算目标子网到其他子网的最短距离：

8. 初始化：

   • 创建一个队列q，用于BFS。
   • 创建一个二维数组dis，记录每个网点到目标子网的最短距离，初始值为INT_MAX。
   • 将目标子网的所有网点加入队列，并将它们的初始距离设为0。

9. BFS遍历：

   • 从队列中取出一个网点，检查其上下左右四个方向的相邻网点。
   • 如果相邻网点未被破坏且未被访问过，则将该网点加入队列，并更新其距离。

10. 结束条件：

    • 队列为空时，BFS结束。

11. 计算结果：

    • 遍历dis数组，找到最近的未被破坏子网的距离。
    • 如果整网中只有一个子网，返回-1。

12. 输出结果

• 如果整网中只有一个子网，返回-1。
• 否则，输出最近的未被破坏子网的距离。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<set>
#include<list>
#include<sstream>
#include<bitset>
#include<stack>
#include<climits>
#include<iomanip>
#include<cstdint>
using namespace std;

int mp[1005][1005];
int n, m;
bool check(int x, int y) {
    if (x < 0 || x >= n || y < 0 || y >= m) return false;
    if (mp[x][y] == 0) return false;
    return true;
}

int dx[4] = { 0,0,1,-1 };
int dy[4] = {1,-1,0,0};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int x, y;
    cin >> x >> y;
    x--;
    y--;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> mp[i][j];
        }
    }
    // 先遍历图所有子网节点
    int num = 2; // 节点编号从2开始，标示不同的子网
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mp[i][j] == 1) {
                queue<pair<int, int>> q;
                mp[i][j] = num;
                q.push({i, j});
                while (!q.empty()) {
                    int cx = q.front().first;
                    int cy = q.front().second;
                    q.pop();
                    for (int k = 0; k < 4; k++) {
                        int nx = cx + dx[k];
                        int ny = cy + dy[k];
                        if (!check(nx, ny)) continue;
                        else {
                            if (mp[nx][ny] == 1) {
                                mp[nx][ny] = num;
                                q.push({nx, ny});
                            }
                        }
                    }
                }
                num++;
            }
        }
    }
    if (num == 3) {
        cout << -1;
        return 0;
    }

    int cur = mp[x][y];
    queue<vector<int>> q;
    vector<vector<int>> dis(n, vector<int>(m, INT_MAX));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mp[i][j] == cur) {
                q.push({i, j, 0});
                dis[i][j] = 0;
            }
        }
    }
    int res = INT_MAX;
    while (!q.empty()) {
        int cx = q.front()[0];
        int cy = q.front()[1];
        int cd = q.front()[2];
        q.pop();
        for (int k = 0; k < 4; k++) {
            int nx = cx + dx[k];
            int ny = cy + dy[k];
            int nd = cd + 1;
            if (nx < 0 || nx >= n || ny < 0 || ny >= m || mp[nx][ny] == cur) continue;
            if (dis[nx][ny] > nd) {
                dis[nx][ny] = nd;
                q.push({nx, ny, nd});
            }
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mp[i][j] != 0 && mp[i][j] != cur) {
                res = min(res, dis[i][j]);
            }
        }
    }
    cout << res - 1;
    return 0;
}