第七章(上) 递归、ＤＦＳ、剪枝、回溯问题

其实题目四个关键字就是一个递归的问题，解决：“有多少种方案这种问题”；

递归问题

１、递归改迭代：（递归可以改成迭代，递归是自上而下的倒着想，而迭代是自下而上的一步步更新变量，其实递归和迭代，迭代要更好一点，，因为他所占的空间要少，不需要递归那样用到栈的结构而开出一大片地方来）（但递归具有更强的表达力，用几句代码表达出很复杂的关系，改成迭代则需要写很多才可以）（递归问题分为数值型和非数值型）

楼梯有ｎ阶，小孩一次可以上１＼２＼３阶，计算小孩有多少种上楼方式　为防止溢出，请将结果ｍｏｄ１００００００００７

class Test48{
    static int mod = 1000000007;  //用Ｉｎｔ就可以，ｊａｖａ　int 类型的范围是:-2147483648 到2147483648（１０位）
    public static void main(String[] args) {
        
    }
    static long recursion(int n){

        if(n<0) return 0;
        if(n==0 || n==1) return 1;
        if(n==2) return 2;
        return recursion(n-1)%mod+recursion(n-2)%mod+recursion(n-3)%mod;
    }
    static int recursion2(int n){
        if(n<0) return 0;
        if(n==0||n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 4;
        int x1 = 1;
        int x2 = 2;
        int x3 =4;
        for(int i=4;i<=n;i++){
            int x_1 = x1;
            x1 = x2%mod;
            x2 = x3%mod;
            x3 = ((x1+x2)%mod+x_1)%mod;
        }
        return x3;
    }
}

２、机器人走网格问题：

有一个　ｘ×Ｙ的网格，一个机器人走个点且只能向右或向下，要从左上角到右下角，问机器人有多少种算法，，ｘ＋ｙ要小于等于１２

关键是　ｆ（ｘ，ｙ）　＝　ｆ（ｘ，ｙ－１）＋ｆ（ｘ－１，ｙ）

还是同样有两种写法　

class Test48{
    public static void main(String[] args) {

    }
    //倒着想
    static int solve(int x,int y){
        if(x==1 || y==1){
            return 1;
        }
        return solve(x-1,y)+solve(x,y-1);
    }
    //顺着想（但是因为是二纬的，所以保存历史数据要用二纬表来保存,但是这个存我觉得很好存哎，因为不用去拿一个变量来回换，而是直接存成二维数组）
    static int solve2(int m,int n){
        int [][]state = new int[m+1][n+1];//都从第一行或者第一列开始存，不要０的
        for(int i=1;i<=n;i++){
            state[1][i] = 1;
        }
        for(int i=1;i<=m;i++){
            state[i][1]= 1;
        }
        for(int i=2;i<=m;i++){
            for(int j=2;j<=n;j++){
                state[i][j] = state[i][j-1]+state[i][j-1];

            }
        }
        return state[m][n];
    }
}

３、硬币表示问题：

８种面值硬币　１，２，５，１０，２０，５０，１００，２００　给定一个数值ｎ

思路：在循环当中递归，每个小老板只决定最大面额的币用多少张

然后剩下的钱交给下一个去处理

这里比机器人复杂的地方在于不是一个地方要还是不要，，而是这个东西我要一个，或者我要两个，或者我要三个（在循环中递归）

class Test48{
    public static void main(String[] args) {

    }
    static int countways(int n){
        if(n<=0) return 0;
        return countwayscore(n,new int[]{1,5,10,25},3);//３表示第一次可选范围是０～３

    }
    static int countwayscore(int n,int[] coins,int cur){
        if(cur==0) return 1;
        int res =0;
        for(int i=0;i*coins[cur]<=n;i++){
            int shengyu = n-i*coins[cur];
            res+=countwayscore(shengyu,coins,cur-1);
        }
        return res;
    }
}

４、递归问题的非数值问题的解法（就是需要用容器去装了，生成一点，装一点，慢慢改变）

非法括号问题：输入ｎ，打印ｎ对括号的全部有效组合

import java.util.HashSet;
import java.util.Set;

class Test48{
    public static void main(String[] args) {

        Set par= parenthesis(3);
        System.out.println(par);
    }
    static Set parenthesis(int n){
        Set s_n = new HashSet<>();
        if(n==1){
            s_n.add("()");
            return s_n;
        }
        Set s_n_1 = parenthesis(n-1);
        for(String ex:s_n_1){
            s_n.add("()"+ex);
            s_n.add(ex+"()");
            s_n.add("("+ex+")");
        }
        return s_n;
    }
    //正着写
    static Set parenthesis2(int n){
        Set res = new HashSet<>();
        res.add("()");
        if(n==1){
            return res;
        }
        for(int i=2;i<=n;i++){
            Set res_new = new HashSet<>();

            for(String e:res){
                res_new.add(e+"()");
                res_new.add("()"+e);
                res_new.add("("+e+")");
            }
            res = res_new;
        }
        return res;
    }
}

５、非空子集

public class _9_4非空子集 {

