[Leetcode] BFS

DFS一般会使用递归调用的方式来实现，简单，但是如果递归的深度非常大，可能会造成递归栈的overflow

BFS可以实现对图的非递归遍历。

在leetcode当中有两道经典的BFS遍历的题目

[1] Number of Islands

public class Solution {
    private void set(int r,int c, char[][]grid,int rownum, int colnum,Queue<Integer> queue){
        if(r>=0&&r<rownum&&c>=0&&c<colnum&&grid[r][c]=='1'){
            grid[r][c]='2';
            queue.offer(r * colnum + c);
        }
        return;
    }
    private boolean expandWater(int r,int c, char[][] grid){
        int m= grid.length,n = grid[0].length;
        if(r<0||r>=m||c<0||c>=n||grid[r][c]!='1') return false;
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(r * n + c);
        grid[r][c]='2';
        while(!queue.isEmpty()){
            int dim = queue.poll();
            int row = dim / n;
            int col = dim % n;
            set(row+1,col,grid,m,n,queue);
            set(row-1,col,grid,m,n,queue);
            set(row,col-1,grid,m,n,queue);
            set(row,col+1,grid,m,n,queue);
        }
        return true;
    }
    public int numIslands(char[][] grid) {
        if(grid==null||grid.length==0) return 0;
        int count =0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(expandWater(i,j,grid)==true)
                    count++;
            }
        }
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]=='2')grid[i][j]='1';
            }
        }
        return count;
    }
}

 

[2] Surrounded Regions

http://www.cnblogs.com/deepblueme/p/4737638.html

import java.util.*;

public class Solution {
    private void set(int r,int c, Queue<Integer> queue,int rownum, int colnum, char [][] board){
        if(r>=0&&r<rownum&&c>=0&&c<colnum&&board[r][c]=='O'){
            queue.offer(r * colnum + c);
            board[r][c]='D';
        }
    }
    public void BFS(int row,int col, char [][] board){
        if(row<0||row>=board.length||col<0||col>=board[0].length||board[row][col]!='O') return;
        int m= board.length;
        int n = board[0].length;
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(row*n + col);
        board[row][col]= 'D';
        while(!queue.isEmpty()){
            int dimension = queue.poll();
            int r = dimension / n;
            int c = dimension % n;
            //left
            set(r,c-1,queue,m,n,board);
            //up
            set(r-1,c,queue,m,n,board);
            //right
            set(r,c+1,queue,m,n,board);
            //down
            set(r+1,c,queue,m,n,board);
        }
    }
    public void solve(char[][] board) {
        if(board==null|| board.length==0) return;
        //up down
        int m = board.length;
        int n = board[0].length;
        for(int i=0;i<n;i++){
            BFS(0,i,board);
            BFS(m-1,i,board);
        }
        //right left
        for(int i=1;i<m-1;i++){
            BFS(i,0,board);
            BFS(i,n-1,board);
        }
        //flip back D->O,O->X
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(board[i][j]=='D') board[i][j] = 'O';
                else if(board[i][j]=='O') board[i][j] = 'X';
            }
        }
    }
}