回溯法 | n皇后问题

今早上看了一篇英语阅读之后，莫名有些空虚寂寞冷。拿出算法书，研读回溯法。我觉得n皇后问题完全可以用暴力方式，即先对n个数进行全排列，得到所有结果的下标组合，问题规模为n！。

全排列花了比较久的时间才编写出来。主要是没有找对思路。最终我想到了递归，即对4个数进行全排列可以化为把【对3个数进行了全排列】的结果拿出来，在下标为1-4的位置上各插上一个数，一次类推。于是我编写了全排列类：

 //全排列
 class Arrangment{
     int[][]ans;
     Arrangment(){}
     Arrangment(int[] nums){
         ans=createA(nums.length,nums);
     }
     void printNums(int[][] nums){
         int row=nums.length;
         int col=nums[].length;
         int i,j;
         for(i=;i<row;i++){
             for(j=;j<col;j++)
                 System.out.print(nums[i][j]+" ");
             System.out.print("\n");
         }
     }
      int[][]createA(int rank,int []nums){
         int[][] re;
         if(rank>){
             int[][] pre=createA(rank-,nums);
             int row=pre.length;
             int col=nums.length;
             re=new int[row*rank][rank];
             int index=;
             int i,j,k,m;
             for(i=;i<rank;i++){
                 for(j=;j<row;j++){
                     for(k=,m=;k<rank  ;k++){
                         if(k==i){//如果列下标等于i（在0~rank）中循环
                             re[index][k]=nums[rank-];
                             int a;
                             a=;
                         }else{
                             re[index][k]=pre[j][m];
                             m++;
                         }
                     }
                     index++;
                 }
             }

         }
         else{
             re=new int[][];
             re[][]=nums[];
         }
         return re;
     }
     private int factorial(int n){
         int re=;
         while(n>=)
             re*=(n--);
         return re;
     }
 }

使用这个全排列类，就可以构造所有的问题的求解空间了。