  public static void main(String[] args) {
    int[] A = {1, 2, 3};
    _9_4非空子集 obj = new _9_4非空子集();

    Set> subsets3 = obj.getSubsets3(A, A.length);
    System.out.println(subsets3);

    Set> subsets2 = obj.getSubsets2(A, A.length);
    System.out.println(subsets2);

    ArrayList> subsets = obj.getSubsets(A, A.length);
    System.out.println(subsets);
  }

  /**
   * 二进制法,迭代法,或者逐步生成法
   * @param A
   * @param n
   * @return
   */
  public ArrayList> getSubsets(int[] A, int n) {
    Arrays.sort(A);//正序排序
    ArrayList> res = new ArrayList<>();//大集合

    for (int i = Case11_NExponent.ex(2, n) - 1; i > 0; i--) {//大数字-1
      ArrayList s = new ArrayList<>();//对每个i建立一个集合
      for (int j = n - 1; j >= 0; j--) {//检查哪个位上的二进制为1,从高位开始检查,高位对应着数组靠后的元素
        if (((i >> j) & 1) == 1) {
          s.add(A[j]);
        }
      }
      res.add(s);
    }
    return res;
  }

  /*迭代大法*/
  public Set> getSubsets2(int[] A, int n) {
    Set> res = new HashSet<>();
    res.add(new HashSet<>());//初始化为空集
    //从第一个元素开始处理
    for (int i = 0; i < n; i++) {
      Set> res_new = new HashSet<>();//新建一个大集合,,zhe ge da ji he li mian jia wan dongxi hou zai tihuan diao yuanlai de jihe
      res_new.addAll(res);//把原来集合中的每个子集都加入到新集合中
      //遍历之前的集合,全部克隆一遍
      for (Set e : res) {
        Set clone = (Set) ((HashSet) e).clone();
        clone.add(A[i]);//把当前元素加进去
        res_new.add(clone);//把克隆的子集加到大集合中
      }
      res = res_new;
    }
    return res;
  }

  public Set> getSubsets3(int[] A, int n) {
    // Arrays.sort(A);
    return getSubsets3Core(A, n, n - 1);

  }


