BFS中的FloodFill和最短路模型

ZZTC

于 2024-12-27 11:40:30 发布

阅读量577

点赞数 18

分类专栏：算法文章标签：宽度优先算法

本文链接：https://blog.youkuaiyun.com/qq_73628657/article/details/144763908

版权

算法专栏收录该内容

23 篇文章

订阅专栏

Flood Fill

Flood Fill算法，又称洪水填充，泛洪算法

其思想是：从一个种子点开始，将与其连通（可达且颜色相同/相近）的点全部染上另外一种颜色，直到所有可达节点都被染色为止。

1097. 池塘计数

农夫约翰有一片 $N * M$ 的矩形土地。

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

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

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

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

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

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

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

输入格式

第一行包含两个整数 $N$ 和 $M$ 。

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

输出格式

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

数据范围

$1 \leq N, M \leq 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.

输出样例：

这就是一道 Flood Fill算法裸题

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N = 1010;
int n, m, dx[9] = {0, -1, 1, 0, 0, -1, 1, 1, -1}, dy[9] = {0, 0, 0, -1, 1, -1, -1, 1, 1}, res; 
char g[N][N];
bool st[N][N];

bool check(int tx, int ty){
    if(tx < 0 || tx >= n || ty < 0 || ty >= m || st[tx][ty] || g[tx][ty] == '.') return false;
    return true;
}

void bfs(int x, int y){
    res++;
    queue<PII> q;
    q.push({x, y});
    st[x][y] = true;
    while(q.size()){
        auto t = q.front();
        q.pop();
        int xx = t.first, yy = t.second;
        for (int i = 1; i <= 8; i++){
            int tx = xx + dx[i], ty = yy + dy[i];
            if(check(tx, ty)){
                q.push({tx, ty});
                st[tx][ty] = true;
            }
        }
    }
}

int main(){
    cin >> n >> m;
    for (int i = 0; i < n; i++) cin >> g[i];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if(!st[i][j] && g[i][j] == 'W') bfs(i, j);
    cout << res << endl;
    return 0;
}

1098. 城堡问题

    1   2   3   4   5   6   7  
   #############################
 1 #   |   #   |   #   |   |   #
   #####---#####---#---#####---#
 2 #   #   |   #   #   #   #   #
   #---#####---#####---#####---#
 3 #   |   |   #   #   #   #   #
   #---#########---#####---#---#
 4 #   #   |   |   |   |   #   #
   #############################
           (图 1)

   #  = Wall   
   |  = No wall
   -  = No wall

   方向：上北下南左西右东。

图1是一个城堡的地形图。

请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。

城堡被分割成 $m * n$ 个方格区域，每个方格区域可以有0~4面墙。

注意：墙体厚度忽略不计。

输入格式

第一行包含两个整数 $m$ 和 $n$ ，分别表示城堡南北方向的长度和东西方向的长度。

接下来 $m$ 行，每行包含 $n$ 个整数，每个整数都表示平面图对应位置的方块的墙的特征。

每个方块中墙的特征由数字 $P$ 来描述，我们用1表示西墙，2表示北墙，4表示东墙，8表示南墙， $P$ 为该方块包含墙的数字之和。

例如，如果一个方块的 $P$ 为3，则 3 = 1 + 2，该方块包含西墙和北墙。

城堡的内墙被计算两次，方块(1,1)的南墙同时也是方块(2,1)的北墙。

输入的数据保证城堡至少有两个房间。

输出格式

共两行，第一行输出房间总数，第二行输出最大房间的面积（方块数）。

数据范围

$1 \leq m, n \leq 50$ ,
$0 \leq P \leq 15$

输入样例：

4 7 
11 6 11 6 3 10 6 
7 9 6 13 5 15 5 
1 10 12 7 13 7 5 
13 11 10 8 10 12 13

输出样例：

5
9

思路：

