马踏棋盘问题(骑士周游问题)及其优化算法java实现

最新推荐文章于 2024-05-28 18:22:06 发布
原创 最新推荐文章于 2024-05-28 18:22:06 发布 · 3.4k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#DFS #马踏棋盘 #骑士周游 #八叉树

本文介绍了一种使用深度优先搜索解决马踏棋盘问题的方法，并通过贪心算法进行了优化，以减少搜索的时间。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

马踏棋盘问题java实现(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用或者进一步理解为一颗8叉树的深度遍历

package ccnu.offer.tree;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Scanner;

public class Demo07 {
	private static int X; // 棋盘的列数
	private static int Y; // 棋盘的行数
	private static boolean visited[]; // 用来标记棋盘上各个位置是否被访问过
	private static boolean finished; // 用来标记是否期盼所有位置均被访问(意味着已成功)

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入棋盘的行数和列数：");
		do{
			Y = sc.nextInt();
			X = sc.nextInt();
		}while(X <= 0 || Y <= 0);
		System.out.print("请输入起始位置(先行数后列数)：");
		int row, column;
		do{
			row = sc.nextInt();
			column = sc.nextInt();
		}while(row <= 0 || row > Y || column <= 0 || column > X);
		int[][] chessBoard = new int[Y][X];
		visited = new boolean[X * Y];
		long start = System.currentTimeMillis();
		traversalChessBoard(chessBoard, row - 1, column - 1, 1);
		long end = System.currentTimeMillis();
		System.out.println("共耗时：" + (end - start) + "ms");
		for(int[] rows : chessBoard){
			for(int columns : rows){
				System.out.print(columns + "\t");
			}
			System.out.println();
		} 
		sc.close();
	}

	public static void traversalChessBoard(int[][] chessBoard, int row, int column, int step) {
		chessBoard[row][column] = step;
		visited[row * X + column] = true; // 此位置已访问
		ArrayList<Point> ps = next(new Point(column, row)); // 由当前位置得到下一次所有位置的集合
		while (!ps.isEmpty()) {
			Point p = ps.remove(0);
			if (!visited[p.y * X + p.x]) { // 这个位置没有访问，那么就从这个位置开始进行下一次访问
				traversalChessBoard(chessBoard, p.y, p.x, step + 1);
			}
		}
		if(step < X * Y && !finished){ // (step < X * Y)这个条件成立，有两种情况：第一种，棋盘到目前为止仍没有走完;第二种，棋盘已经走完过，此时在回溯的过程中
			chessBoard[row][column] = 0; // 如果整个棋盘最终全部为零，则表示无解
			visited[row * X + column] = false;
		}else{
			finished = true;
		}
	}
	
	// 在当前位置p处，下一次的位置(最多有8个位置)
	public static ArrayList<Point> next(Point p) {
		ArrayList<Point> ps = new ArrayList<Point>();
		Point p1 = new Point(p);
		if ((p1.x = p.x - 2) >= 0 && (p1.y = p.y - 1) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 1) >= 0 && (p1.y = p.y - 2) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 1) < X && (p1.y = p.y - 2) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 2) < X && (p1.y = p.y - 1) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 2) < X && (p1.y = p.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 1) < X && (p1.y = p.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 1) >= 0 && (p1.y = p.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 2) >= 0 && (p1.y = p.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		return ps;
	}
}


贪心算法优化处理

    贪心算法（又称贪婪算法），是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。它只考虑局部的最优，从而让总体也最优。就我们这个马踏棋盘来说，我们每走一步都取最优的那个选择(而不是随便选择下一步)，从而让整体的算法也最优。

   那么此问题的局部最优选择是什么呢？答案是，对于当前的一步，如果它的下一步有多种选择，我们应该选择它的下一步中的下一步选择最少的那个作为它的下一步。理由：因为只有在这样的选择方案下，当方案不符时，能够最快的回溯到当前的这一步上来(例如，它的下一步有4种选择，并且这4种选择的各自的下一步又分别有3，10，1，8种选择，而现在只有选择了下一步中的某一个才能成功，那么问题就是如何以最快的速度遍历出它的下一步中正确选择，也就是说当当前选择不对时，如何快速回溯到当前这一步，很显然，那只有它的下一步的下一步选择越少才会越快的结束这个选择)，接着选择当前这一步的下一步选择次少作为它的下一步，依此类推。