  private Set> getSubsets3Core(int[] A, int n, int cur) {
    Set> newSet = new HashSet<>();
    if (cur == 0) {//处理第一个元素
      Set nil = new HashSet<>();//空集
      Set first = new HashSet<>();//包含第一个元素的集合
      first.add(A[0]);
      newSet.add(nil);
      newSet.add(first);
      return newSet;
    }

    Set> oldSet = getSubsets3Core(A, n, cur - 1);//dao zhe chu li de 
    for (Set set : oldSet) {
      //对于每个子集,cur这个元素可以加进去,也可以不加进去
      newSet.add(set);//保留原样
      Set clone = (Set) ((HashSet) set).clone();
      clone.add(A[cur]);//添加当前元素
      newSet.add(clone);
    }
    return newSet;
  }
}

７、全排列问题：

不存在要不要的问题，就是顺序的问题

（用集合的思路去插空）

import java.util.ArrayList;

class Test48{
    public static void main(String[] args) {
        ArrayList res = getpermutation("abcd");
        System.out.println( res);
    }
    static ArrayList getpermutation(String A){
        int n  = A.length();
        ArrayList res = new ArrayList<>();
        res.add(A.charAt(0)+"");  //初始化，包含第一个字符

        for (int i=1;i res_new  = new ArrayList<>();
            char c= A.charAt(i);
            for(String str:res){
                String newstr = c+str;
                res_new.add(newstr);
                newstr = str + c;//加在后面
                res_new.add(newstr);
                for(int j =1;j

全排列问题之递归

import java.util.ArrayList;

class Test48{
    public static void main(String[] args) {
        ArrayList res = getpermutation("abcd");
        System.out.println( res);
    }
    static ArrayList getpermutation(String A){
        int n  = A.length();
        ArrayList res = new ArrayList<>();
        res.add(A.charAt(0)+"");  //初始化，包含第一个字符

        for (int i=1;i res_new  = new ArrayList<>();
            char c= A.charAt(i);
            for(String str:res){
                String newstr = c+str;
                res_new.add(newstr);
                newstr = str + c;//加在后面
                res_new.add(newstr);
                for(int j =1;j

全排列之回溯算法

难点：多路递归　，回溯（回复到原点），

import java.util.ArrayList;
import java.util.Arrays;

class Test48{
    public static void main(String[] args) {
        ArrayList res = getpermutation("12345");
        System.out.println(res);
    }
    static ArrayList res = new ArrayList<>();
    static ArrayList getpermutation(String A){
        char[] arr= A.toCharArray();
        Arrays.sort(arr);
        getpermutationcore(arr,0);
        return res;
    }
    static void getpermutationcore(char[] arr,int k){
        if(k==arr.length){
            res.add(new String(arr));
        }
        for(int i=k;i

全排列之前缀扫描法

class Test48{
    public static void main(String[] args) {
        String s = "123";
        permutation("",s.toCharArray());
    }
    static int count =0;
    static int k= 3;
    static void permutation(String prefix,char[] arr){
        if(prefix.length() == arr.length){
            count++;
            if(count==k){
                System.out.println("----------"+prefix);

            }
        }
        for(int i=0;i

８、封闭式举例

递归中封闭式问题的意思就是可以直接用数学归纳法得出答案的问题

例如：汉诺塔问题　举个例子就知道是２^n-1

斐波那契数列第ｎ项，也可以用公式，，矩阵【１，１】成那个矩阵的算法

上楼梯问题　

上述问题重在找到规律

以下深搜开始啦！

ＤＦＳ：本质是啥呢？就是一直办法一直往下走，走不下去了就摁下撤销键，去尝试另一种办法，，这些办法之间起始是平行关系。（嗯撤销键的过程其实就是回溯问题，有的深搜就不用回溯，比如水洼数问题）ｄｆｓ是一个自己调用自己的过程，而ｂｆｓ确是图的问题，现不在这里说　　　要注意的起始思路就是不一定需要把行加加列加加放在大循环里，他们的变化可能是在整个条件内部的下一状态

９、ｄｆｓ例题：

你一定听说过“数独”游戏。
如下图所示，玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个同色九宫内的数字均含1-9，不重复。
数独的答案都是唯一的，所以，多个解也称为无解。
本图的数字据说是芬兰数学家花了3个月的时间设计出来的较难的题目。但对会使用计算机编程的你来说，恐怕易如反掌了。
本题的要求就是输入数独题目，程序输出数独的唯一解。我们保证所有已知数据的格式都是合法的，并且题目有唯一的解。
格式要求，输入9行，每行9个数字，0代表未知，其它数字为已知。
输出9行，每行9个数字表示数独的解。
输入：

005300000
800000020
070010500
400005300
010070006
003200080
060500009
004000030
000009700

程序应该输出：

145327698
839654127
672918543
496185372
218473956
753296481
367542819
984761235
521839764

public class Dfs1_数独 {
  public static void main(String[] args) {
    // System.out.println((char)('0'+1));
    Scanner sc = new Scanner(System.in);
    char[][] table = new char[9][];
    for (int i = 0; i < 9; i++) {
      table[i] = sc.nextLine().toCharArray();
    }
    dfs(table, 0, 0);
  }

  private static void dfs(char[][] table, int x, int y) {
    if (x == 9) {
      print(table);
      System.exit(0);
    }
    if (table[x][y] == '0') {//虚位以待
      for (int k = 1; k < 10; k++) {
        if (check(table, x, y, k)) {
          // f = false;
          table[x][y] = (char) ('0' + k);
          dfs(table, x + (y + 1) / 9, (y + 1) % 9);小技巧，ｙ等于９的时候下一次就要下一行了，ｘ＋他就换到下一行了，ｙ也是，到了９就重新回到１
        }
      }
      table[x][y] = '0';//回溯

    } else {
      dfs(table, x + (y + 1) / 9, (y + 1) % 9);//处理下一个状态
    }

  }

  private static void print(char[][] table) {
    for (int i = 0; i < 9; i++) {
      System.out.println(new String(table[i]));
    }
  }

  private static boolean check(char[][] table, int i, int j, int k) {
    //检查同行和同列
    for (int l = 0; l < 9; l++) {
      if (table[i][l] == (char) ('0' + k)) return false;
      if (table[l][j] == (char) ('0' + k)) return false;
    }
    //检查小九宫格
    for (int l = (i / 3) * 3; l < (i / 3 + 1) * 3; l++) {
      for (int m = (j / 3) * 3; m < (j / 3 + 1) * 3; m++) {
        if (table[l][m] == (char) ('0' + k)) return false;
      }
    }
    return true;
  }

}

１０、部分和

给定整数序列a1,a2,...,an,判断是否可以从中选出若干数,使它们的和恰好为k.

    1≤n≤20

    -10^8≤ai≤10^8

    -10^8≤k≤10^8

样例:

输入

    n=4
    a={1,2,4,7}
    k=13
输出:

    Yes (13 = 2 + 4 + 7)

思路：这题起始可以用子数组做，，求出所有的子数组，然后看等不等于１３

另外，ｄｆｓ也可以

import java.util.ArrayList;
import java.util.Scanner;

class Main{
    static int kk;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int k = sc.nextInt();//13
        kk =k;
        dfs(a,k,0,new ArrayList());

    }
    static void dfs(int[] a, int k, int cur,ArrayList ints){
        if(k==0){
            System.out.print("Yes("+kk+" = ");
            int size  = ints.size();
            for(int i=0;i

１１、水洼数（这个递归就不需要回溯）

有一个大小为 N*M 的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出
园子里总共有多少水洼？（八连通指的是下图中相对 W 的*的部分）

    ***
    *W*
    ***

限制条件

 N, M ≤ 100

 样例:

 输入
    N=10, M=12

园子如下图（'W'表示积水， '.'表示没有积水）

W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

输出

    3

import java.util.Scanner;

public class Main {
    private static int n;
    private static int m;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        char[][] a = new char[n][];
        for (int i = 0; i < n; i++) {
            a[i] = sc.next().toCharArray();
        }
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (a[i][j] == 'W') {
                    dfs(a, i, j);//清除一个水洼
                    cnt++;
                }
            }
        }
        System.out.println(cnt);
    }

    private static void dfs(char[][] a, int i, int j) {
        a[i][j] = '.';

        for (int k = -1; k < 2; k++) {//-1,0,1
            for (int l = -1; l < 2; l++) {//-1,0,1
                if (k == 0 && l == 0) continue;//过滤掉本身这种情况，，直接看下一种

                if (i + k >= 0 && i + k <= n - 1 && j + l >= 0 && j + l <= m - 1) {//不越界
                    if (a[i + k][j + l] == 'W')
                        dfs(a, i + k, j + l);
                }
            }
        }
    }
}

此题相关：

题目：Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子 

 1   2   3  4  5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9
一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

import java.util.Scanner;

public class test {
    static int r,c,sum=0;
    static int[][]map;
    static int[][] memo;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        r = sc.nextInt();
        c = sc.nextInt();
        map = new int[r][c];
        memo = new int[r][c];
        for(int i=0;i= 0 && i + k <= r - 1 && j + l >= 0 && j + l <=c - 1&&memo[i][j]>memo[i+k][j+l]){
                    len = Math.max(len,memo[i+k][j+l]+1);
                }
            }
        }
        memo[i][j] = len;
        return memo[i][j];
    }
}

 这个代码目前不对，，思路是对的，，发现后会把代码改过来。

１２、ｎ皇后问题

请设计一种算法，解决著名的n皇后问题。这里的n皇后问题指在一个n*n的棋盘上放置n个棋子，
 * 使得每行每列和每条对角线上都只有一个棋子，求其摆放的方法数。

 给定一个int n，请返回方法数，保证n小于等于15

public class Dfs_4n皇后问题 {
  static int n;
  static int cnt;

  static int[] rec;

  public static void main(String[] args) {
    n = 4;
    rec = new int[4];
    dfs(0);
    System.out.println(cnt);
  }

  /**
   *
   * @param row 当前正在处理的行
   */
  private static void dfs(int row) {
    if (row == n) {
      cnt++;
      return;
    }
    //依次尝试在某列上放一个皇后
    for (int col = 0; col < n; col++) {
      boolean ok = true;
      //检验这个皇后是否和之前已经放置的皇后有冲突
      for (int i = 0; i < row; i++) {
        if (rec[i] == col || i + rec[i] == row + col || rec[i] - i == col - row) {
          ok = false;
          break;
        }
      }
      /*=======这里可以认为是剪枝=======*/
      //这一行的这一列可以放
      if (ok) {
        rec[row] = col; //标记
        dfs(row + 1); //继续找下一行
        // rec[row]=0; //恢复原状，这种解法这里是否恢复状态都行，为什么？
      }
    }
  }

}

１３、 * 输入正整数n，对1-n进行排列，使得相邻两个数之和均为素数，
 * 输出时从整数1开始，逆时针排列。同一个环应恰好输出一次。
 * n<=16
 *
 * 如输入：6
 * 输出：
 * 1 4 3 2 5 6
 * 1 6 5 2 3 4
 *

public class Dfs_5素数环 {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int[] r = new int[n];
    r[0] = 1;
    dfs(n, r, 1);
  }

  private static void dfs(int n, int[] r, int cur) {
    if (cur == n && isP(r[0] + r[n - 1])) {//填到末尾了,还有首尾相加为素数才算成功
      print(r);
      return;
    }

    for (int i = 2; i <= n; i++) {//尝试用每个数字填到cur这个位置  
      if (check(r, i, cur)) {//r中没有i这个数,且和上一个数之和为素数
        r[cur] = i;//试着将i放在cur位置,往前走一步
        dfs(n, r, cur + 1);
        r[cur] = 0;//回溯
      }

    }
  }

  private static void print(int[] r) {
    for (int i = 0; i < r.length; i++) {
      System.out.print(r[i] + (i == r.length - 1 ? "" : " "));
    }
    System.out.println();
  }

  private static boolean check(int[] r, int i, int cur) {
    for (int e : r) {
      if (e == i || !isP(r[cur - 1] + i)) return false;
    }
    return true;
  }

  private static boolean isP(int k) {
    for (int i = 2; i * i <= k; i++) {
      if (k % i == 0) return false;
    }
    return true;

  }
}

１４、

 * 问题描述:如果一个字符串包含两个相邻的重复子串，则称它为容易的串，其他串称为困难的串,
 * 如:BB，ABCDACABCAB,ABCDABCD都是容易的，A,AB,ABA,D,DC,ABDAB,CBABCBA都是困难的。

 输入正整数n,L，输出由前L个字符(大写英文字母)组成的，字典序第n小的困难的串。
 例如，当L=3时，前7个困难的串分别为:
 A,AB,ABA,ABAC,ABACA,ABACAB,ABACABA
 n指定为4的话,输出ABAC

public class Main{
    public static void main(String[] args) {
        int n = 10;
        int l = 4;
        dfs(l, n, "");
        // isHard("0123020120",1);
    }

    static int count;

    private static void dfs(int l, int n, String prefix) {

        //尝试在prefix后追加一个字符
        for (char i = 'A'; i < 'A' + l; i++) {
            if (isHard(prefix, i)) {//是困难的串,就组合起来输出
                String x = prefix + i;
                System.out.println(x);
                count++;//计数
                if (count == n)
                    System.exit(0);

                dfs(l, n, x);
            }
        }
    }

    /**
     * 判断prefix+i是否一个困难的串
     * 1.遍历所有的长度为偶数的子串,看是否对称
     * 2.prefix是一个困难的串 ABACA i
     * @param prefix
     * @param i
     * @return
     */
    private static boolean isHard(String prefix, char i) {
        int count = 0;//截取的宽度
        for (int j = prefix.length() - 1; j >= 0; j -= 2) {
            final String s1 = prefix.substring(j, j + count + 1);
            final String s2 = prefix.substring(j + count + 1) + i;
            if (s1.equals(s2))
                return false;
            count++;
        }
        return true;
    }
}

我们考虑到这里传进方法来的本来就是一个困难的串，所以并不需要像上面这样进行搜索情况的判断，只需要考虑当前加入的字符与其他字符组合起来再与相邻长度的字符串进行比较来看一下是否相同，如果相同那么加进来这个字符之后变成了容易的串，那么这个字符应该舍弃

这里需要好好体会一下为什么那个困难的串要那么判断　　ｃｏｕｎｔ作为截取的长度，每次加一，ｊ是起始端，判断是否对称一定是偶数，所以一次减二

sunbstring的用法：
public String substring(int beginIndex)

或

public String substring(int beginIndex, int endIndex)

参数

• beginIndex -- 起始索引（包括）, 索引从 0 开始。

• endIndex -- 结束索引（不包括）。