[高频] 五. 如何高效实现搜索类题目

130. Sorrounded Regions：  点击打开链接

思路：从四个最外边向里面搜索，只要是遇到'O'，就是可以从外面走通的，装入queue

         将搜过的为'O'的元素进行遍历，并标记为true，

         找它的四个邻居点，如果在边界点之内为'O'并且是没有标记为true的，要做标记等待被遍历

         最后将没有标记成true的'O'标记为'X'，这些是内部围着的'X'，返回地图

class Pair{
    int x;
    int y;
    Pair(int x, int y){
        this.x = x;
        this.y = y;
    }
}

public class Solution {
    /**
     * @param board a 2D board containing 'X' and 'O'
     * @return void
     */
    
    public void surroundedRegions(char[][] board) {
        if(board==null || board.length == 0) return;
        boolean[][] marked = new boolean[board.length][board[0].length];
        Queue<Pair> queue = new LinkedList<Pair>();
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
       
        for(int i = 0; i < board[0].length; i++){                        //最上，最下两条边
            if(board[0][i] == 'O'){
                queue.offer(new Pair(0, i));
            }
            if(board[board.length - 1][i] == 'O'){
                queue.offer(new Pair(board.length - 1, i));
            }
        }
        
        for(int j = 0; j < board.length; j++){                           //最左，最右两条边
            if(board[j][0] == 'O'){
                queue.offer(new Pair(j, 0));
            }
            if(board[j][board[0].length - 1] == 'O'){
                queue.offer(new Pair(j, board[0].length - 1));
            }
        }
        
        while(!queue.isEmpty()){
            Pair current = queue.poll();
            marked[current.x][current.y] = true;                         //每次poll出来的标记为true
            for(int k = 0; k < 4; k++){
                int newX=current.x + dx[k];
                int newY=current.y + dy[k];
                Pair newP=new Pair(newX,newY);
                if(isValid(board, newP)){
                    if(board[newX][newY] == 'O' && !marked[newX][newY]){
                        queue.add(newP);                            
                    }
                }
            }
        }
        
        for(int i = 0; i < board.length; i++){                           //剩余没被标记为true的'O'，都要标记为'X'
            for(int j = 0; j < board[0].length; j++){
                if(board[i][j] == 'O' && !marked[i][j]){
                    board[i][j] = 'X';
                }
            }
        }
    }
    
    private boolean isValid(char[][] board,Pair p){
        if(p.x<0 || p.x>=board.length){
            return false;
        }
        if(p.y<0 || p.y>=board[0].length){
            return false;
        }
        return true;
    }
}

663. Nearest Exit：  点击打开链接

思路：遍历整个matrix拿到所有gate，BFS所有gate点，如果四周有有效的INF点，INF的值更新为gate值+1

注意：已经更新的INF点，就不用再更新，即使以后的遍历恰好是别的gate的四周点，因为要求离门最近的距离，越先被更新说明离门越近

         obsatcle点不用管，一开始我也是对obstacle不知道怎么处理

class Point{
    int x;
    int y;
    Point(int x,int y){
        this.x=x;
        this.y=y;
    }
}
public class Solution {
    /**
     * @param rooms m x n 2D grid
     * @return nothing
     */
    public void wallsAndGates(int[][] rooms) {
        if(rooms==null || rooms.length==0){
            return;
        }
        final int INF = 2147483647;
        int[] dx={0,0,-1,1};
        int[] dy={1,-1,0,0};
        Queue<Point> queue=new LinkedList<>();
        for(int i=0;i<rooms.length;i++){
            for(int j=0;j<rooms[0].length;j++){
                if(rooms[i][j]==0){
                    queue.offer(new Point(i,j));
                }
            }
        }
        
        while(!queue.isEmpty()){
            Point p=queue.poll();
            for(int i=0;i<4;i++){
                int newX=p.x+dx[i];
                int newY=p.y+dy[i];
                Point newP=new Point(newX,newY);
                if(isValid(rooms,newP)){
                    if(rooms[newX][newY]==INF){
                        queue.offer(newP);
                        rooms[newX][newY]=rooms[p.x][p.y]+1;                //一层一层的值不断累加
                    }
                }
            }
        }
    }
    
    private boolean isValid(int[][] rooms,Point p){
        if(p.x<0 || p.x>=rooms.length){
            return false;
        }
        if(p.y<0 || p.y>=rooms[0].length){
            return false;
        }
        return true;
    }
}

425. Letter Combinations of a Phone Number： 点击打开链接

思路：枚举型dfs

时间：O(3^n)，每一层有三种选择，一共有n层

public class Solution {
    /**
     * @param digits A digital string
     * @return all posible letter combinations
     */
    ArrayList<String> result=new ArrayList<>();
    public ArrayList<String> letterCombinations(String digits) {
        if(digits==null || digits.length()==0){
            return result;
        }
        
        String[] array=new String[]{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};  
        dfs(0,digits.length(),"",digits,array);
        return result;
    }
    
    private void dfs(int n,int len,String str,String digits,String[] array){  //无脑地放入所有所需参数
        if(n==len){                                                           //再写退出情况
            result.add(str);  
            return;
        }
        
        int digit=digits.charAt(n)-'0';                                       //先写扩展情况
        for(char c:array[digit].toCharArray()){
            dfs(n+1,len,str+c,digits,array);                                  //String可以直接加char,int
        }
    }
}

652. Factorization： 点击打开链接

public class Solution {
    /**
     * @param n an integer
     * @return a list of combination
     */
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    public List<List<Integer>> getFactors(int n) {
        if(n<=1){
            return result;
        }
        dfs(2,n);
        return result;
    }
    
    private void dfs(int lastF,int remain){
        if(!list.isEmpty()){
            list.add(remain);                                        //判断的时候才装remain
            result.add(new ArrayList<Integer>(list));
            list.remove(list.size()-1);                              //装到result链之后还要remove
        }
        
        for(int i=lastF;i<=remain/i;i++){                            //能保证每个list顺序是non-descending order
            if(remain%i==0){                                         //也能保证后面的[6,2]不要，和[2,6]不重复
                list.add(i);
                dfs(i,remain/i);
                list.remove(list.size()-1);
            }
        }
    }
}

653. Add Operators： 点击打开链接

注意：String转化为int很容易溢出，因此要用long

public class Solution {
    /**
     * @param num a string contains only digits 0-9
     * @param target an integer
     * @return return all possibilities
     */
    public List<String> addOperators(String num, int target) {
        List<String> result=new ArrayList<>();
        if(num==null || num.length()==0){
            return result;
        }
        dfs(result,num,target,"",0,0,0);
        return result;
    }
    
    private void dfs(List<String> result,String num, int target,String path,int pos,long sum,long lastF){
        if(pos==num.length()){
            if(sum==target){
                result.add(path);
            }
        }
        
        for(int i=pos;i<num.length();i++){
            long cur=Long.valueOf(num.substring(pos,i+1));
            if(pos==0){                                                         //第一个数字前不能有符号
                dfs(result,num,target,path+cur,i+1,cur,cur);
            }else{
                dfs(result,num,target,path+"+"+cur,i+1,sum+cur,cur);
                dfs(result,num,target,path+"-"+cur,i+1,sum-cur,-cur);
                dfs(result,num,target,path+"*"+cur,i+1,sum-lastF+lastF*cur,lastF*cur);
            }
            if(num.charAt(pos)=='0'){                                           //数字不能有前导零
                break;
            }
        }
    }
}

634. Word Squares： 点击打开链接