数据结构实验五-马踏棋盘

最新推荐文章于 2023-08-10 15:53:36 发布
最新推荐文章于 2023-08-10 15:53:36 发布
阅读量1k 收藏 5
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/txygoodluck/article/details/109687357
版权

简介：
实验目的：
1、了解图的应用
2、加深对图结构及算法的理解
3、培养解决实际问题的编程能力
实验内容：
国际象棋马的走法：先直走或横走一格，再沿离开原来格子的方向斜走二格，合起来为一步棋；国际象棋棋盘黑白交错，格数8×8。
在这里插入图片描述
基本要求：
给出马从任意一个位置出发遍历整个棋盘的一条路径。
在1)的基础上给出从该位置出发的所有遍历路径

马踏棋盘

任务一：
问题建模-将马踏棋盘问题用无向图建模，输出图的邻接表表示

任务描述：
本关任务：将棋盘转换成图的邻接表表示模型，并输出邻接表。

相关知识：
为了完成本关任务，你需要掌握：
1.问题建模
2.如何输出邻接表

- 问题建模

整个棋盘可表示为一个N×N的二维数组。假若马目前在位置（i,j）则马下一步可移动的位置最多有八个(如上图所示八个小黑点)。这八个位置（用0、1、……、7来标示）与当前位置在x,y方向上有固定位移差。0~7号位置(x,y)可以表示为：
(i-2,j+1),(i-1,j+2),(i+1,j+2),(i+2,j+1),
(i+2,j-1),(i+1,j-2),(i-1,j-2),(i-2,j-1)。
当然，这些位置一定在棋盘边界以内，即位置坐标（x,y)必须满足：
0<=x<=N-1 &&0<=y<=N-1

如何定义邻接关系？
马当前所在格子（i，j）,马的下一步最多有八个格子可以到达。我们就认为当前格子和下一步能够到达的格子是“可达的”，这种“可达性”具有对称性。如果把格子看作一个顶点的话，那一个格子最多有8个格子可达，下一步马能到达的格子就是当前格子的邻接点。一个 N * N 棋盘可以转换成一个具有 N * N 个顶点的无向图。
为了方便，格子除了具有坐标属性（以格子左下角坐标表示），我们还可以给每个格子增加一个序号属性。
以5*5棋盘为例，假定我们按照以下方式对棋盘上的格子进行编号，那么编号与格子所在的坐标位置必然存在一定关系。

(0,4) , 20(1,4) , 21(2,4) , 22(3,4) , 23(4,4) , 24
(0,3) , 15(1,3) ,16(2,3) , 17(3,3) , 18(4,3) , 19
(0,2) ,10(1,2) , 11(2,2) , 12(3,2) , 13(4,2) , 14
(0,1) , 5(1,1) , 6(2,1) , 7(3,1) , 8(4,1) , 9
(0,0) , 0(1,0) , 1(2,0) , 2(3,0) , 3(4,0) , 4

对于每一个顶点（格子），它的邻接点都可以计算出来。
举例：以上图中6号格子为例
6号格子坐标（1,1）
根据偏移量，计算它的下一步的8个位置的坐标：
0~7号位置分别为:
（-1,2）（0,3）（2,3）（3,2）
（3,0）（2,-1） (0,-1) (-1,0)
其中：第1、5、6、7个位置越界，舍掉
因此6号格子（顶点）有4个邻接点。
既然我们能计算出每个顶点的邻接点，那我们就很容易生成图的邻接表了。
表头结点结构：
x y k link
边结点结构：
k next

其中
k:表头结点或边结点的序号
x:表头头结点所在的横坐标；
y:表头结点所在的纵坐标；
link:表头结点中指向边结点所在链表的表头结点。
next:边结点中指向后继的指针

- 邻接表的生成

在这里插入图片描述

- 编程要求

以N=8为例：根据提示，在右侧编辑器写出完整代码，实现邻接表的输出。

