剑指offer 递归与回溯法

---

剑指 Offer 12. 矩阵中的路径

class Solution {
//原来是求能走到的所有格子之和.简单的BFS,每加一个合法的坐标, res += 1.
    public int movingCount(int m, int n, int k) {
       int count=0;
       boolean[][] visited=new boolean[m][n]; 
        return  recur(0,0,m,n,k,visited); 
    }


     public int recur(int i,int j,int m,int n,int k, boolean visited[][]){

         //当在方格范围外面或者已经访问过或者方格之和大于18,则为0
     if(i<0||i>=m||j<0||j>=n||(i/10+i%10+j/10+j%10)>k||visited[i][j]==true){
              return 0;
     } 
         
          visited[i][j] = true;
          return recur(i+1,j,m,n,k,visited)+recur(i-1,j,m,n,k,visited)+
           recur(i,j-1,m,n,k,visited)+recur(i,j+1,m,n,k,visited)+1;
     }  
}

剑指 Offer 13. 机器人的运动范围

//原来是求能走到的所有格子之和.简单的BFS,每加一个合法的坐标, res += 1.
    public int movingCount(int m, int n, int k) {
       int count=0;
       boolean[][] visited=new boolean[m][n]; 
        return  recur(0,0,m,n,k,visited); 
    }


     public int recur(int i,int j,int m,int n,int k, boolean visited[][]){

         //当在方格范围外面或者已经访问过或者方格之和大于18,则为0
     if(i<0||i>=m||j<0||j>=n||(i/10+i%10+j/10+j%10)>k||visited[i][j]==true){
              return 0;
     } 
         
          visited[i][j] = true;
          return recur(i+1,j,m,n,k,visited)+recur(i-1,j,m,n,k,visited)+
           recur(i,j-1,m,n,k,visited)+recur(i,j+1,m,n,k,visited)+1;
     } 

剑指 Offer 38. 字符串的排列

 
import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> re = new ArrayList<String>();
        if (str == null || str.length() == 0) {
            return re;
        }
        HashSet<String> set = new HashSet<String>();
        fun(set, str.toCharArray(), 0);
        re.addAll(set);
        Collections.sort(re);
        return re;
    }
    void fun(HashSet<String> re, char[] str, int k) {
        if (k == str.length) {
            re.add(new String(str));
            return;
        }
        for (int i = k; i < str.length; i++) {
            swap(str, i, k);
            fun(re, str, k + 1);
            swap(str, i, k);
        }
    }
    void swap(char[] str, int i, int j) {
        if (i != j) {
            char t = str[i];
            str[i] = str[j];
            str[j] = t;
        }
    }
}

---

Leetcode 200 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

 public int numIslands(char[][] grid) {
         int numIslands=0;
     for(int i=0;i<grid.length;i++){
         for(int j=0;j<grid[0].length;j++){
              if(grid[i][j]=='1'){
                  numIslands++; 
                 infect(grid,i,j);
              }
         } 
     }
     return numIslands;  
  }

    public void infect(char[][] grid,int i,int j){
            if(i<0||j<0||i>=grid.length||j>=grid[0].length||grid[i][j] != '1') return;
            grid[i][j]='2'; 
            infect(grid,i+1,j);
            infect(grid,i,j+1);
            infect(grid,i-1,j);
            infect(grid,i,j-1);
    }
    

NC 46.加起来和为目标值的组合

import java.util.*;
/*
之前那道题给定数组中的数字可以重复使用，而这道题不能重复使用，只需要在之前的基础上修改两个地方即可，
首先在递归的 for 循环里加上 if (i > start && candidates[i] == candidates[i - 1]) continue; 这样可以防止 res 中出现重复项，
然后就在递归调用 dfs 里面的参数换成 i+1，这样就不会重复使用数组中的数字了，
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> combinationSum2(int[] candidates, int target) {
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> out = new ArrayList<Integer>();
        if(candidates == null || candidates.length <= 0) return null;
        Arrays.sort(candidates);
        dfs(candidates,target,0,out,res);
        return res;
    }
    public static void dfs(int[] candidates, int diff, int start, ArrayList<Integer> out, ArrayList<ArrayList<Integer>> res){
        if(diff == 0){//找到一个合法解
            res.add(new ArrayList<>(out));//这里要注意！！！！！一定要new
            return;
        }
        for (int i = start; i < candidates.length; i++) {//扩展状态
            if(diff < candidates[i]) return ;    //剪枝
            if (i > start && candidates[i] == candidates[i - 1]) continue;
            out.add(candidates[i]);            //执行扩展动作
            dfs(candidates,diff-candidates[i],i+1,out,res);
            out.remove(out.size()-1);         //撤销扩展动作
        }
    }
}