图论第1天｜dfs 797 bfs 200 695 1020 130

dfs要用到回溯 

797 dfs经典模版题 跟回溯一样 很好写 x这里是目前达到的节点位置 for loop里面是遍历当前位置可去的节点位置 path要先加入0（所有的路径都是从0开始的）

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void dfs(vector<vector<int>>& graph, int x) {
        if (x==graph.size()-1) {
            result.push_back(path);
            return;
        }
        for (int i=0; i<graph[x].size(); i++) {
            path.push_back(graph[x][i]);
            dfs(graph, graph[x][i]);
            path.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        path.push_back(0);
        dfs(graph, 0);
        return result;
    }
};

bfs 适合用于解决找两点之间的最短路径

200 bfs function 从某个点开始 将它连续的所有为1的都标记上 

main function 从头到尾遍历 遇到为1但没被标记过的 说明遇到新岛屿 count++ 走一遍bfs function

class Solution {
private: 
    void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
        int dir[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}};
        queue<pair<int, int>> que;
        que.push({x,y});
        visited[x][y]=true;
        while (!que.empty()) {
            pair<int, int> curr = que.front(); que.pop();
            for (int i=0; i<4; i++) {
                int next_x = curr.first+dir[i][0];
                int next_y = curr.second+dir[i][1];
                if (next_x<0 || next_x>=grid.size() || next_y<0 || next_y>=grid[0].size()) continue;
                if (!visited[next_x][next_y] && grid[next_x][next_y]=='1') {
                    visited[next_x][next_y]=true;
                    que.push({next_x, next_y});
                }
            }
        }
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int count=0;
        vector<vector<bool>> visited(grid.size(), vector<bool>(grid[0].size(), false)); 
        for (int i=0; i<grid.size(); i++) {
            for (int j=0; j<grid[0].size(); j++) {
                if (grid[i][j]=='1' && !visited[i][j]) {
                    count++;
                    bfs(grid, visited, i,j);
                }
            }
        }
        return count;
    }
};

这道岛屿问题用dfs也很好写 不用终于条件 因为调用时是有条件的 main function的逻辑和bfs一样

void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {                    
     visited[x][y]=true;
     for (int i=0; i<4; i++) {    
         int next_x = x+dir[i][0];
         int next_y = y+dir[i][1];
         if (next_x<0 || next_x>=grid.size() || next_y<0 || next_y>=grid[0].size()) continue;
         if (!visited[next_x][next_y] && grid[next_x][next_y]=='1') {
             dfs(grid, visited, next_x, next_y);
         }
     }
}

695 岛屿问题都是一样的 一个岛一个岛的去深搜/广搜且标记计数 找到最大的岛

class Solution {
private:
    int dir[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    int dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
        if (x<0 || x>=grid.size() || y<0 || y>=grid[0].size()) return 0;
        if (grid[x][y]==0||visited[x][y]) return 0;
        visited[x][y] = true;
        int count=1;
        for (int i=0; i<4; i++) {
            int next_x = x+dir[i][0];
            int next_y = y+dir[i][1];
            count+=dfs(grid, visited, next_x, next_y);
        }
        return count;
    }
    int bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
        queue<pair<int, int>> que;
        que.push({x,y});
        visited[x][y]=true;
        int count=1;
        while (!que.empty()) {
            int x=que.front().first;
            int y=que.front().second;
            que.pop();
            for (int i=0; i<4; i++) {
                int next_x = x+dir[i][0];
                int next_y = y+dir[i][1];
                if (next_x<0 || next_x>=grid.size() || next_y<0 || next_y>=grid[0].size()) {
                    continue;
                }
                if (!visited[next_x][next_y] && grid[next_x][next_y]==1) {
                    que.push({next_x, next_y});
                    visited[next_x][next_y]=true;
                    count++;
                }
            }
        }
        return count;
    }
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        vector<vector<bool>> visited(grid.size(), vector<bool>(grid[0].size(), false));
        int result = 0;
        for (int i=0; i<grid.size(); i++) {
            for (int j=0; j<grid[0].size(); j++) {
                if (grid[i][j]==0) continue;
                //int count = dfs(grid, visited, i, j);
                int count = bfs(grid, visited, i, j);
                result = max(result, count);
            }
        }
        return result;
    }
};

1020 先遍历四个边的岛屿 都标记之后 再数没标记的1有几个

class Solution {
private:
    int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
    void dfs (vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
        if (x<0 || x>=grid.size() || y<0 || y>=grid[0].size()) return;
        if (visited[x][y] || grid[x][y]==0) return;
        
        visited[x][y]=true;
        int count = 1;
        for (int i=0; i<4; i++) {
            int next_x=x+dir[i][0];
            int next_y=y+dir[i][1];
            dfs(grid, visited, next_x, next_y);
        }
    }

    void bfs (vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
        queue<pair<int, int>> que;
        que.push({x,y});
        visited[x][y]=true;

        while (!que.empty()) {
            int x= que.front().first;
            int y= que.front().second;
            que.pop();
            for (int i=0; i<4; i++) {
                int next_x=x+dir[i][0];
                int next_y=y+dir[i][1];
                if (next_x<0 || next_x>=grid.size() || next_y<0 || next_y>=grid[0].size()) continue;
                if (visited[next_x][next_y] || grid[next_x][next_y]==0) continue;
                que.push({next_x, next_y});
                visited[next_x][next_y]=true;
            }
        }
        
    }


public:
    int numEnclaves(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<bool>> visited(grid.size(), vector<bool>(grid[0].size(), false));
        for (int i=0; i<m; i++) {
            if (!visited[i][0] && grid[i][0]==1) bfs(grid, visited, i, 0);
            if (!visited[i][n-1] && grid[i][n-1]==1) bfs(grid, visited, i, n-1);
        }
        for (int i=0; i<n; i++) {
            if (!visited[0][i] && grid[0][i]==1) bfs(grid, visited, 0, i);
            if (!visited[m-1][i] && grid[m-1][i]==1) bfs(grid, visited, m-1, i);
        }

        int count = 0;
        for (int i=1; i<m-1; i++) {
            for (int j=1; j<n-1; j++) {
                if (!visited[i][j] && grid[i][j]==1) {
                    count++;
                }
            }
        }
        return count;
    }
};

130 跟上一题一样 把四边的都标记完之后改中间没标记的变成X

class Solution {
private:
    int dir[4][2]={{0,1}, {0,-1}, {1,0}, {-1,0}};
    void dfs(vector<vector<char>>& board, vector<vector<bool>>& visited, int x, int y) {
        if (x<0 || x>=board.size() || y<0 || y>=board[0].size()) return;
        if (visited[x][y] || board[x][y]=='X') return;
        
        visited[x][y]=true;
        for (int i=0; i<4; i++) {
            int nx=x+dir[i][0];
            int ny=y+dir[i][1];
            dfs(board, visited, nx, ny);
        }
    }
public:
    void solve(vector<vector<char>>& board) {
        vector<vector<bool>> visited(board.size(), vector<bool>(board[0].size(), false));
        int m=board.size();
        int n=board[0].size();
        for (int i=0; i<m; i++) {
           dfs(board, visited, i, 0);
           dfs(board, visited, i, n-1); 
        }
        for (int j=0; j<n; j++) {
            dfs(board, visited, 0, j);
            dfs(board, visited, m-1, j);
        } 

        for (int i=1; i<m-1; i++) {
            for (int j=1; j<n-1; j++) {
                if (visited[i][j] || board[i][j]=='X') continue;
                board[i][j]='X';
            } 
        }
    }
};