马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索

最新推荐文章于 2021-05-23 19:20:51 发布
最新推荐文章于 2021-05-23 19:20:51 发布
阅读量1.3k 收藏 5
点赞数 2
分类专栏： 小程序 文章标签： 马踏棋盘 骑士巡游 贪心算法 动态展示
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42193196/article/details/96720437
版权

  • 马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索

  • （动态展示马的路径）

  • 附带蹩马脚功能，将main函数中 //set_barrier(3, 4); //set_barrier(6,
    注释取消，即可在棋盘3行4列与6行4列的位置增加不可走区域，以此类推

  • 如果有人看，我再写详细一些

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<Windows.h>



#define WIDTH 24
#define VERTICAL 1			//垂直的路
#define HORIZONTAL 0			//水平的路
#define Horse_Tag 7

#define LEFT_2_UP_1 'A'
#define LEFT_1_UP_2 'B'
#define RIGHT_1_UP_2 'C'
#define RIGHT_2_UP_1 'D'
#define RIGHT_2_DOWN_1 'E'
#define	RIGHT_1_DOWN_2 'F'
#define LEFT_1_DOWN_2 'G'
#define LEFT_2_DOWN_1 'H'
#define OVER 'O';

#define WALL 1
typedef struct position {
	int value;				// '0' represents a wall, while '1' represents an accessible position.
	bool isvisited;			//马是否来过这个位置了


}PST;
typedef struct node
{
	int x;
	int y;
}NODE;

typedef struct ar
{
	int num;
	char togo;
}ARRAY;

PST matrix[WIDTH + 2][WIDTH + 2];
NODE path[WIDTH*WIDTH];

int found = 0;						//用于记录找到的路径个数
int count_barrier = 0;				//用于记录设置的障碍个数
void init()

{
	void set_road(int col, int value);
	for (int i = 0; i < WIDTH + 1; i++)
	{
		for (int j = 0; j < WIDTH + 1; j++)
		{

			matrix[i][j].value = 0;
			matrix[i][j].isvisited = false;
		}
	}
	set_road(0, VERTICAL);								//设置地图的边框
	set_road(0, HORIZONTAL);
	set_road(WIDTH + 1, HORIZONTAL);
	set_road(WIDTH + 1, VERTICAL);
}

void set_road(int col, int value)	//col代表将哪一行或者列设置成路(将他们的值++);	 if the value equals 1,it means the road would be set vertically, otherwise horizontally.
{
	if (value == VERTICAL)
	{
		for (int i = 0; i < WIDTH + 1; i++)
		{
			matrix[col][i].value++;
		}
	}
	else
	{
		for (int i = 0; i < WIDTH + 1; i++)
		{
			matrix[i][col].value++;
		}

	}
}


void set_horse_position(int &horse_x, int &horse_y, int x, int y)			//To preset the horse's position at the very begining
{
	matrix[x][y].value = Horse_Tag;
	horse_x = x;
	horse_y = y;

}

void set_barrier(int x, int y)			//设置障碍，别马脚
{
	matrix[x][y].value = 1;
	matrix[x][y].isvisited = true;
	count_barrier++;
}


void gotoxy(unsigned char x, unsigned char y) {
	//COORD是Windows API中定义的一种结构，表示一个字符在控制台屏幕上的坐标
	COORD cor;

	//句柄 
	HANDLE hout;

	//设定我们要定位到的坐标 
	cor.X = 2 * y;
	cor.Y = x;

	//GetStdHandle函数获取一个指向特定标准设备的句柄，包括标准输入，标准输出和标准错误。
	//STD_OUTPUT_HANDLE正是代表标准输出（也就是显示屏）的宏 
	hout = GetStdHandle(STD_OUTPUT_HANDLE);

	//SetConsoleCursorPosition函数用于设置控制台光标的位置
	SetConsoleCursorPosition(hout, cor);
}

void show_path()
{
	system("cls");
	for (int i = 0; i < WIDTH + 2; i++)
	{
		for (int j = 0; j < WIDTH + 2; j++)
		{


			if (matrix[i][j].value != WALL)
				printf("  ", matrix[i][j].value);
			else
				printf("* ");
		}
		printf("\n");
	}
	printf("\n\n开始展示找到的第%d条路径", found);			//地图生成完毕


	for (int i = 0; i < WIDTH*WIDTH; i++)				//将路径动态显示出来
	{
		gotoxy(path[i].x, path[i].y);
		printf("M");
		Sleep(50);
	}

}

