LeetCode中的BFS和DFS专题

LeetCode中的BFS和DFS专题

BFS广度优先，是按照层来扩展的；DFS深度优先，是“一条道走到黑”。

如果是一个规模为2的n次方的问题，那么BFS的时间复杂度是2的n次方，而DFS的时间复杂度是n。

一般用BFS来解决迷宫的最短路径问题，这是因为DFS走到终点的时候可能是绕了一大圈才到达终点。

BFS

1.空间大，是呈指数增长的

2.不会有爆栈的风险，申请的空间是堆空间

3.可以搜索最短或者最小路径

DFS

1.空间与深度成正比

2.有爆栈的风险，比如树的深度过大的情况下

3.无法搜索最短、最小的路径

111.二叉树的最小深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root) return 0;
        int left = minDepth(root->left);
        int right = minDepth(root->right);
        if(!left&&right) return right+1; 
        if(!right&&left)  return left+1;
        return min(left,right)+1;
    }
};

279.完全平方数

class Solution {
public:
    int numSquares(int n) {
        queue<int> q;
        vector<int> dist(n+1,INT_MAX);
        q.push(0);
        dist[0] = 0;
        while(q.size()){
            int t=q.front();
            q.pop();
            if(t==n) return dist[t];
            for(int i=1;i*i+t<=n;i++){
                int j=t+i*i;
                if(dist[j]>dist[t]+1){
                    dist[j]=dist[t]+1;
                    q.push(j);
                }
            }
        }
        return 0;
    }
};

733.图像渲染

class Solution {
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        if(image.empty()||image[0].empty()) return image;
        int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
        int oldColor = image[sr][sc];
        if(oldColor==newColor) return image;
        image[sr][sc] = newColor;
        for(int i=0;i<4;i++){
            int x=sr+dx[i],y=sc+dy[i];
            if(x>=0&&x<image.size()&&y>=0&&y<image[0].size()&&image[x][y]==oldColor){
                floodFill(image,x,y,newColor);
            }
        }
        return image;
    }
};

200.岛屿数量

class Solution {
public:
    int m,n;
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty()||grid[0].empty())  return 0;
        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);
                }
            }
        }
        return res;
    }
    void dfs(vector<vector<char>>& grid,int x,int y){
        int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
        grid[x][y]='0';
        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 && grid[a][b]=='1')
                dfs(grid,a,b);
        }
    }
};