测试说明：
测试输入：无
（在程序中#define N 8）
测试输出：
(0,0),0->17 10
(1,0),1->18 16 11
(2,0),2->19 17 8 12
(3,0),3->20 18 9 13
(4,0),4->21 19 10 14
(5,0),5->22 20 11 15
(6,0),6->23 21 12
(7,0),7->22 13
(0,1),8->25 2 18
(1,1),9->26 24 3 19
(2,1),10->27 25 16 0 4 20
(3,1),11->28 26 17 1 5 21
(4,1),12->29 27 18 2 6 22
(5,1),13->30 28 19 3 7 23
(6,1),14->31 29 20 4
(7,1),15->30 21 5
(0,2),16->33 1 10 26
(1,2),17->34 32 0 2 11 27
(2,2),18->35 33 24 8 1 3 12 28
(3,2),19->36 34 25 9 2 4 13 29
(4,2),20->37 35 26 10 3 5 14 30
(5,2),21->38 36 27 11 4 6 15 31
(6,2),22->39 37 28 12 5 7
(7,2),23->38 29 13 6
(0,3),24->41 9 18 34
(1,3),25->42 40 8 10 19 35
(2,3),26->43 41 32 16 9 11 20 36
(3,3),27->44 42 33 17 10 12 21 37
(4,3),28->45 43 34 18 11 13 22 38
(5,3),29->46 44 35 19 12 14 23 39
(6,3),30->47 45 36 20 13 15
(7,3),31->46 37 21 14
(0,4),32->49 17 26 42
(1,4),33->50 48 16 18 27 43
(2,4),34->51 49 40 24 17 19 28 44
(3,4),35->52 50 41 25 18 20 29 45
(4,4),36->53 51 42 26 19 21 30 46
(5,4),37->54 52 43 27 20 22 31 47
(6,4),38->55 53 44 28 21 23
(7,4),39->54 45 29 22
(0,5),40->57 25 34 50
(1,5),41->58 56 24 26 35 51
(2,5),42->59 57 48 32 25 27 36 52
(3,5),43->60 58 49 33 26 28 37 53
(4,5),44->61 59 50 34 27 29 38 54
(5,5),45->62 60 51 35 28 30 39 55
(6,5),46->63 61 52 36 29 31
(7,5),47->62 53 37 30
(0,6),48->33 42 58
(1,6),49->32 34 43 59
(2,6),50->56 40 33 35 44 60
(3,6),51->57 41 34 36 45 61
(4,6),52->58 42 35 37 46 62
(5,6),53->59 43 36 38 47 63
(6,6),54->60 44 37 39
(7,6),55->61 45 38
(0,7),56->41 50
(1,7),57->40 42 51
(2,7),58->48 41 43 52
(3,7),59->49 42 44 53
(4,7),60->50 43 45 54
(5,7),61->51 44 46 55
(6,7),62->52 45 47
(7,7),63->53 46

  • 示例代码如下：（温馨提示：本文全部代码只在 EduCoder 平台上通过测试，仅供参考，如有运行错误请自行改正）
#include<stdio.h>
#include<stdlib.h>
#define N 8
typedef struct node
{
	int k;
	struct node *next;
}edgenode;
typedef struct
{
	int x,y;
	int k;
	edgenode *link;
}vexnode;
vexnode ga[N*N];

int PX[8]={2,2,1,-1,-2,-2,-1,1};
int PY[8]={1,-1,-2,-2,-1,1,2,2};

