leetcode算法训练第六天：深度优先搜索和广度优先搜索

深度优先搜索（递归）

class Solution {
private:
    void dfs(vector<vector<char>>& grid,int n,int r){
        int nc=grid.size();
        int rc=grid[0].size();
        grid[n][r]='0';
        if(n>0&&grid[n-1][r]=='1')dfs(grid,n-1,r);
        if(n<(nc-1)&&grid[n+1][r]=='1')dfs(grid,n+1,r);
        if(r>0&&grid[n][r-1]=='1')dfs(grid,n,r-1);
        if(r<(rc-1)&&grid[n][r+1]=='1')dfs(grid,n,r+1);
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int nc=grid.size();
        int rc=grid[0].size();
        int sum=0;
        for(int n=0;n<nc;n++){
            for(int r=0;r<rc;r++){
                if(grid[n][r]=='1'){
                    sum++;
                    dfs(grid,n,r);
                }
            }
        }
        return sum;
    }
};

广度优先搜索(迭代）

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nc=grid.size();
        int rc=grid[0].size();
        int sum=0;
        queue<pair<int,int>>neighbor;
        for(int n=0;n<nc;n++){
            for(int r=0;r<rc;r++){
                if(grid[n][r]=='1'){
                    sum++;
                    grid[n][r]='0';
                    neighbor.push({n,r});//queue是用的push函数。
                    while(!neighbor.empty()){
                        auto res=neighbor.front();
                        neighbor.pop();
                        int i=res.first;
                        int j=res.second;
                        if(i>0&&grid[i-1][j]=='1'){
                             grid[i-1][j]='0';
                             neighbor.push({i-1,j});
                        }
                        if(i<(nc-1)&&grid[i+1][j]=='1'){
                             grid[i+1][j]='0';
                             neighbor.push({i+1,j});
                        }
                        if(j>0&&grid[i][j-1]=='1'){
                             grid[i][j-1]='0';
                             neighbor.push({i,j-1});
                        }
                        if(j<(rc-1)&&grid[i][j+1]=='1'){
                             grid[i][j+1]='0';
                             neighbor.push({i,j+1});
                        }
                    }
                }
            }
        }
        return sum;
    }
};

深度优先搜索1

class Solution {
private:
    void dfs(vector<vector<int>>& isConnected,int row,int line){
        int n=isConnected.size();
        isConnected[row][line]=0;
        for(int i=0;i<n;i++){
            if(isConnected[i][line]==1)dfs(isConnected,i,line);
        }
        for(int j=0;j<n;j++){
            if(isConnected[row][j]==1)dfs(isConnected,row,j);
        }
    }
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n=isConnected.size();
        int sum=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(isConnected[i][j]==1){
                    sum++;
                    dfs(isConnected,i,j);
                }
            }
        }
        return sum;
    }
};

深度优先搜索2（官方

class Solution {
public:
    void dfs(vector<vector<int>>& isConnected, vector<int>& visited, int provinces, int i) {
        for (int j = 0; j < provinces; j++) {
            if (isConnected[i][j] == 1 && !visited[j]) {
                visited[j] = 1;
                dfs(isConnected, visited, provinces, j);
            }
        }
    }

    int findCircleNum(vector<vector<int>>& isConnected) {
        int provinces = isConnected.size();
        vector<int> visited(provinces);
        int circles = 0;
        for (int i = 0; i < provinces; i++) {
            if (!visited[i]) {
                dfs(isConnected, visited, provinces, i);
                circles++;
            }
        }
        return circles;
    }
};