带你学习Flood Fill算法与最短路模型

Python微信订餐小程序课程视频

https://edu.csdn.net/course/detail/36074

Python实战量化交易理财系统

https://edu.csdn.net/course/detail/35475

一、Flood Fill（连通块问题）

0.简介

Flood Fill（洪水覆盖）

可以在线性的时间复杂内，找到某个点所在的连通块！

注：基于宽搜的思想，深搜也可以做但可能会爆栈

flood fill算法DFS与BFS：

​ DFS：无法求解最短路问题；可能会爆栈（递归层数很深时）；代码简介。当数据范围较小时可以使用

​ BFS：可以求解最短路；不存在爆栈情况；需要自己手写队列

1.池塘计数

农夫约翰有一片 N∗MN∗M 的矩形土地。

最近，由于降雨的原因，部分土地被水淹没了。

现在用一个字符矩阵来表示他的土地。

每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。

现在，约翰想知道他的土地中形成了多少片池塘。

每组相连的积水单元格集合可以看作是一片池塘。

每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。

请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。
**
输入格式**

第一行包含两个整数 NN 和 MM。

接下来 NN 行，每行包含 MM 个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。

输出格式

输出一个整数，表示池塘数目。

数据范围

1≤N,M≤10001≤N,M≤1000

输入样例：

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

输出样例：

3

思路：

从前往后遍历，找到一块水（没被标记过的），进行Flood Fill得出所在的连通块，水洼加1。即每一次bfs结束就得到一个连通块（水洼）

【代码实现】

#include 
#include 
#include 
#include 

using namespace std;

typedef pair<int, int> PII;// 用来存储坐标
queue q;

const int N = 1010 + 10;
char g[N][N];
bool st[N][N];
int n, m, ans;

//八方向
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};

// 找出(x,y)所构成的连通块！
void bfs(int x, int y)
{
 
 q.push({x, y}), st[x][y] = true;
 
 while(q.size())
 {
 auto t = q.front();
 q.pop();
 //扩展队头（遍历所有邻接点）
 for(int i = 0; i < 8; i ++)
 {
 int tx = t.first + dx[i];
 int ty = t.second + dy[i];
 
 //细节判断
 if(tx < 0 || tx >= n || ty < 0 || ty >= m ) continue;// 越界
 if(g[tx][ty] == '.' || st[tx][ty]) continue;// 如果是. 或者虽然是水但被标记过了
 
 
 //邻接节点入队
 q.push({tx, ty});
 st[tx][ty] = true;
 
 }
 }
}

int main()
{
 
 scanf("%d%d", &n, &m);
 
 //读入地图
 for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);
 
 for (int i = 0; i < n; i ++ )
 {
 for (int j = 0; j < m; j ++ )
 {
 //找到水 且 没有被标记过的 进行foll fill找连通块
 if(g[i][j] == 'W' && !st[i][j])
 {
 bfs(i, j);
 ans ++;
 }
 }
 }
 
 printf("%d", ans);
 
 return 0;
}

【DFS代码】

#include 
#include 
#include 

using namespace std;

int n, m, ans;
const int N = 1100;
char g[N][N];

int fx[8]={-1,-1,-1,0,0,1,1,1};
int fy[8]={-1,0,1,-1,1,-1,0,1};

// 如果遇到池塘就计数，并把与他相连通的池塘抽干(用深搜将它们标记为.)

void dfs(int x, int y)
{
    // 将被访问过的水洼标记，避免重复使用
    g[x][y] = '.';
    
    // 深搜抽干连通的部分
    for(int i = 0; i < 8; i++)
    {
        int tx = x + fx[i];
        int ty = y + fy[i];
        if(tx >= 1 && tx <= n && ty >= 1 && ty <= m && g[tx][ty] == 'W')
        {  
            dfs(tx, ty);
        }
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )
        for(int j = 1; j <= m; j++)
                cin >> g[i][j];
    
    // 依次遍历每个点，如果是水洼，计数加1，用深搜将连通的水洼抽干
    for(int i = 1; i <= n; i++){
        for (int j = 1; j <= m; j ++ ){
            if(g[i][j] == 'W'){ // 碰到水洼 结果加1，深搜抽干连通的水洼
                dfs(i,j);
                ans ++;
            }
        }
    }
    
    cout << ans;
    
        
                
    return 0;
}

2.红与黑

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。

你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。

请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

输入格式

输入包括多个数据集合。

每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。

在接下来的 HH 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下

1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。

当在一行中读入的是两个零时，表示输入结束。

输出格式

对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

数据范围

1≤W,H≤20

输入样例：

6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0

输出样例：

45

思路：

遍历图，找到起点（但起点），从起点开始flood fill 并统计黑色瓷砖的数量！

【DFS代码实现】

#include 
#include 
#include
#include 

using namespace std;

const int N = 30;
char g[N][N];

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

int n, m, res;

void dfs(int x, int y)
{
    g[x][y] = '#';//标记，防止重复访问
    res ++;
    
    for(int i = 0; i < 4; i++ )
    {
        int a = x + dx[i], b = y + dy[i];
        if(a < 0 || a >= n || b < 0 || b >= m) continue;
        if(g[a][b] == '#') continue;
        if(g[a][b] == '.')//找到黑色瓷砖，继续深搜
        {
            dfs(a, b);
        }
    }
}

int main()
{
    //多组数据输入
    while(cin >> m >> n, n || m)
    {
        res = 0;//多输入 每次res要置零 不然结果就累加了！
        for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);
        
        int x, y;
        bool flag = false;
        for (int i = 0; i < n; i ++ )
        {
            for (int j = 0; j < m; j ++ )
                if(g[i][j] == '@')
                {
                    x = i;
                    y = j;
                    flag = true;
                }
            if(flag) break;//找到起点（一个起点） 就可以直接跳出循环了