int get_next(int x, int y, ARRAY next_step[], int step, int count)			//用于寻找马周围八个方向中接下来一步可走位置最少的一个位置
{
	int k = 0;
	if (x - 1 > 0 && y - 2 > 0 && matrix[x - 1][y - 2].isvisited == false && matrix[x][y - 1].value == 0)				// 左2上1 可以走吗？ 并且检测是否有别马脚
	{
		k++;
		if (count < 1)
		{
			next_step[0].num = get_next(x - 1, y - 2, next_step, step, count + 1);
			next_step[0].togo = LEFT_2_UP_1;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[0].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}
	}
	if (x - 2 > 0 && y - 1 > 0 && matrix[x - 2][y - 1].isvisited == false && matrix[x - 1][y].value == 0)		// 左1上2可走吗？ 并且检测是否有别马脚
	{
		k++;
		if (count < 1)
		{
			next_step[1].num = get_next(x - 2, y - 1, next_step, step, count + 1);
			next_step[1].togo = LEFT_1_UP_2;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[1].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}
	}
	if (x - 2 > 0 && y + 1 <= WIDTH && matrix[x - 2][y + 1].isvisited == false && matrix[x - 1][y].value == 0)		// 右1上2可以走吗
	{
		k++;
		if (count < 1)
		{
			next_step[2].num = get_next(x - 2, y + 1, next_step, step, count + 1);
			next_step[2].togo = RIGHT_1_UP_2;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[2].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}

	}
	if (x - 1 > 0 && y + 2 <= WIDTH && matrix[x - 1][y + 2].isvisited == false && matrix[x][y + 1].value == 0)		// 右2上1可以走吗
	{
		k++;
		if (count < 1)
		{
			next_step[3].num = get_next(x - 1, y + 2, next_step, step, count + 1);
			next_step[3].togo = RIGHT_2_UP_1;
		}
		if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
		{
			next_step[3].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
		}
	}

	if (x + 1 <= WIDTH && y + 2 <= WIDTH && matrix[x + 1][y + 2].isvisited == false && matrix[x][y + 1].value == 0)				// 右2下1可以走吗？ 并且检测是否有别马脚
	{
		k++;
		if (count < 1)
		{
			next_step[4].num = get_next(x + 1, y + 2, next_step, step, count + 1);
			next_step[4].togo = RIGHT_2_DOWN_1;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[4].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}
	}
	if (x + 2 <= WIDTH && y + 1 <= WIDTH && matrix[x + 2][y + 1].isvisited == false && matrix[x + 1][y].value == 0)		// 右1下2可走吗？ 并且检测是否有别马脚
	{
		k++;
		if (count < 1)
		{
			next_step[5].num = get_next(x + 2, y + 1, next_step, step, count + 1);
			next_step[5].togo = RIGHT_1_DOWN_2;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[5].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}
	}
	if (x + 2 <= WIDTH && y - 1 > 0 && matrix[x + 2][y - 1].isvisited == false && matrix[x + 1][y].value == 0)		// 左1下2可以走吗
	{
		k++;
		if (count < 1)
		{
			next_step[6].num = get_next(x + 2, y - 1, next_step, step, count + 1);
			next_step[6].togo = LEFT_1_DOWN_2;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[6].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}

	}
	if (x + 1 <= WIDTH && y - 2 > 0 && matrix[x + 1][y - 2].isvisited == false && matrix[x][y - 1].value == 0)		// 左2下1可以走吗 并且检测是否有别马脚
	{
		k++;
		if (count < 1)
		{
			next_step[7].num = get_next(x + 1, y - 2, next_step, step, count + 1);
			next_step[7].togo = LEFT_2_DOWN_1;
			if (step == WIDTH * WIDTH - 1 - count_barrier)					//如果走到了最后一步，还只剩下最后一个格子的情况
			{
				next_step[7].num = 1;						//将值置为一个正数（不一定要是1），以便于最后一步可执行	。否则最后一步会检测到无路可走
			}
		}
	}
	return k;
}


int Comp(const void *p1, const void *p2)	//用于比较结构体数组的快排
{
	ARRAY *c = (ARRAY*)p1;
	ARRAY *d = (ARRAY*)p2;
	return (c->num - d->num);
}

