可以组成网络的服务器--并查集/DFS

题目描述：

在一个机房中，服务器的位置标识在 n*m 的整数矩阵网格中，1 表示单元格上有服务器，0表示没有。如果两台服务器位于同一行或者同一列中紧邻的位置，则认为它们之间可以组成一个局域网。
请你统计机房中最大的局域网包含的服务器个数。

输入描述

第一行输入两个正整数，n和m，
0<n,m<=100
之后为n*m的二维数组，代表服务器信息
输出描述
最大局域网包含的服务器个数。

示例

输入

22
10
11

输出

3

说明
[0,0]、[1,0]、 [1,1]三台服务器相互连接，可以组成局域网

答案1：

可以使用并查集的方法。关于并查集的概念，可以参考【算法与数据结构】—— 并查集

我们的方法就是按照上述概念来的，除了加权标记法没有用到，其余都用到了。
代码如下：

#include <iostream>
#include <vector>

using namespace std;

class UnionFind {
public:
    vector<int> parent;
    vector<int> size;
    int maxServers;
    
    UnionFind(int n) {
        parent.resize(n);
        size.resize(n, 1);
        maxServers = 1;
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    void unite(int x, int y) {
        int rootx = find(x);
        int rooty = find(y);
        if (rootx != rooty) {
            parent[rootx] = rooty;
            size[rooty] += size[rootx];
            maxServers = max(maxServers, size[rooty]);
        }
    }
};

int maxLocalArea(vector<vector<int> >& grid) {
    if (grid.empty() || grid[0].empty()) {
        return 0;
    }

    int n = grid.size();
    int m = grid[0].size();
    UnionFind uf(n * m);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) {
                if (i > 0 && grid[i - 1][j] == 1) {
                    uf.unite(i * m + j, (i - 1) * m + j);
                }
                if (j > 0 && grid[i][j - 1] == 1) {
                    uf.unite(i * m + j, i * m + j - 1);
                }
            }
        }
    }
    
    return uf.maxServers;
}

int main() {
    int n = 2, m = 2;
    vector<vector<int>> grid = {{1, 0},{1, 1}};
    int result = maxLocalArea(grid);
    cout << result << endl;
    
    return 0;
}

以上代码是C++中的并查集（Union Find）的实现，用于求解集合的并、查操作。下面解释下类UnionFind。

1. 在类 UnionFind 中，声明了三个成员变量：
   -parent：用于存储每个节点的父节点编号，初始化时设为自身的编号。
   -size：用于记录每个集合（根节点）的大小，初始化时设为1。
   -maxServers：用于记录当前最大的集合大小。

2. 构造函数 UnionFind(int n)：
   -初始化了 parent 和 size 两个数组，parent 的每个元素都指向自身，size 全部初始化为1。
   -初始化 maxServers 为1.

3. 函数 find(int x)：
   -实现了路径压缩的查找操作，通过递归将当前节点指向其根节点，以减小后续查找所需时间。

4. 函数 unite(int x, int y)：
   -实现了合并操作，首先找到 x 和 y 的根节点 rootx 和 rooty。
   -如果 rootx 和 rooty 不相等，即两个节点不在同一个集合中，这时将其中一个集合的根节点指向另一个集合的根节点。
   -更新两个集合的 size，然后更新 maxServers。

而maxLocalArea()函数，其实是在做动态规划：对于grid[x][y] == 1的情况，查看它上面和左面的值是否也为1，如果是，则将他们算作是一个集合。指向同一个根节点。

答案2：

可以使用深度优先搜索(DFS)来做。后面再补吧。