一. 三国势力划分问题
1.1 题目描述
在一个大小为 n * m 的棋盘状土地上，每个格子上都有一个数字，表示该格子的归属国家。上下左右相邻且属于同一个国家的格子被认为是同一股势力。我们需要编写一个程序来计算土地上总共的势力股数。
测试样例
-
样例1：
- 输入：
n = 4, m = 4, s = ["1122", "1222", "3111", "3333"] - 输出：
4
- 输入：
-
样例2：
- 输入：
n = 2, m = 2, s = ["11", "11"] - 输出：
1
- 输入：
-
样例3：
- 输入：
n = 3, m = 3, s = ["123", "123", "123"] - 输出：
3
- 输入：
解题思路
-
数据结构选择：
- 使用二维数组
grid来存储棋盘上的国家分布。 - 使用二维布尔数组
visited来记录每个格子是否已经被访问过。
- 使用二维数组
-
算法步骤：
- 将输入的字符串列表
s转换为二维数组grid。 - 初始化
visited数组为False，表示所有格子都未被访问。 - 遍历每个格子，如果该格子未被访问过，则进行深度优先搜索（DFS），将所有相邻且属于同一国家的格子标记为已访问，并计数为一股势力。
- 最终返回势力股数。
- 将输入的字符串列表
def dfs(grid, n, m, i, j, visited, cur):
if i < 0 or i >= n or j < 0 or j >= m or visited[i][j] or cur != grid[i][j]:
return
visited[i][j] = True
dfs(grid, n, m, i - 1, j, visited, cur)
dfs(grid, n, m, i + 1, j, visited, cur)
dfs(grid, n, m, i, j - 1, visited, cur)
dfs(grid, n, m, i, j + 1, visited, cur)
def solution(n, m, s):
grid = [[0] * m for _ in range(n)]
# 将字符串列表 s 转换为二维数组
for i in range(n):
for j in range(m):
grid[i][j] = int(s[i][j])
visited = [[False] * m for _ in range(n)]
faction_count = 0
for i in range(n):
for j in range(m):
if not visited[i][j]:
dfs(grid, n, m, i, j, visited, grid[i][j])
faction_count += 1
return faction_count
if __name__ == '__main__':
print(solution(n = 4, m = 4, s = ["1122", "1222", "3111", "3333"]) == 4)
print(solution(n = 2, m = 2, s = ["11", "11"]) == 1)
print(solution(n = 3, m = 3, s = ["123", "123", "123"]) == 3)
关键点总结
- DFS 深度优先搜索：用于遍历和标记相邻且属于同一国家的格子。
- visited 数组：用于记录每个格子是否已经被访问过，避免重复计算。
- 势力股数计数：每次进行 DFS 时，计数器
faction_count加 1，表示发现一股新的势力。
二、其他类似题目
2.1岛屿的周长
2.1.1题目描述
给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 1：
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边
示例 2：
输入：grid = [[1]]
输出：4
示例 3：
输入：grid = [[1,0]]
输出：4
2.1.2题目分析
深度优先遍历。对于一个陆地格子的每条边，它被算作岛屿的周长当且仅当这条边为网格的边界或者相邻的另一个格子为水域。 因此，我们可以遍历每个陆地格子，看其四个方向是否为边界或者水域，如果是，将这条边的贡献+1。为了防止陆地格子在深度优先搜索中被重复遍历导致死循环，我们需要将遍历过的陆地格子标记为已经遍历过，下面的代码中我们设定值为-1。
class Solution {
/*用来表示上下左右*/
constexpr static int dx[4] {0, 0, 1, -1};
constexpr static int dy[4] {1, -1, 0, 0};
public:
int islandPerimeter(vector<vector<int>>& grid) {
int n = grid.size(), m = grid[0].size();
int res = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
if(grid[i][j] == 1) {
/*陆地*/
res = dfs(grid, i, j, n, m);
}
}//for j
}//for i
return res;
}
int dfs(vector<vector<int>>& grid, int i, int j, int n, int m) {
if(i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == 0) {
/*四周为边界--周长加1*/
return 1;
}
if(grid[i][j] == -1) {
/*已经遍历过*/
return 0;
}
grid[i][j] = -1;
int res = 0;
for(int k = 0; k < 4; ++k) {
int tx = i + dx[k];
int ty = j + dy[k];
res += dfs(grid, tx, ty, n, m);
}
return res;
}
};
/*
时间复杂度：O(nm)，其中 n 为网格的高度，m 为网格的宽度。每个格子至多会被遍历一次，因此总时间复杂度为 O(nm)。
空间复杂度：O(nm)。深度优先搜索复杂度取决于递归的栈空间，而栈空间最坏情况下会达到 O(nm)。
*/
2.2 岛屿的最大面积
2.2.1题目描述
给你一个大小为 m x n 的二进制矩阵 grid 。
岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 1 的单元格的数目。
计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
2.3.2题目分析
我们想知道网格中每个连通形状的面积，然后取最大值。
如果我们在一个土地上，以 4 个方向探索与之相连的每一个土地（以及与这些土地相连的土地），那么探索过的土地总数将是该连通形状的面积。
为了确保每个土地访问不超过一次，我们每次经过一块土地时，将这块土地的值置为 0。这样我们就不会多次访问同一土地。
class Solution {
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
int ans = 0;
for(int i = 0; i < grid.size(); ++i){
for(int j = 0; j < grid[0].size(); ++j){
ans = max(ans, Island(grid, i, j));
}
}
return ans;
}
int Island(vector<vector<int>>& grid, int i, int j){
//递归终止条件
if(i >= grid.size() || j >= grid[0].size() || i < 0 || j < 0){
return 0;
}
if(grid[i][j] == 0) return 0;
grid[i][j] = 0;
return 1 + Island(grid, i + 1, j) + Island(grid, i - 1, j) + Island(grid, i, j + 1) + Island(grid, i, j -1);
}
};
2.3 岛屿数量
2.3.1题目描述
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [["1","1","1","1","0"],
["1","1","0","1","0"],
["1","1","0","0","0"],
["0","0","0","0","0"]
]
输出：1
示例 2：
输入：grid = [["1","1","0","0","0"],
["1","1","0","0","0"],
["0","0","1","0","0"],
["0","0","0","1","1"]
]
输出：3
2.3.2题目分析
我们可以将二维网格看成一个无向图，竖直或水平相邻的 1之间有边相连。为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 1都会被重新标记为 0。最终岛屿的数量就是我们进行深度优先搜索的次数。
class Solution {
constexpr static int dx[4] {0, 0, 1, -1};
constexpr static int dy[4] {1, -1, 0, 0};
public:
int numIslands(vector<vector<char>>& grid) {
int n = grid.size();
if(n == 0) return 0;
int m = grid[0].size();
int nums = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
if(grid[i][j] == '1') {
++nums;
//返回dfs遍历与其相连的所有1，并将其置为0
dfs(grid, i, j, n, m);
}
}//for j
}//for i
return nums;
}
void dfs(vector<vector<char>>& grid, int i, int j, int n, int m) {
if(i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == '0') {
return;
}
grid[i][j] = '0';
for(int k = 0; k < 4; ++k) {
dfs(grid, i+dx[k], j+dy[k], n, m);
}
}
};
/*
时间复杂度为O(nm)
空间复杂度为O(nm)
*/
三、总结
在解决二维网格的连通性问题时，如势力划分、岛屿数量、岛屿面积和岛屿周长等，可以采用一个通用的模板。该模板的核心是使用深度优先搜索（DFS）或广度优先搜索（BFS）来遍历网格中的连通区域。首先，定义一个方向数组来表示上下左右的移动方向，并初始化一个 visited 数组来记录每个格子是否已经被访问过，以避免重复计算。然后，通过双重循环遍历网格中的每个格子，对于未访问的格子，调用 DFS/BFS 函数进行遍历，并将所有相邻且属于同一类别的格子标记为已访问。根据具体问题的需求，可以在 DFS/BFS 过程中更新结果，如计数连通区域的数量、计算面积或周长等。
这个通用模板的优势在于其灵活性和可扩展性，能够适应不同类型的二维网格问题。例如，在势力划分问题中，通过统计不同国家的连通区域数量来确定势力股数；在岛屿数量问题中，只统计陆地格子的连通区域；在岛屿面积问题中，通过累加访问的格子数来计算最大面积；在岛屿周长问题中，通过检查边界和相邻水域来累加周长。通过这种统一的方法，可以高效地解决各种复杂的二维网格连通性问题，确保代码的简洁性和可维护性。
