c++实现岛问题(并查集)

最新推荐文章于 2024-07-27 12:18:13 发布

alxe_made

最新推荐文章于 2024-07-27 12:18:13 发布

阅读量1.1k

点赞数

分类专栏： C++ 文章标签：岛屿问题并查集

本文链接：https://blog.csdn.net/alxe_made/article/details/95732902

版权

C++ 专栏收录该内容

49 篇文章 8 订阅

订阅专栏

1. 问题描述

一个矩阵中只有0和1两种值,每个位置都可以和自己的上、下、左、右四个位置相连,如果有一片1连在一起,这个部分叫做一个岛,求一个矩阵中有多少个岛?

比如：
0 0 1 0 1 0
1 1 1 0 1 0
1 0 0 1 0 0
0 0 0 0 0 0

这个矩阵中有三个岛。

2. 思路

我们的主体是进行二维数组的遍历，同时我们也定义一个感染函数。比如我们遇到一个1时候，我们对这个点的上下作用进行感染，让其赋值为2，所以会导致一片为1的点都会被感染为2，只统计第一个1，然后进行计数就会得到所有的岛屿数目。

3. 代码

#include <iostream>
#include <vector>

void infectLands(std::vector<std::vector<int>>& lands, int N, int M, int n, int m) {
    if (n < 0 || n >=N || m < 0 || m >= M || lands[n][m] != 1) {
        return;
    }
    lands[n][m] = 2;
    infectLands(lands, N, M, n + 1, m);
    infectLands(lands, N, M, n - 1, m);
    infectLands(lands, N, M, n, m + 1);
    infectLands(lands, N, M, n, m - 1);
}

int countIslands(std::vector<std::vector<int>>& lands) {
    if (lands.size() == 0 || lands[0].size() == 0) {
        return 0;
    }
    int res = 0;
    int N = lands.size();
    int M = lands[0].size();
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            if (lands[i][j] == 1) {
                res ++;
                infectLands(lands, N, M, i, j);
            }

        }
    }
    return res;
}

int main()
{
    std::vector<std::vector<int>> lands =  {{0, 0, 1, 0, 1, 0},
                                        {1, 1, 1, 0, 1, 0},
                                        {1, 0, 0, 1, 0, 0},
                                        {0, 0, 0, 0, 0, 0}};
    std::cout << countIslands(lands) << std::endl;
    return 0;
}

在这里插入图片描述

4. 进一步扩展

现在我们对岛问题进行扩展，加入我们现在这个岛很大，那么有没有什么方法快速求解了。

方法：一种直观的思想就是使用分治的思想，也就是我们可以先划分，然后进行合并。但是现在有一个问题，因为每一块边界上也有可能连成一片，这样我们在求解的时候还是很复杂的。针对边界，我们借助并查集这种方法。

5. 并查集简单介绍

参考文献：

一般介绍并查集都是先引入畅通工程这个例子。

5.1 畅通工程

Problem Description

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

Input

测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。

Output

对每个测试用例，在1行里输出最少还需要建设的道路数目。

Sample Input

4 2
1 3
4 3
3 3
1 2
1 3
2 3
5 2
1 2
3 5
999 0
0

Sample Output

1
0
2
998

Hint

Huge input, scanf is recommended.

5.2 并查集求解畅通工程

#include <iostream>

const int MAX = 1000;
int father[MAX];

void initUnionSet(int n) {
    for (int i = 1; i <= n; ++i) {
        father[i] = i;
    }
}

int findUnionSet(int x) {
    int root = x;
    while (root != father[root]) {
        root = father[root];
    } // get the root
    int node = x;
    while (node != root) {
        int temp = father[node];    // save the temp node
        father[node] = root;   // compress path
        node = temp;
    }
    return root;    // return the root
}

void combine(int unionSet1, int unionSet2) {
    int root1 = findUnionSet(unionSet1);
    int root2 = findUnionSet(unionSet2);
    if (root1 != root2) {
        father[root1] = root2;
    }
}

int findAns(int n) {
    int sum = 0;
    for (int i = 1; i <= n; ++i) {
        if (father[i] == i) {
            ++sum;
        }
    }
    return sum;
}

int main() {
    int m, n, a, b;
    while (std::cin>>n) {
        if (int(n) == 0) break;
        initUnionSet(n);
        std::cin >> m;
        for (int i = 1; i <= m; ++i) {
            std::cin >> a >> b;
            combine(a, b);
        }
        std::cout << "outpus: " << findAns(n) - 1 << std::endl;
    }

    return 0;
}