寒假每日一题红与黑（个人练习）详细题解+推导证明（第四天）

Posted 2022-06-04 我是管小亮

文章目录

• 前言
• 题目
• 详细题解
• • • • 写法1 $O(n\ast m)$
      • 推导证明
      • 写法2 $O(n\ast m)$
      • 推导证明
• 举一反三
• 总结

前言

今天做了全民核酸检测，有点东西，晚上来更新博客了，哈哈！！！

今天还是寒假每日一题，不是软广，不是硬广，只是个人练习，题目来自《信息学奥赛一本通》。

在以下的代码中，看到了很多很好的代码习惯，比如使用简单的字母表示 pair 的 first 和 second；比如使用 PII 代替 pair<int, int>；比如上下左右四个位置的写法；

这些都是需要学习并掌握的，加油各位

题目

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

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

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

输入格式

• 输入包括多个数据集合。
• 每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。
• 在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下
  • 1）‘.’：黑色的瓷砖；
  • 2）‘#’：红色的瓷砖；
  • 3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。
• 当在一行中读入的是两个零时，表示输入结束。

输出格式

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

数据范围

• $1\le W,H\le 20$

输入样例：
6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0
输出样例：
45

详细题解

写法1 $O(n\ast m)$

bfs:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;
const int N = 25;

int n, m;
char f[N][N];

int bfs(int sx, int sy)

    queue<PII> q;
    q.push(sx, sy);
    f[sx][sy] = '#';
    int ans = 0;
    
    int dx[] = -1, 0, 1, 0, dy[] = 0, 1, 0, -1;
    
    while (q.size())
    
        auto t = q.front();
        q.pop();
        ++ ans;
        for (int i = 0; i < 4; ++ i )
        
            int x = t.x + dx[i], y = t.y + dy[i];
            if(x < 0 || x >= n || y < 0 || y >= m || f[x][y] != '.') continue;
            f[x][y] = '#';
            q.push(x, y);
        
    
    return ans;


int main()

    while(cin >> m >> n, n || m)
    
        for (int i = 0; i < n; ++ i ) cin >> f[i];
        int x, y;
        for (int i = 0; i < n; ++ i )
            for (int j = 0; j < m; ++ j )
                if (f[i][j] == '@')
                
                    x = i; y = j;
                
        cout << bfs(x, y) << endl;
    
    
    return 0;

毫无疑问，这是一道经典问题，也就是 Flood Fill 算法。

一共有两种写法，一种是宽度优先搜索算法，即bfs；一种是深度优先搜索算法，即dfs；

最后提交，AC😁

推导证明

宽度优先算法，即在每一步都搜索自己周围的所有可能性。

写法2 $O(n\ast m)$

dfs:

#include <iostream>

using namespace std;

const int N = 25;

int n, m;
char f[N][N];
int dx[] = -1, 0, 1, 0, dy[] = 0, 1, 0, -1;

int dfs(int sx, int sy)

    int ans = 1;
    f[sx][sy] = '#';
    for (int i = 0; i < 4; ++ i )
    
        int x = sx + dx[i], y = sy + dy[i];
        if (x >= 0 && x < n && y >=0 && y < m && f[x][y] == '.')
        
            ans += dfs(x, y);
        
    
    
    return ans;


int main()

    while(cin >> m >> n, n || m)
    
        for (int i = 0; i < n; ++ i ) cin >> f[i];
        int x, y;
        for (int i = 0; i < n; ++ i )
            for (int j = 0; j < m; ++ j )
                if (f[i][j] == '@')
                
                    x = i; y = j;
                
        cout << dfs(x, y) << endl;
    
    
    return 0;

深度优先算法相较于宽度优先算法来说，更简单，但是由于递归问题，栈空间可能会爆炸。

最后提交，AC😁

推导证明

宽度优先算法在每一个位置会按照上右下左的顺序继续搜索，直到无法搜索，进行回溯。

举一反三

比如表格搜索，比如最短路径等等。

总结

继续努力，坚持更新，4th打卡。