这个题目的难度在于如何建图，如何判断两个点之间是否存在墙
题目用 $1 、 2 、 4 、 8$ ，可以发现就是 $2^j(j = 0、1、2、3)$ ，就可以用对应数的二进制位数表示

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
typedef pair<int,int> PII;
const int N = 55;
int n, m, g[N][N], dx[4] = {0, -1, 0, 1}, dy[4] = {-1, 0, 1, 0}, res, num;
bool st[N][N];

void bfs(int x, int y){
    res++;
    int temp = 1;
    queue<PII> q;
    q.push({x, y});
    st[x][y] = true;
    while(q.size()){
        auto t = q.front();
        q.pop();
        int xx = t.first, yy = t.second;
        for (int i = 0; i < 4; i++){
            int tx = xx + dx[i], ty = yy + dy[i];
            if(tx < 0 || tx >= n || ty < 0 || ty >= m || st[tx][ty]) continue;
            if(g[xx][yy] >> i & 1) continue;
            q.push({tx, ty});
            st[tx][ty] = true;
            temp++;
        }
    }
    num = max(num, temp);
}

int main(){
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) cin >> g[i][j];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if(!st[i][j]) bfs(i, j);
    cout << res << endl << num << endl;
    return 0;
}

1106. 山峰和山谷

FGD小朋友特别喜欢爬山，在爬山的时候他就在研究山峰和山谷。

为了能够对旅程有一个安排，他想知道山峰和山谷的数量。

给定一个地图，为FGD想要旅行的区域，地图被分为 $n \times n$ 的网格，每个格子 $(i, j)$ 的高度 $w (i, j)$ 是给定的。

若两个格子有公共顶点，那么它们就是相邻的格子，如与 $(i, j)$ 相邻的格子有 $(i - 1, j - 1), (i - 1, j), (i - 1, j + 1), (i, j - 1), (i, j + 1), (i + 1, j - 1), (i + 1, j), (i + 1, j + 1)$ 。

我们定义一个格子的集合 $S$ 为山峰（山谷）当且仅当：

$S$ 的所有格子都有相同的高度。
$S$ 的所有格子都连通。
对于 $s$ 属于 $S$ ，与 $s$ 相邻的 $s'$ 不属于 $S$ ，都有 $w_s>w_{s′}$ （山峰），或者 $w_s<w_{s′}$ （山谷）。
如果周围不存在相邻区域，则同时将其视为山峰和山谷。

你的任务是，对于给定的地图，求出山峰和山谷的数量，如果所有格子都有相同的高度，那么整个地图即是山峰，又是山谷。

输入格式

第一行包含一个正整数 $n$ ，表示地图的大小。

接下来一个 $n \times n$ 的矩阵，表示地图上每个格子的高度 $w$ 。

输出格式

共一行，包含两个整数，表示山峰和山谷的数量。

数据范围

$1 \leq n \leq 1000$ ,
$0≤w≤10^9$

输入样例1：

输出样例1：

2 1

输入样例2：

输出样例2：

3 3

样例解释

样例1：

样例2：

#include<iostream>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N = 1010;
int n, g[N][N], top, bot, dx[9] = {0, -1, 1, 0, 0, -1, 1, 1, -1}, dy[9] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
bool st[N][N];

void bfs(int x, int y){
    bool t1 = true, t2 = true;
    queue<PII> q;
    q.push({x, y});
    st[x][y] = true;
    while(q.size()){
        auto t = q.front();
        q.pop();
        int xx = t.first, yy = t.second;
        for (int i = 1; i <= 8; i++){
            int tx = xx + dx[i], ty = yy + dy[i];
            if(tx <= 0 || tx > n || ty <= 0 || ty > n) continue;
            if(g[tx][ty] == g[xx][yy]){
                if(!st[tx][ty]){
                    q.push({tx, ty});
                    st[tx][ty] = true;
                }
            }
            else if(g[tx][ty] > g[xx][yy]) t1 = false;
            else if(g[tx][ty] < g[xx][yy]) t2 = false;
        }
    }
    if(t1) top++;
    if(t2) bot++;
}