void creatadjlist(vexnode ga[])  //创建邻接表
{
	int i,j,k;
	int xx,yy,newx,newy,newk;
	edgenode *s;
	edgenode *p;
	for(j=0;j<N;j++)
	for(i=0;i<N;i++)
	{
		k=N*j+i;
		ga[k].x=i;
		ga[k].y=j;
		ga[k].k=k;
		ga[k].link=NULL;
	}
	for(i=0;i<N*N;i++)
	{
		xx=ga[i].x;
		yy=ga[i].y;
		for(j=0;j<8;j++)
		{
			newx=xx+PX[j];
			newy=yy+PY[j];
			if(newx>=0 && newx<N  &&  newy>=0 && newy<N)   //头插法
			{
				newk=N*newy+newx;
				s=(edgenode *)malloc(sizeof(edgenode));
				s->k=newk;
				s->next=ga[i].link;
				ga[i].link=s;
			}
		}
	}


    for(i=0;i<N*N;i++)
	{
	printf("(%d,%d),%d->",ga[i].x,ga[i].y,ga[i].k);
	p=ga[i].link;
	while(p)
	{
		printf("%d ",p->k);
		p=p->next;
		
	}
	printf("\n");
    }

}


int main()
{
	creatadjlist(ga);
	return 0;
}

任务二：
遍历算法的实现

任务描述：
给出马从任意一个位置出发遍历整个棋盘的一条路径。

  • 示例代码如下：（温馨提示：本文全部代码只在 EduCoder 平台上通过测试，仅供参考，如有运行错误请自行改正）
#include<stdio.h>
#include<stdlib.h>
#define N 6
typedef struct node
{
	int k;
	struct node *next;
}edgenode;
typedef struct
{
	int x,y;
	int k;
	edgenode *link;
}vexnode;

typedef struct
{
    edgenode *data[MAXSIZE];
    int top;
}stack s;
stack s;

void push(stack *s,edgenode *x)
{if (s->top == MAXSIZE-1)
printf("overflow!");
s->top++;
s->data[s->top]=x;
}

edgenode* pop(stack *s)
{
    if(s->top==-1)
    {
        printf("overflow!"); return NULL;
    }
    return s->data[s->top--];
}
void output(stack *s)
{
    int i;
    for(i=0;i<=s->top;i++)
    printf("%d ",s->data[i]->k);
}
vexnode ga[N*N];
int visited[N*N]={0};
int path[N*N]={-1};
int PX[8]={2,2,1,-1,-2,-2,-1,1};
int PY[8]={1,-1,-2,-2,-1,1,2,2};

void creatadjlist(vexnode ga[])
{
    int i,j,k;
    int xx,yy,newx,newy,newk;
    edgenode *s;
    edgenode *p;
    for (j=0;j<N;j++)
    for (i=0;i<N;i++)
    {
        k=N*j+i;
        ga[k].x=i;
        ga[k].y=j;
        ga[k].k=k;
        ga[k].link=NULL;
    }
    for (i=0;i<N*N;i++)
    {
        xx=ga[i].x;
        yy=ga[i].y;
        for(j=0;j<8;j++)
        {
            newx=xx+PX[j];
            newy=yy+PY[j];
            if(newx>=0 && newx<N && newy>=0 && newy<N)
            {
                newk=N*newy+newx;
                s=(edgenode *)malloc(sizeof (edgenode));
                s->k=newk;
                s->next=ga[i].link;
                ga[i].link=s;
            }
        }
    }
}
for (i=0;i<N*N;i++)
{
    printf("(%d,%d),%d->",ga[i].x,ga[i].y,ga[i].k);
    p=ga[i].link;
    while(p)
    {
        printf("%d ",p->k);
        p=p->next;
    }
    printf("\n");
    }  
}
void path_list()
{
    int i;
    for (i=0;i<N*N;i++)
    printf("(%d,%d)" ,i,path[i]);
}
dfs(int i)
{
    edgenode *p;
    p=ga[i].link;
    visited[i]=1;
while(s.top!=-1||p)
{
    while(p)
    {
        if (!visited[p->k])
        {visited[p->k]=1; push(&s,p);
        p=ga[p->k].link;
        }
        else p=p->next;
    }
    if(s.top==N*N-2)
    {
        printf("succeed!");
        printf("起点是0,依次经过的顶点序列：\n");
        output(&s);return 1;
    }
    if(s.top!=-1)
    {
        p=pop(&s);visited[p->k]=0;
        p=p->next;
    }
}
return 0;
}