void DFS_optimized_with_greed(int horse_x, int horse_y, int step)					//贪心算法优化后的深度遍历搜索
{
	printf("我现在在  (%d,%d)  第%d步\n", horse_x, horse_y, step);
	path[step - 1].x = horse_x;		//将走过的点存入路径数组中，因为step从1开始计数，所以路径数组要从step-1开始计数
	path[step - 1].y = horse_y;
	matrix[horse_x][horse_y].isvisited = true;
	if (step == WIDTH * WIDTH - count_barrier)		//如果马将棋盘走满了
	{
		found++;
		printf("找到了一个诶！");
		show_path();
	}
	ARRAY next_step[8];				//用于记录8个方向的位置
	if (get_next(horse_x, horse_y, next_step, step, 0) == 0)
	{

	}
	else
	{
		qsort(next_step, 8, sizeof(next_step[0]), Comp);			//对结构体数组进行排序
		for (int i = 0; i < 8; i++)
		{
			if (next_step[i].num != 0)
			{
				switch (next_step[i].togo)
				{
				case LEFT_2_UP_1: DFS_optimized_with_greed(horse_x - 1, horse_y - 2, step + 1); break;
				case LEFT_1_UP_2: DFS_optimized_with_greed(horse_x - 2, horse_y - 1, step + 1); break;
				case RIGHT_1_UP_2:DFS_optimized_with_greed(horse_x - 2, horse_y + 1, step + 1); break;
				case RIGHT_2_UP_1:DFS_optimized_with_greed(horse_x - 1, horse_y + 2, step + 1); break;
				case RIGHT_2_DOWN_1:DFS_optimized_with_greed(horse_x + 1, horse_y + 2, step + 1); break;
				case RIGHT_1_DOWN_2:DFS_optimized_with_greed(horse_x + 2, horse_y + 1, step + 1); break;
				case LEFT_1_DOWN_2: DFS_optimized_with_greed(horse_x + 2, horse_y - 1, step + 1);  break;
				case LEFT_2_DOWN_1: DFS_optimized_with_greed(horse_x + 1, horse_y - 2, step + 1); break;
				default:break;
				}

			}
		}


	}
	matrix[horse_x][horse_y].isvisited = false;

}