int main(){
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) cin >> g[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if(!st[i][j]) bfs(i, j);
    cout << top << " " << bot << endl; 
    return 0;
}

最短路模型

1076. 迷宫问题

给定一个 $n \times n$ 的二维数组，如下所示：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

数据保证至少存在一条从左上角走到右下角的路径。

输入格式

第一行包含整数 $n$ 。

接下来 $n$ 行，每行包含 $n$ 个整数 0 或 1，表示迷宫。

输出格式

输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。

按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为 $(0, 0)$ ，右下角坐标为 $(n - 1, n - 1)$ 。

数据范围

$0 \leq n \leq 1000$

输入样例：

输出样例：

思路：

为了方便最后输出路径，因此从右下角往左上角搜索
每次搜索的时候记录下这个的前驱坐标
最后依次输出从左上角到右下角的前驱坐标即为路径

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N = 1010;
int n, g[N][N], dx[5] = {0, -1, 1, 0, 0}, dy[5] = {0, 0, 0, -1, 1};
bool st[N][N];
PII pre[N][N];

void bfs(){
    queue<PII> q;
    q.push({n - 1, n - 1});
    st[n - 1][n - 1] = true;
    while(q.size()){
        auto t = q.front();
        q.pop();
        int x = t.first, y = t.second;
        for (int i = 1; i <= 4; i++){
            int tx = x + dx[i], ty = y + dy[i];
            if(tx >= n || tx < 0 || ty >= n || ty < 0 || st[tx][ty] || g[tx][ty]) continue;
            q.push({tx, ty});
            st[tx][ty] = true;
            pre[tx][ty] = {x, y};
        }
    }
    
    int x = 0, y = 0;
    while(x != n - 1 || y != n - 1){
        cout << x << " " << y << endl;
        PII t = pre[x][y];
        x = t.first;
        y = t.second;
    }
    cout << n - 1 << " " << n - 1 << endl;
}

int main(){
    cin >> n;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) cin >> g[i][j];
    bfs();
    return 0;
}

188. 武士风度的牛

农民 John 有很多牛，他想交易其中一头被 Don 称为 The Knight 的牛。

这头牛有一个独一无二的超能力，在农场里像 Knight 一样地跳（就是我们熟悉的象棋中马的走法）。

虽然这头神奇的牛不能跳到树上和石头上，但是它可以在牧场上随意跳，我们把牧场用一个 $x ， y$ 的坐标图来表示。

这头神奇的牛像其它牛一样喜欢吃草，给你一张地图，上面标注了 The Knight 的开始位置，树、灌木、石头以及其它障碍的位置，除此之外还有一捆草。

现在你的任务是，确定 The Knight 要想吃到草，至少需要跳多少次。

The Knight 的位置用 K 来标记，障碍的位置用 * 来标记，草的位置用 H 来标记。

这里有一个地图的例子：

             11 | . . . . . . . . . .
             10 | . . . . * . . . . . 
              9 | . . . . . . . . . . 
              8 | . . . * . * . . . . 
              7 | . . . . . . . * . . 
              6 | . . * . . * . . . H 
              5 | * . . . . . . . . . 
              4 | . . . * . . . * . . 
              3 | . K . . . . . . . . 
              2 | . . . * . . . . . * 
              1 | . . * . . . . * . . 
              0 ----------------------
                                    1 
                0 1 2 3 4 5 6 7 8 9 0

The Knight 可以按照下图中的 $A, B, C, D \dots$ 这条路径用 $5$ 次跳到草的地方（有可能其它路线的长度也是 $5$ ）：

             11 | . . . . . . . . . .
             10 | . . . . * . . . . .
              9 | . . . . . . . . . .
              8 | . . . * . * . . . .
              7 | . . . . . . . * . .
              6 | . . * . . * . . . F<
              5 | * . B . . . . . . .
              4 | . . . * C . . * E .
              3 | .>A . . . . D . . .
              2 | . . . * . . . . . *
              1 | . . * . . . . * . .
              0 ----------------------
                                    1
                0 1 2 3 4 5 6 7 8 9 0