暴力求解算法：

 class N_Queens{
     int n;
     N_Queens(int inN){
         n=inN;
     }
     List<int[]> solved =new ArrayList<int[]>();
     void solveByBrutal(){//穷举求解

     boolean isComplied(int[] nums,int len){
         int i,j;
         for(i=0;i<len-1;i++)
             for(j=i+1;j<len;j++){
                 int a=Math.abs(i-j);
                 int b=Math.abs(nums[i]-nums[j]);
                 if(a==b || b==0)
                     return false;
             }
         return true;
     }
 }

然后我开始研究怎么使用【回溯法】进行解题。我看了严奶奶书上的伪代码，以及树形结构实例，感触颇深。原来我以为这个问题和8数码问题一样需要进行树的按层遍历，已经使用队列结构的，但是他既然使用了一种递归的思想，并且是深度优先的。用递归的入栈出栈，在【剪掉枝丫】（问题不可解）和【找到一个解】之后，自动的求下一个解。

回溯法代码：

 class N_Queens{
     int n;
     N_Queens(int inN){
         n=inN;
     }
     List<int[]> solved =new ArrayList<int[]>();
     void solveByBackTrace(){
         int[] nums=null;
         trial(nums,0);
     }
     void trial(int [] nums,int i){//棋盘上的前i行已经放置了【符合条件】的棋子
         if(i<n){
             int j,k;
             //第i行进行放置
             for(j=0;j<n;j++){//在第j列上进行遍历
                 int[] node=new int[n];//新建结点
                 for(k=0;k<i;k++)
                     node[k]=nums[k];//拷贝父结点
                 node[i]=j;//第i行第j列上放上一个皇后
                 if(isComplied(node,i+1)){//符合条件
                     trial(node,i+1);//扩展它的子节点
                 }
             }
         }else{
             solved.add(nums);
         }
     }

     boolean isComplied(int[] nums,int len){
         int i,j;
         for(i=0;i<len-1;i++)
             for(j=i+1;j<len;j++){
                 int a=Math.abs(i-j);
                 int b=Math.abs(nums[i]-nums[j]);
                 if(a==b || b==0)
                     return false;
             }
         return true;
     }
 }

完整代码：

 import java.util.*;

 public class Main {

     public static void main(String[] args) {
         while(true){
             System.out.print("请输入皇后的数目：");
             Scanner scan=new Scanner(System.in);
             int n=scan.nextInt();
             N_Queens problem=new N_Queens(n);
             int []nums={1,2,3};
             problem.isComplied(nums, 2);
             problem.solveByBrutal();
             problem.PrintChecker();
         }
     }

 }

 //全排列
 class Arrangment{
     int[][]ans;
     Arrangment(){}
     Arrangment(int[] nums){
         ans=createA(nums.length,nums);
     }
     void printNums(int[][] nums){
         int row=nums.length;
         int col=nums[0].length;
         int i,j;
         for(i=0;i<row;i++){
             for(j=0;j<col;j++)
                 System.out.print(nums[i][j]+" ");
             System.out.print("\n");
         }
     }
      int[][]createA(int rank,int []nums){
         int[][] re;
         if(rank>1){
             int[][] pre=createA(rank-1,nums);
             int row=pre.length;
             int col=nums.length;
             re=new int[row*rank][rank];
             int index=0;
             int i,j,k,m;
             for(i=0;i<rank;i++){
                 for(j=0;j<row;j++){
                     for(k=0,m=0;k<rank  ;k++){
                         if(k==i){//如果列下标等于i（在0~rank）中循环
                             re[index][k]=nums[rank-1];
                             int a;
                             a=0;
                         }else{
                             re[index][k]=pre[j][m];
                             m++;
                         }
                     }
                     index++;
                 }
             }

         }
         else{
             re=new int[1][1];
             re[0][0]=nums[0];
         }
         return re;
     }
     private int factorial(int n){
         int re=1;
         while(n>=1)
             re*=(n--);
         return re;
     }
 }

 class N_Queens{
     int n;
     N_Queens(int inN){
         n=inN;
     }
     List<int[]> solved =new ArrayList<int[]>();
     void solveByBrutal(){//穷举求解
         int i;
         int indexs[]=new int[n];
         for(i=0;i<n;i++) indexs[i]=i;
         Arrangment solve=new Arrangment(indexs);
         int[][] solceSpace=solve.ans;//构造所有解空间
         solved.clear();
         for(i=0;i<solceSpace.length;i++){
             if(isComplied(solceSpace[i],n))
                 solved.add(solceSpace[i]);
         }
         int a;
         a=0;
     }
     void solveByBackTrace(){
         int[] nums=null;
         trial(nums,0);
     }
     void trial(int [] nums,int i){//棋盘上的前i行已经放置了【符合条件】的棋子
         if(i<n){
             int j,k;
             //第i行进行放置
             for(j=0;j<n;j++){//在第j列上进行遍历
                 int[] node=new int[n];//新建结点
                 for(k=0;k<i;k++)
                     node[k]=nums[k];//拷贝父结点
                 node[i]=j;//第i行第j列上放上一个皇后
                 if(isComplied(node,i+1)){//符合条件
                     trial(node,i+1);//扩展它的子节点
                 }
             }
         }else{
             solved.add(nums);
         }
     }

     boolean isComplied(int[] nums,int len){
         int i,j;
         for(i=0;i<len-1;i++)
             for(j=i+1;j<len;j++){
                 int a=Math.abs(i-j);
                 int b=Math.abs(nums[i]-nums[j]);
                 if(a==b || b==0)
                     return false;
             }
         return true;
     }

     public String toString(){
         int i,j;
         String str=new String("");
         for(i=0;i<solved.size();i++){
             int [] out=solved.get(i);
             for(j=0;j<out.length;j++){
                 str+=out[j];
                 str+=" ";
             }
             str+="\n";
         }
         return str;
     }
     void PrintChecker(){
         int i,j,k;
         String out=new String();
         for(i=0;i<solved.size();i++){
             int[] nums=solved.get(i);
             for(j=0;j<nums.length;j++){
                 int l=nums[j];
                 int r=nums.length-1-nums[j];
                 for(k=0;k<l;k++) out+="□";
                 out+="■";
                 for(k=0;k<r;k++) out+="□";
                 out+="\n";
             }
             out+="\n";
         }
         System.out.print(out);
     }
 }

输出结果：

4皇后：

8皇后：

10皇后：