int main()
{
	int horse_x, horse_y;			//horse's x and y
	int count = 0;			//to count the dog's total steps

	bool set_bool = false;
	srand((int)time(0));
	init();
	set_horse_position(horse_x, horse_y, WIDTH / 2, WIDTH / 2);

	//set_barrier(3, 4);
	//set_barrier(6, 4);

	DFS_optimized_with_greed(horse_x, horse_y, 1);

	system("pause");

	return 0;


}
Fivethousand5000
关注
专栏目录
贪心算法 --- 马踏棋盘（C）
Jensen
11-30 4406
五大常用算法之一，好高大上的东西，决定了把这五大算法给搞了，第一个贪心算法，百度一下它的概念，贴过了来了： 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。 贪婪算法是一种改进
c语言数据结构之马踏棋盘
qq_55918164的博客
07-12 1251
c语言数据结构之马踏棋盘
马踏棋盘C语言贪心算法.c
04-11
马踏棋盘C语言贪心算法 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
马踏棋盘C语言的完整算法
01-17
马踏棋盘C语言的完整算法 vs2013下编译运行通过
马踏棋盘_深度优先搜索_JavaScript
m0_46193048的博客
05-31 330
一个5X5的棋盘， “马”从左上角出发，按“日”字跳马， 要求不重复地跳经所有位置， 求出符合规则的所有方案。 //起步 var step0 = 0; //起始坐标 var x0 = 0; var y0 = 0; //棋盘大小 var xLen = 5; var yLen = 5; //邻位向量 var Sides = [[1,2],[2,1],[-1,2],[-2,1],[1,-2],[2,-1],[-1,-2],[-2,-1]]; //空棋盘 var map0 = MapCreat(xLen, yLen
马踏棋盘问题的优化
weixin_44824650的博客
10-13 464
数据结构——马踏棋盘题解（贪心算法） 马踏棋盘问题是一个很经典的问题 一般的解决方法就是dfs,但是由于每次踏的方向不同，和初始值的不同，可能会增加这个问题的复杂的，所以在这里我们采用一些贪心算法，加权值进行优化 使用循环建立棋盘与权值棋盘（权值为该位置可走的位置数量） 将当前步数写入棋盘数组中 开始探测下一步该走的位置， 分别测试八个方向 对可走位置进行查询权值，将权值最少的作为下一步的位置（每...
C语言实现马踏棋盘
04-12
使用C语言实现的马踏棋盘，利用的贪心算法，效率大大提升
使用深度优先搜素（DFS）实现马踏棋盘
wslxc00的博客
07-01 310
感觉想学会DFS说到底最重要的也就是弄懂递归怎么用 #include<stdio.h> #define X 8 #define Y 8 int chess[X][Y] = { 0 };//棋盘 bool nextxy(int* x, int* y, int count) {//x，y使用指针类型是为了直接修改 switch (count) { case 0: if (*x + 2 <= X - 1 && *y - 1 >= 0 && ches
贪心算法马踏棋盘c语言,马踏棋盘：一个贪心算法实例
weixin_39649736的博客
05-23 436
问题描述：在8×8方格(国际象棋)的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径问题分析：首先这是一个搜索问题，运用深度优先搜索进行求解是完全可行的，它输入的是全部解，但是马遍历当8×8时解是非常之多的，用天文数字形容也不为过，这样一来求解的过程就非常慢，并且出一个解也非常慢。怎么才能快速地得到部分解呢？其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C....
马踏棋盘C语言算法
07-29
马踏棋盘C语言算法，经过多次测试，代码运行良好。
马踏棋盘算法（c++）
12-12
贪心算法，回溯法，哈密尔顿路径，马踏棋盘算法练习，
贪心算法求解马踏棋盘
01-03
利用贪心算法求解马踏棋盘，数据结构课程设计！
c语言马踏棋盘编程分析,马踏棋盘的递归算法（c语言）
weixin_33966205的博客
05-18 331
#include#include#includeintm,n;//棋盘大小intc[100][100];intdy[]={2,1,-1,-2,-2,-1,1,2};intdx[]={1,2,2,1,-1,-2,-2,-1};intjudge(intx,inty)//判断是否在棋盘上{if(x>0&&x<=m&&y>0&&amp...
c语言马踏棋盘编程分析,数据结构——马踏棋盘题解（贪心算法）（C语言）
weixin_39668571的博客
05-18 307
//马踏棋盘---贪心题解#include#include#define OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define M 8#define N 8int direction[2][9]={{0,-2,-1,1,2,2,1,-1,-2},{0,1,2,2,1,-1,-2,-2,-1}}; //增量...
马踏棋盘－－－c语言
u010547141的博客
11-05 1237
问题描述： 国际象棋的棋盘为8x8的方格棋盘。现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘的64个方格。 编写一个c程序，实现马踏棋盘操作，要求1～64这64个数字标注马移动的路径，也就是按照求出的行走路线，将数字1，2，3，......，64依次填入棋盘的方格中，并输出。 问题分析： 国际象棋中，“马”的移动...
马踏棋盘问题（c语言实现）
m0_47773954的博客
05-22 778
#include <stdio.h> #include <time.h> #define X 8 #define Y 8 int chess[X][Y]; // 找到基于(x,y)位置的下一个可走的位置 int nextxy(int* x, int* y, int count) { switch (count) { case 0: if (*x + 2 <= X - 1 && *y - 1 >= 0 && chess[*x
数据结构与算法｜马踏棋盘算法（小甲鱼）C语言代码的算法分析
峰峰的博客
03-03 3215
马踏棋盘算法（骑士周游问题）的算法分析 C语言代码部分来自小甲鱼的《数据结构与算法》 题目要求： ​ 国际象棋的棋盘为8*8的方格棋盘，现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘64个方格。 马踏棋盘的一个解： 对于在n*n的棋盘上，当n>=5且为偶数的时候，以任意点作点都有解。 回溯法：一条路走到黑，碰壁了...
马踏棋盘c语言链表算法,马踏棋盘问题的贪心算法实现
weixin_28362173的博客
05-23 380
马踏棋盘就是贪心算法的一个很好的应用。先描述下：在国际象棋的8×8棋盘上，随机把马放在一个格子中，马按日字行走进行移动(同中国象棋，无蹩腿，即直走一格再斜走一格)，要求每个方格只踏入一次，走遍棋盘上全部64个方格。下面是我根据前述算法思想用VC实现程序，执行速度没统计，完全小于人的反应时间，先贴运行结果，先看下程序思路的来源：早在1823年，J.C.Warnsdorff就提出了一个有名的算法。在每...
C语言经典算法大全：从河内塔到约瑟夫问题
骑士走棋盘是一个经典的搜索算法问题，旨在找到骑士在棋盘上的一条路径。该算法可以使用深度优先搜索算法来实现，时间复杂度为O(n)。 7. 八皇后（Eight Queens） 八皇后是一个经典的回溯算法问题，旨在找到八个皇后...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值