int main()
{
    s.top=-1;
    creatadjlist(ga);
    dfs(0);
    printf("---------------------");
    return 0;
}

我把我目前写的关于数据结构 题目 的链接全部汇总整理在下面，有需要的小伙伴自己点击哈。

实验：

最近在学习最优化、运筹学和计量经济学的相关知识，实验课马上就要开了，不知道大家有没有兴趣。如果后期有时间，学习结束后，我可以整理一下上实验课的实验报告和题目，一起学习交流~

TXYGoodluck
关注
专栏目录
数据结构马踏棋盘JAVA实验源码
06-18
《数据结构马踏棋盘JAVA实验源码》的解析与探讨 在计算机科学领域，数据结构是编程的基础，它涉及到如何高效地存储和处理数据。本实验“马踏棋盘”是一个基于Java语言的数据结构应用实例，旨在通过动态演示帮助学习...
马踏棋盘（回溯算法）
xiao-ren-wu的博客
10-05 2288
马可以走的位置如图： 要求： 找到所有马从任意一个位置出发遍历整个棋盘的一条路径 算法实现：#include<stdlib.h> #include<stdio.h> int chessboard[12][12];//定义棋盘， //马走的方向 int move[8][2] = { { 2, 1 }, { 1, 2 }, { -1, 2 }, { -2, 1 }, { -2, -1 }, { -1
数据结构___马踏棋盘详尽实现+报告+通俗易懂注释
菱形继承
10-17 7218
数据结构实验报告 实验课题马踏棋盘 实验时间2019.10.01 学 院信息学院 专 业计算机科学系 学 号...
算法与数据结构学习（59）-程序员常用10种算法（马踏棋盘算法）
九岁ya的博客
04-20 843
马踏棋盘算法介绍 马踏棋盘算法也被称为骑士周游问题 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格 骑士周游（马踏棋盘）问题的解决步骤和思路 创建棋盘 chessBoard , 是一个二维数组 将当前位置设置为已经访问，然后根据当前位置，计算马儿还能走哪些位置，并放入到一个集合中(A...
数据结构课程设计---马踏棋盘（C++）
qq_56725624的博客
06-20 6756
马踏棋盘：设计一个国际象棋的马踏遍棋盘的演示程序。将马随机放在国际象棋 8x8 棋盘 Board[8][8]的某个方格中，马按走棋规则进行移动。要求每个方格只进入一次，走遍棋盘上全部 64 个方格。编制递归或非递归程序，求出马的行走路线，并按求出的行走路线输出。结果中输出：在方阵中输出 1-64 个行走足迹。 ...
马踏棋盘-数据结构 详细教程
A_Renaissance的博客
12-26 7205
国际象棋的棋盘为8×8的方格棋盘。现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘的64个方格。 编写一个C程序，实现马踏棋盘操作，要求用1〜64这64个数字标注马移动的路径，也就是按照求出的行走路线，将数字1，2，……64依次填入棋盘的方格中，并输出。
数据结构课程设计 马踏棋盘
06-02
将马随机放在国际象棋的8×8棋盘的某个方格中，马按照走棋的规则进行移动。每个方格只进入一次，走遍棋盘的全部64个方格。编写算法，求出马的行走路线，并按求出的行走路线，将1,2,…,64依次填入一个8×8的方阵，并...
数据结构课程设计—骑士漫游（马踏棋盘）
10-25
编写一个程序来获得马踏棋盘即骑士漫游问题的一个解。 您的程序需要达到下面的要求： 棋盘的规模是8*8； 对于任意给定的初始化位置进行试验，得到漫游问题的解； 对每次实验，按照棋盘矩阵的方式，打印每个格被行径...
马踏棋盘——一个数据结构综合实验案例新解.pdf
08-07
在数据结构实验教学中，将马踏棋盘问题作为一个综合设计案例，有助于学生将理论知识与实际问题结合，提升学生的逻辑思维、问题分析以及问题解决能力。这一案例具有以下几个特点： 1. 创新性：传统的马踏棋盘问题...
数据结构马踏棋盘.doc
07-11
本文档介绍的是一个基于数据结构的编程实验，名为“马踏棋盘”，主要涉及栈和队列的应用。实验目标是设计一个程序，模拟国际象棋中马的移动，使其能按照规则走遍8x8棋盘的每个格子且每个格子仅访问一次。下面将详细...
马踏棋盘 数据结构
06-26
这里有你想要的资源，马踏棋盘，完整代码！
马踏棋盘java程序设计报告6,数据结构课程设计 马踏棋盘
weixin_36249618的博客
03-12 616
《数据结构课程设计 马踏棋盘》由会员分享，可在线阅读，更多相关《数据结构课程设计 马踏棋盘(27页珍藏版)》请在人人文库网上搜索。1、前言学习数据结构的最终目的是解决实际的应用问题，特别是非数值计算类型的应用问题，数据结构课程设计就是为此目的一次实际训练。要求我们在对题目进行独立分析的基础上，完成设计和开发，并最终接受严格的测试考核。以深化对数据结构课程中基本概念、理论和方法的理解，提升综合运用所...
常用十大算法（十）— 踏棋盘算法
归子莫的博客
09-09 873
常用十大算法（十）— 踏棋盘算法 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 介绍 马踏棋盘算法也被称为骑士周游问题 将马随机放在国际象棋的8×8棋盘Board0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格 思路 马踏棋盘问题(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用。 如果使用回溯（就是深度优先搜索）来解决，假如马儿踏了53个点，如图：走到了第5
马踏棋盘（构思）
Silent_Lamb的专栏
11-08 1940
这学期数据结构有这么一题，我感觉蛮有意思，就做了下。下面分享一下我的收获。  以下是我编程前做的工作： 1.弄清题目的意思 2.提出问题（做的过程中可能遇到的问题） 3.构思解决这些问题的大致方法（与编程语言（工具）联系起来），并考虑如何将这些方法在程序流程中联系起来 4.设计出程序流程图 5.优化解决方法、程序流程 6.开始编程         在编程过程中经常会冒出
数据结构和算法:程序员常用的10种算法之马踏棋盘算法
最新发布
weixin_43597208的博客
08-10 334
1)马踏棋盘算法也被称为骑士周游问题2）将马随机放在国际象棋的8X8 棋盘Board[0-7][0-7]的某个方格中，马按走棋规则（马走日字）进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格；
数据结构---马踏棋盘
minug的专栏
12-03 1549
最近学数据结构，基于贪心算法写了个马踏棋盘。。。 // //  main.cpp //  马踏棋盘 // //  Created by minug on 14/10/30. // #include using namespace std; int popnumber = 0; int Htry1[8]
马踏棋盘问题(C-数据结构)
m0_61122217的博客
10-04 1236
【代码】马踏棋盘问题(C-数据结构)
数据结构——马踏棋盘题解（贪心算法）（C语言）
热门推荐
一个巨大的博客
10-15 1万+
数据结构——马踏棋盘题解（贪心算法） 使用循环建立棋盘与权值棋盘 将当前步数写入棋盘数组中 开始探测下一步该走的位置， 分别测试八个方向 对可走位置进行查询权值，将权值最少的作为下一步的位置（每次都将步数最少的可走位置作为下一步的位置即贪心的体现） 循环2~4。 //马踏棋盘---贪心题解 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt;
数据结构与算法——马踏棋盘（c++栈实现）
qq_51228515的博客
03-20 3179
马踏棋盘问题是旅行商（TSP）或哈密顿问题（HCP）的一个特例。在国际棋盘棋盘上，用一个马按照马步跳遍整个棋盘，要求每个格子都只跳到一次，最后回到出发点。这是一个 NP问题，通常采用回溯法或启发式搜索类算法求解。 在此采用栈进行回溯法求解 #include <iostream> #include<stdlib.h> #include <stdio.h> #include <iomanip> using namespace std; const int .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值