图DFS和BFS总结 力扣

图的BFS与DFS

对数据结构和算法有一定了解的朋友一定知道对于图的遍历而言，BFS和DFS是两种不错的方法。但是对于什么时候应该使用BFS或者是DFS却缺少判断，有时一道题目DFS会超时，BFS不会，有时两种方法都可以。

我的一个简单的判断方法是：求图里有多少岛等需要得到一个具体数字问题用DFS，求最短路径用BFS

DFS例题与模板

例题

力扣 733. 图像渲染
有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。

你也被给予三个整数 sr , sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行 上色填充 。

为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor 。

最后返回 经过上色渲染后的图像 。

输入: image = [[1,1,1],[1,1,0],[1,0,1]]，sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析: 在图像的正中间，(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，因为它不是在上下左右四个方向上与初始点相连的像素点。

示例 2:

输入: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2
输出: [[2,2,2],[2,2,2]]

提示:

m == image.length
n == image[i].length
1 <= m, n <= 50
0 <= image[i][j], newColor < 216
0 <= sr < m
0 <= sc < n

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/flood-fill
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

DFS解法

/*
DFS模板，从题目给的位置开始进行DFS，把与开始位置的节点全部变为新颜色
*/
class Solution {
public:
    void DFS(vector<vector<int>>& image,int i,int j,int color,int newColor)
    {
        if (i < 0 || i >= image.size() || j < 0 || j >= image[0].size())
            return;
        if (image[i][j] != color || image[i][j] == newColor)
            return;
        image[i][j] = newColor;
        DFS(image,i + 1,j,color,newColor);
        DFS(image,i - 1,j,color,newColor);
        DFS(image,i,j + 1,color,newColor);
        DFS(image,i,j - 1,color,newColor);
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int color = image[sr][sc];
        DFS(image,sr,sc,color,newColor);
        return image;
    }
};

模板

从上面的例题，我们可以稍微总结一下DFS的模板
内容上大致分为四个部分
1. 对边界的判断
2. 根据题意进行剪枝
3. 进行操作
4. 上下左右四个方向进行递归

当然也需要根据题意来灵活变换DFS函数的返回值等其他设计

//DFS函数设计，image为图 i和j为DFS开始坐标
void DFS(vector<vector<int>>& image,int i,int j,int color,int newColor)
 {
 		//对边界的判断
        if (i < 0 || i >= image.size() || j < 0 || j >= image[0].size())
            return;
        //根据题意剪枝
        if (image[i][j] != color || image[i][j] == newColor)
            return;
        // 进行标记等操作
        image[i][j] = newColor;
        //上下左右四个方向递归
        DFS(image,i + 1,j,color,newColor);
        DFS(image,i - 1,j,color,newColor);
        DFS(image,i,j + 1,color,newColor);
        DFS(image,i,j - 1,color,newColor);
    }

BFS例题与模板

例题

力扣 542. 01 矩阵
给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

示例 1：

输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
输出：[[0,0,0],[0,1,0],[0,0,0]]

示例 2：

输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
输出：[[0,0,0],[0,1,0],[1,2,1]]

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 104
1 <= m * n <= 104
mat[i][j] is either 0 or 1.
mat 中至少有一个 0 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/01-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/*
最短路径 优先用BFS
将0的位置入队，1变成-1，进行BFS，往外扩散
*/
class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        //方向数组
        int dx[4] = {0,0,1,-1};
        int dy[4] = {-1,1,0,0};
        //矩阵大小
        int n = mat.size();
        int m = mat[0].size();
        //BFS队列
        queue<pair<int,int>> qe;
        //矩阵预处理,将0的下标入队，1对应的值变为-1
        for (int i = 0;i < n; i++)
            for (int j = 0;j < m; j++)
            {
                if (mat[i][j] == 0)
                    qe.push({i,j});
                else
                    mat[i][j] = -1;
            }
        //扩散层数
        int level = 0;
        //当队列不为空
        while (qe.empty() == false)
        {
 			//该层队列长度
            int size = qe.size();
            level++;
            while (size--)
            {
            	//取队首
                auto it = qe.front();
                //出队
                qe.pop();
                // x，y队首坐标上下左右
                int x = it.first;
                int y = it.second;
                //更新坐标
                for (int i = 0;i < 4;i++)
                {
                	//上下左右新坐标
                    int newX = x + dx[i];
                    int newY = y + dy[i];
                    //合法范围内
                    if (newX >= 0 && newX < n&& newY >= 0 && newY < m && mat[newX][newY] == -1)
                    {
                    	//标记或者其他操作
                        mat[newX][newY] = level;
                        //新点入队
                        qe.push({newX,newY});
                    }
                }
            }
        }
        return mat;

    }
};

模板

BFS模板总结
1. 根据题意设置方向数组，不一定是上下左右四个方向
2. 根据题意设置BFS队列，有时候是pair<int,int>,有时候是int,有时候是tuple<int,int,int>
3. 预处理起点或是某类点并标记
4. 开始BFS时，int size = qe.size()和while (size–)可视情况去掉
5. 取队首，出队，获取队首坐标，根据方向数组长度更新BFS扩散出去的位置
6. 如果该坐标合法，那么进行标记和新点入队操作

		//两个方向数组
        int dx[4] = {0,0,1,-1};
        int dy[4] = {-1,1,0,0};
        //BFS队列
        queue<pair<int,int>> qe;
        //预处理操作，起点入队并且标记已访问
		qe.push(起点)
		vis[起点] = true;
		
		while (qe.empty() == false)
        {
 			//该层队列长度
            int size = qe.size();
            while (size--)
            {
            	//取队首
                auto it = qe.front();
                //出队
                qe.pop();
                // x，y队首坐标上下左右
                int x = it.first;
                int y = it.second;
                //更新坐标
                for (int i = 0;i < 4;i++)
                {
                	//上下左右新坐标
                    int newX = x + dx[i];
                    int newY = y + dy[i];
                    //合法范围内
                    if (newX >= 0 && newX < n&& newY >= 0 && newY < m && mat[newX][newY] == -1)
                    {
                    	//标记或者其他操作
              			标记
                        //新点入队
                        qe.push({newX,newY});
                    }
                }
            }
        }