深入递归回溯剪枝

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

public class _dfs素数环 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.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;

	}
}

2.

/*
你一定听说过“数独”游戏。
如下图所示，玩家需要根据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

再例如，输入：

800000000
003600000
070090200
050007000
000045700
000100030
001000068
008500010
090000400

程序应该输出：

812753649
943682175
675491283
154237896
369845721
287169534
521974368
438526917
796318452
*/

public class _Dfs数独 {
  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;
  }

}

 

/**
 * 问题描述:如果一个字符串包含两个相邻的重复子串，则称它为容易的串，其他串称为困难的串,
 * 如: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 _dfs困难的串 {
   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;
	  }
}

/*
给定整数序列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)

*/

public class _Dfs部分和 {

  private 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<Integer>());
  }


  private static void dfs(int[] a, int k, int cur, ArrayList<Integer> ints) {
    if (k == 0) {
      System.out.print("Yes (" + kk + " = ");
      int size = ints.size();
      for (int i = 0; i < size; i++) {
        System.out.print(ints.get(i) + (i == size - 1 ? "" : " + "));
      }
      System.out.println(")");
      exit(0);
    }
    if (k < 0 || cur == a.length) return;

    dfs(a, k, cur + 1, ints);//不要cur这个元素

    ints.add(a[cur]);
    int index = ints.size() - 1;
    dfs(a, k - a[cur], cur + 1, ints);
    ints.remove(index);//回溯
  }
}

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

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

public class _dfs4n皇后问题 {
  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);
}
  /*
   * 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;//恢复原状，这种解法这里是否恢复状态都行，为什么？
		  }
	  }
  }
  
}