注意： 数据保证一定有解。

输入格式

第 $1$ 行：两个数，表示农场的列数 $C$ 和行数 $R$ 。

第 $2.. R + 1$ 行: 每行一个由 $C$ 个字符组成的字符串，共同描绘出牧场地图。

输出格式

一个整数，表示跳跃的最小次数。

数据范围

$1 \leq R, C \leq 150$

输入样例：

10 11
..........
....*.....
..........
...*.*....
.......*..
..*..*...H
*.........
...*...*..
.K........
...*.....*
..*....*..

输出样例：

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int N = 155;
typedef pair<int,int> PII;
int n, m, dx[9] = {0, -1, -2, -2, -1, 1, 2, 2, 1}, dy[9] = {0, -2, -1, 1, 2, 2, 1, -1, -2}, dist[N][N];
PII start, ed;
char g[N][N];
bool st[N][N];

void bfs(){
    queue<PII> q;
    q.push(start);
    st[start.first][start.second] = true;
    while(q.size()){
        auto t = q.front();
        q.pop();
        int x = t.first, y = t.second;
        if(x == ed.first && y == ed.second) break;
        for (int i = 1; i <= 8; i++){
            int tx = x + dx[i], ty = y + dy[i];
            if(tx < 0 || tx >= n || ty < 0 || ty >= m || g[tx][ty] == '*' || st[tx][ty]) continue;
            dist[tx][ty] = dist[x][y] + 1;
            q.push({tx, ty});
            st[tx][ty] = true;
        }
    }
    cout << dist[ed.first][ed.second] << endl;
}

int main(){
    cin >> m >> n;
    for (int i = 0; i < n; i++){
        cin >> g[i];
        for (int j = 0; j < m; j++){
            if(g[i][j] == 'K') start = {i, j};
            else if(g[i][j] == 'H') ed = {i, j};
        }
    }
    bfs();
    return 0;
}

1100. 抓住那头牛

农夫知道一头牛的位置，想要抓住它。

农夫和牛都位于数轴上，农夫起始位于点 $N$ ，牛位于点 $K$ 。

农夫有两种移动方式：

从 $X$ 移动到 $X - 1$ 或 $X + 1$ ，每次移动花费一分钟
从 $X$ 移动到 $2 * X$ ，每次移动花费一分钟

假设牛没有意识到农夫的行动，站在原地不动。

农夫最少要花多少时间才能抓住牛？

输入格式

共一行，包含两个整数N和K。

输出格式

输出一个整数，表示抓到牛所花费的最少时间。

数据范围

$0≤N,K≤10^5$

输入样例：

5 17

输出样例：

#include<iostream>
#include<queue>
using namespace std;
const int N = 1e5 + 10;
int n, k, dist[N];
bool st[N];

void bfs(){
    queue<int> q;
    q.push(n);
    st[n] = true;
    while(q.size()){
        int t = q.front();
        q.pop();
        if(t == k) break;
        int tt = t - 1;
        if(tt >= 0 && !st[tt]){
            dist[tt] = dist[t] + 1;
            q.push(tt);
            st[tt] = true;
        }
        tt = t + 1;
        if(tt <= k && !st[tt]){
            dist[tt] = dist[t] + 1;
            q.push(tt);
            st[tt] = true;
        }
        tt = t * 2;
        if(tt <= k + 1 && !st[tt]){
            dist[tt] = dist[t] + 1;
            q.push(tt);
            st[tt] = true;
        }
    }
    cout << dist[k] << endl;
}

int main(){
    cin >> n >> k;
    if(n > k){
        cout << n - k << endl;
        return 0;
    }
    bfs();
    return 0;
}