package ccnu.offer.tree;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Demo07 {
	private static int X; // 棋盘的列数
	private static int Y; // 棋盘的行数
	private static boolean visited[]; // 用来标记棋盘上各个位置是否被访问过
	private static boolean finished; // 用来标记是否期盼所有位置均被访问(意味着已成功)
	private static int count = 1;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		do{
			System.out.print("请输入棋盘的行数和列数：");
			Y = sc.nextInt();
			X = sc.nextInt();
		}while(X <= 0 || Y <= 0);
		int row, column;
		do{
			System.out.print("请输入起始位置(先行数后列数)：");
			row = sc.nextInt();
			column = sc.nextInt();
		}while(row <= 0 || row > Y || column <= 0 || column > X);
		int[][] chessBoard = new int[Y][X];
		visited = new boolean[X * Y];
		long start = System.currentTimeMillis();
		traversalChessBoard(chessBoard, row - 1, column - 1, 1);
		long end = System.currentTimeMillis();
		System.out.println("共耗时：" + (end - start) + "ms");
		for(int[] rows : chessBoard){
			for(int columns : rows){
				System.out.print(columns + "\t");
			}
			System.out.println();
		}
		sc.close();
	}

	public static void traversalChessBoard(int[][] chessBoard, int row, int column, int step) {
		chessBoard[row][column] = step;
		visited[row * X + column] = true; // 此位置已访问
		ArrayList<Point> ps = next(new Point(column, row)); // 由当前位置得到下一次所有位置的集合
		sort(ps); // 按照当前(new Point(column, row))这步的下一步的下一步选择数目进行非递减排序
		while (!ps.isEmpty()) {
			Point p = ps.remove(0); // 每次选择仍然未选中的下一步的下一步选择数目最少的下一步作为当前这步的下一步
			if (!visited[p.y * X + p.x]) { // 这个位置没有访问，那么就从这个位置开始进行下一次访问
				traversalChessBoard(chessBoard, p.y, p.x, step + 1);
			}
		}
		if(step < X * Y && !finished){ // (step < X * Y)这个条件成立，有两种情况：第一种，棋盘到目前为止仍没有走完;第二种，棋盘已经走完过，此时在回溯的过程中
			chessBoard[row][column] = 0; // 如果整个棋盘最终全部为零，则表示无解
			visited[row * X + column] = false;
		}else{ // 此处代表已成功走出覆盖棋盘的完整路径，如果此时将结果输出(去掉finished变量)，以便回溯可以得到所有的结果
			finished = true;
		}
	}
	
	// 在当前位置p处，下一次的位置(最多有8个位置)
	public static ArrayList<Point> next(Point p) {
		ArrayList<Point> ps = new ArrayList<Point>();
		Point p1 = new Point(p);
		if ((p1.x = p.x - 2) >= 0 && (p1.y = p.y - 1) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 1) >= 0 && (p1.y = p.y - 2) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 1) < X && (p1.y = p.y - 2) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 2) < X && (p1.y = p.y - 1) >= 0) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 2) < X && (p1.y = p.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x + 1) < X && (p1.y = p.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 1) >= 0 && (p1.y = p.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		if ((p1.x = p.x - 2) >= 0 && (p1.y = p.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		return ps;
	}
	
	// 根据当前的这一步的所有下一步的选择数目进行非递减排序
	public static void sort(ArrayList<Point> ps){
		ps.sort(new Comparator<Point>() {
			@Override
			public int compare(Point o1, Point o2) {
				int count1 = next(o1).size(); // 当前这一步o1的下一步的选择数目
				int count2 = next(o2).size();
				if (count1 < count2) {
					return -1;
				} else if (count1 == count2) {
					return 0;
				} else {
					return 1;
				}
			}
		});
	}
	
}





贪心算法 --- 马踏棋盘（C）
Jensen
11-30 4515
五大常用算法之一，好高大上的东西，决定了把这五大算法给搞了，第一个贪心算法，百度一下它的概念，贴过了来了： 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。 贪婪算法是一种改进
二十五、程序员10大算法之马踏棋盘算法
陈大大的博客
10-26 450
一、马踏棋盘算法介绍 二、代码实现 import java.awt.Point; import java.util.ArrayList; import java.util.Comparator; public class HorseChessboard { private static int X; // 棋盘的列数 private static int Y; // 棋盘的行数 //创建一个数组，标记棋盘的各个位置是否被访问过 private static boolean visited[
马踏棋盘的贪心算法
weixin_33749242的博客
11-07 569
【问题描述】马的遍历问题。在８×８方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。【初步设计】首先这是一个搜索问题，运用深度优先搜索进行求解。算法如下：１、    输入初始位置坐标x,y；２、    步骤 c:　　　如果c&gt;64输出一个解，返回上一步骤c--(x,y) ← c计算(x,y)的八个方位的子结点，选出那此可行的子结点循环遍历所有可行子结点，步...
贪心算法马踏棋盘c语言,马踏棋盘（贪心算法）
weixin_36430300的博客
05-23 847
需求将马随机放在国际象棋的Board[0～7][0～7]的某个方格中，马按走棋规则进行移动。，走遍棋盘上全部64个方格。编制非递归程序，求出马的行走路线，并按求出的行走路线，将数字1，2，…，64依次填入一个8×8的方阵，输出之。分析最基本的应该是深度优先搜索，但是对于一个8×8的棋盘，如果采取暴力搜索，将会耗费很长时间而得不到一个结果，如果采用贪心算法，对路径有目的地筛选，尽量选择出口少的路先走...
马踏棋盘的贪心算法实现
10-24
VC++实现，生成可视化演示程序 棋盘式的，点一下所有步骤1234.。
马踏棋盘（骑士周游问题）JAVA
qq_55670428的博客
07-14 626
​ 马踏棋盘问题是旅行商问题（TSP）或哈密顿回路问题（HCP）的一个特例。在 8×8 的国际象棋棋盘上，用一个马按照马步跳遍整个棋盘，要求每个格子都只跳到一次，最后回到出发点。这是一个NP问题，通常采用回溯法或启发式搜索类算法求解。在 9×10 的中国象棋棋盘上也可以实现马步遍历。 ​...
马踏棋盘算法（骑士周游问题）
Ronz 的博客
02-08 5412
一、问题概述 马踏棋盘算法也被称为骑士周游问题。问题内容是： 将马随机放在国际象棋的 8× 8 棋盘的某个方格中， 马按走棋规则（马走日字）进行移动。要求每个方格只能走一次， 走遍棋盘上全部 64 个方格，求可行的路径。 二、思路分析 马踏棋盘问题实际上是图的深度优先搜索（DFS）的应用。 该问题的解决思想为： 假设以 V 为起点，首先找出在指定规则下 V 点下一步可能的落点。 在下一步的可能的落点中选择一个点（假设是 U 点），然后走到 U 点。 再以 U 点为起点，找出指定规则下 U 点下一步可能的
骑士周游问题（马踏棋盘）----贪心算法（动态规划补充）
Dr_RR的博客
05-28 1040
然后就是考虑调用的位置 ：应该在获取ps数组下一个可以走的位置有哪些之后就对这些路线的数量进行排序，而其位置就在traversalChessBoard方法下，在对ps数组进行遍历之前进行排序。//这里一定要放入一个新的p1点，不然会造成p1点的位置一直在变换。比如：下一次走的1号位置和2号位置，1号位置的下一步有两个选择，2号位置下一步有四个选择，那马下一步就走1号位置以减少回溯次数。//这样就把ps数组里的每一个点的下一个位置的多少进行了排序，优先走下一步的下一步的次数少的格子。
马踏棋盘(骑士周游问题 思路分析及疑问分析)
qq_44782542的博客
11-06 1155
所谓“马踏棋盘”问题，就是指在中国象棋的棋盘上，用马的走法走遍整个棋盘，在8*8的方格中，每个格都要遍历，且只能遍历一次。 思路分析 每一个马都有八个下一步的选择，我们在满足要求的点中任意找一个进行遍历，当八个点都不满足要求时，就回溯上一步，找其他点进行遍历。 解决方法： 我们从图中可以看到，一个位置的马可以有八个不同方向的下一步。如何表示下一步呢？ 设当前马的坐标为(x,y)，则下一步为(x-2,y+1)、(x-1,y+2)、(x+1,y+2)、(x+2,y+1)、(x+2,y...
马踏棋盘算法 贪心算法优化
linxintaozi的专栏
04-13 813
马踏棋盘算法 贪心算法优化
c++马踏棋盘贪心算法
12-18
c++解决马踏棋盘问题
C++马踏棋盘程序（贪心算法）
03-13
经典的马踏棋盘程序 采用贪心算法求解 时间复杂度为O(m*n)
贪心算法求解马踏棋盘
01-03
利用贪心算法求解马踏棋盘，数据结构课程设计！
马踏棋盘C语言贪心算法.c
04-11
马踏棋盘C语言贪心算法 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
马踏棋盘问题解决-利用深度搜索和贪婪算法优化
jiubugeinifo的专栏
06-19 2260
最近研究算法，看着了一个基础编程题“马踏棋盘”。尝试用java来解决一下，代码有参考 package com.zjt.wuling.depsearch; /** * 关于‘马踏棋盘’问题，利用‘贪婪算法’优化的学习及尝试 * @since 2015年6月18日 上午11:10:23 * @author wuling */ public class HorseGreedyLearn {
马踏棋盘 之 贪心算法
DC_fun
10-02 935
#include #define M 8 int board[M][M]; //棋盘位置。 typedef struct position { int x; int y; int pathnum; }position; void findway(int x, int y); int Pass(int x, int y); int Pathnum(int x, int y); po
贪婪算法 ---马踏棋盘
只有想不到没有做不到，程序的力量。。。
11-19 922
package com.dataconstructor.greedy; /*马踏棋盘问题，用贪婪算法 */ public class HorseStep { //定义参数,x方向 y方向的增量要一致 private static final int [] dx={-1,-2,-2,-1,1,2,2,1};// x方向的增量 private static fi
给定一个n*n的棋盘
最新发布
03-20
### 关于n×n棋盘的算法与数据结构实现 #### 骑士周游问题（马踏棋盘） 骑士周游问题是经典的回溯算法应用之一，目标是在给定大小的棋盘上找到一条路径，使得骑士能够访问每一个格子恰好一次。为了提高效率，可以采用贪心策略优化搜索过程。 通过引入“下一步候选位置的数量最小化”的启发式规则，可以在每一步优先选择那些后续移动可能性较少的位置[^1]。这种做法有助于减少不必要的递归调用次数，从而提升整体性能。 以下是基于上述原理的一个Python版本实现： ```python def knight_tour(n, start_x=0, start_y=0): # 定义八个可能的方向向量 dx = [-2,-1, 1, 2, 2, 1,-1,-2] dy = [ 1, 2, 2, 1,-1,-2,-2,-1] board = [[-1]*n for _ in range(n)] # 初始化棋盘状态(-1表示未被访问过) next_moves_count = [[8]*n for _ in range(n)] def count_next(x,y): # 计算某个坐标处剩余合法步数 cnt = 0 for i in range(8): nx,ny=x+dx[i],y+dy[i] if 0<=nx<n and 0<=ny<n and board[nx][ny]==-1: cnt +=1 return cnt step_num =0 # 当前已走过几步 stack=[(start_x,start_y)] while len(stack)>0 : current_pos =stack[-1] if board[current_pos[0]][current_pos[1]]==-1: # 如果该节点尚未标记，则处理它 board[current_pos[0]][current_pos[1]]=step_num step_num+=1 min_k=-1 # 寻找具有最少未来选项的那个方向k temp_min=float('inf') for k in range(8): new_x,new_y=current_pos[0]+dx[k],current_pos[1]+dy[k] if not (0<=new_x<n and 0<=new_y<n ):continue # 越界跳过 if board[new_x][new_y]!=-1 : continue # 已经访问过的也跳过 num_of_future_options=count_next(new_x,new_y) # 统计这个新坐标的可用邻居数量 if num_of_future_options<temp_min: # 更新最优解条件下的索引以及对应的值 temp_min=num_of_future_options min_k=k if min_k!=-1: # 存在一个合理的选择就压栈继续探索下去 next_position=(current_pos[0]+dx[min_k],current_pos[1]+dy[min_k]) stack.append(next_position) elif len(stack)==n*n: # 所有方块都被成功遍历完成退出循环 break else: # 否则弹出当前顶点重新考虑其他分支情况 last_visited_node=stack.pop() board[last_visited_node[0]][last_visited_node[1]]=-1 step_num-=1 return board if __name__ == "__main__": result = knight_tour(5) for row in result: print(row) ``` 此代码片段展示了如何利用堆栈模拟深度优先搜索的过程来解决骑士巡游问题，并且融入了Waringham提出的Warnsdorff法则作为剪枝手段的一部分。 #### 棋盘路径计数问题 另一个常见的涉及二维网格的问题是从左上方走到右下方的不同路线数目统计。假设只允许向下或者往右两个动作，在不考虑障碍物的情况下可以直接运用动态规划的思想求得最终答案。 下面给出了一段Java语言编写的解决方案示例[^2]: ```java import java.util.*; public class Main{ public static long pathCount(int n,int m){ if(n==1||m==1)return 1; else { return(pathCount(n-1,m)+pathCount(n,m-1)); } } public static void main(String args[]){ Scanner sc=new Scanner(System.in); int N=sc.nextInt(); int M=sc.nextInt(); System.out.print(pathCount(N,M)); } } ``` 尽管这段程序逻辑简单明了，但由于采用了纯递归的方式计算结果，因此当输入规模较大时可能会遇到严重的性能瓶颈甚至导致栈溢出错误发生。对此可以通过记忆化技术加以改进，即预先创建一个数组用于存储中间运算成果以便重复利用，进而有效降低时间复杂度到O(n*m)[^2]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值