[易读易懂] 骑士游历算法 Knight's Tour Problem

1、问题描述

在一个N*M的棋盘上,在任意位置放置一个骑士,骑士的走"日字",和象棋中的马一样。

问该骑士能否不重复遍历整个棋盘。下面的方法本质还是穷举,所以就写成可以计算出共有多少种不同的遍历方法。

2、分析与思路

根据题意,骑士走的下一步可能在棋盘上有多种选择(最多8种),需要选择1种,然后继续走下去,直到无处可走。

无处可走时有两种情况:

情况一:成功完成了遍历,那么接下来就通过回溯(回到上一步的位置,重新选择下一步的位置),寻找其他的走法。

情况二:未完成遍历,接下来还是要通过回溯继续寻找能够完成遍历的走法。

以上可以知这是一个DFS(深度优先搜索)问题,并且需要回溯。

3、代码(Java版)

算法可以统计出共有多少中不同的遍历方法,以及多少种失败的尝试。并可以给出每次无法前进时棋盘的状态和每步走法。

/*
 * Quesion: Kight's tour in n*m board  骑士(棋盘上走日字)游历问题,n*m棋盘,从角出发,能否不重复的遍历整个棋盘,有几种不同的遍历方法
 * Author: Mingshan Jia
 * Date: 2018/4/16
 * */
/* 
 *┼——┼——┼——┼——┼——┼  
 *│  │ 4│  │5 │  │  
 *┼——┼——┼——┼——┼——┼  
 *│ 3│  │  │  │6 │       
 *┼——┼——┼——┼——┼——┼        
 *│  │  │█ │  │  │        每走一步后按照1~8的位置次序去尝试走下一步,DFS
 *┼——┼——┼——┼——┼——┼  
 *│ 2│  │  │  │7 │   
 *┼——┼——┼——┼——┼——┼ 
 *│  │ 1│  │8 │  │   
 *┼——┼——┼——┼——┼——┼    
 **/	
package com.exercise;

import java.util.ArrayList;
import java.util.Collections;

public class Solution { 
	
	static final int[] xMove= {2,1,-1,-2,-2,-1,1,2};        //xMove和yMove一起组成每一步的偏移量
	static final int[] yMove= {-1,-2,-2,-1,1,2,2,1};

	public void solveKnightTravel(int n,int m) {
		
	    int weight=0; //权重值代表第几步走到该位置;
	    int count=0; //完全遍历的解数;
	    int countFail=0; //失败尝试次数
		int[][] A=new int[n][m];	
	    ArrayList<Boolean> resList=new ArrayList<Boolean>();  //存储无法继续走时棋盘的状态(false或true,true代表遍历完成)
	    
		knightJump(A,n-1,0,resList,weight);   //核心DFS,从(n-1,0)的位置开始跳	
		
		count=Collections.frequency(resList, true);   //true的次数:不同的遍历数
		countFail=Collections.frequency(resList, false);//false的次数:失败的走法
		System.out.println("一共有"+count+"种不同的遍历方法");  //3*4的情况下有2种走法,5*5有304种
		System.out.println("一共有"+countFail+"次失败的尝试"); 
	}
	
	public void knightJump(int[][] A, int row, int col,ArrayList<Boolean> resList,int weight){	
	  boolean sign=false;  //遍历完成标志
	  
	  if(!displacable(A,row,col)) {  //若该位置可走
		  weight++;
	      A[row][col]=weight;
	   
	      if(nowhereCanGo(A,row,col)) { //走到无路可走时,绘出棋盘的状态图,并检测是否完成
			  printBoard(A);
			  if(traverseCompleted(A)) {			
				  sign= true;
			  }
			  resList.add(sign);  
			  System.out.println(sign); 
		  }
	 
		  for(int k=0;k<8;k++) {    //走下一步
			  int nextRow=row+xMove[k];
			  int nextCol=col+yMove[k];
			  
			  if (nextRow<0 || nextRow>=A.length || nextCol<0 || nextCol>=A[0].length) {  
                  continue;  
              }
			  
			  knightJump(A,nextRow,nextCol,resList,weight);  		
		  }	
		  
		  A[row][col]=0; //回溯的操作,来到这里说明该位置下一步不可走,于是将该位置置0并减少权重,也就是说上一步不选择走此处,而去尝试下一个位置
		  weight--;
	   }
	}
	
	public boolean nowhereCanGo(int[][] A, int row, int col) {   //检测该位置是否无处可走
		
		boolean res=true;
		for(int i=0;i<8;i++) {
			res=res&&displacable(A,row+xMove[i],col+yMove[i]);
		}
		return res;	
	}
	
	public boolean displacable(int[][] A,int row,int col) {       //检测该位置能否放置
		if(!(row>=0&&row<A.length&&col>=0&&col<A[0].length&&A[row][col]==0))
			return true;
		else 
			return false;	
	}
	
	public void printBoard(int[][] A) {         //无法继续行走时画出棋盘
		for (int i = 0; i < A.length; i++) {  
            for (int j = 0; j < A[0].length; j++) {  
                if (A[i][j] < 10) {  
                    System.out.print(" " + A[i][j]);  
                } else  
                    System.out.print(A[i][j]);   
                System.out.print(" ");  
            }  
            System.out.println(); 
		}
	}
	
	public boolean traverseCompleted(int[][] A) {     //通过图总权重数判断是否完成了遍历
		int sum=0;
		   for(int i=0;i<A.length;i++) 
				for(int j=0;j<A[0].length;j++) 
					sum+=A[i][j];
		   if(sum==(1+A.length*A[0].length)*A.length*A[0].length/2)   //如果sum=1+2+...+N*M,则完成遍历
			       return true;	   
		   else 
			   return false;
	}	
	
	public static void main(String[] args) {
		Solution solution=new Solution();
		solution.solveKnightTravel(3,4);
	}
}

3*3的结果演示如下

 7  2  5 
 4  0  8 
 1  6  3 
false
 3  8  5 
 6  0  2 
 1  4  7 
false
一共有0种不同的遍历方法
一共有2次失败的尝试



阅读更多
个人分类: 算法
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