社区
数据结构与算法
帖子详情
马踏棋盘--C语言算法(小弟请教高手)100分!
swf0304
2002-07-07 01:34:46
我最近在做课程设计,题目是用C语言编一个马踏棋盘的非递归程序,必须用栈。要求将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动,要求每个方格只进一次,走遍棋盘上64格,求出马的行走路线,并按马的行走路线将1到64依次填入一个8*8的方阵,输出之。已经过去一个多礼拜了还是没有做出来,有的地方根本不知怎么做,感觉特别难。希望各位高手能帮帮小弟的忙!
...全文
229
22
打赏
收藏
马踏棋盘--C语言算法(小弟请教高手)100分!
我最近在做课程设计,题目是用C语言编一个马踏棋盘的非递归程序,必须用栈。要求将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动,要求每个方格只进一次,走遍棋盘上64格,求出马的行走路线,并按马的行走路线将1到64依次填入一个8*8的方阵,输出之。已经过去一个多礼拜了还是没有做出来,有的地方根本不知怎么做,感觉特别难。希望各位高手能帮帮小弟的忙!
复制链接
扫一扫
分享
转发到动态
举报
AI
作业
写回复
配置赞助广告
用AI写文章
22 条
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
swf0304
2002-07-12
打赏
举报
回复
谁能帮我改改这个算法?
#include <stdio.h>
#include <malloc.h>
#define N 8
#define MAX N * N
typedef struct tagSTACK
{
int i, j;
struct tagSTACK * next;
}STACK;//用来回溯的栈数组的元素结构,i、j为当前这一步,而将下一步的可能走法链接在后面
void print(STACK stk[], int top)
{
int i;
for (i = 0; i < top; i++)
printf ("第%2d步, 走到(i = %d, j = %d)\n", i + 1,
stk[i].i, stk[i].j);
}
void setStk(STACK stk[], int top, int i, int j)
{//将当前所在位置的下一步链接到栈中
STACK * p = (STACK *) malloc (sizeof (STACK));
p->i = i;
p->j = j;
p->next = stk[top].next;
stk[top].next = p;
}
int running(int pace[][N], int i, int j)
{
int top = 0;
STACK stk[MAX], * p;
while (top < N * N - 1)
{
stk[top].i = i;
stk[top].j = j;
stk[top].next = NULL;
if (i + 2 < N && j + 1 < N && !pace[i + 2][j + 1])
setStk (stk, top, i + 2, j + 1);
if (i + 1 < N && j + 2 < N && !pace[i + 1][j + 2])
setStk (stk, top, i + 1, j + 2);
if (i - 1 >= 0 && j + 2 < N && !pace[i - 1][j + 2])
setStk (stk, top, i - 1, j + 2);
if (i - 2 >= 0 && j + 1 < N && !pace[i - 2][j + 1])
setStk (stk, top, i - 2, j + 1);
if (i - 2 >= 0 && j - 1 >= 0 && !pace[i - 2][j - 1])
setStk (stk, top, i - 2, j - 1);
if (i - 1 >= 0 && j - 2 >= 0 && !pace[i - 1][j - 2])
setStk (stk, top, i - 1, j - 2);
if (i + 1 < N && j - 2 >= 0 && !pace[i + 1][j - 2])
setStk (stk, top, i + 1, j - 2);
if (i + 2 < N && j - 1 >= 0 && !pace[i + 2][j - 1])
setStk (stk, top, i + 2, j - 1);
if (stk[top].next == NULL)//从这一步走不下去了,需要回溯
{
do
{
pace[stk[top].i][stk[top].j] = 0;//还原状态
--top;
}while (top >= 0 && stk[top].next == NULL);
if (top < 0) return 0;
}
else
pace[i][j] = 1;
p = stk[top].next;
i = p->i;
j = p->j;
stk[top].next = p->next;//把下面要走的这一步从上一步的链表中删除
free (p);
top++;
}
print (stk, top);
return 1;
}
void main()
{
int pace[N][N], i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
pace[i][j] = 0;//初始化状态
INPUT:
printf("请指定从哪一格开始(i,j):");
scanf ("%d,%d", &i, &j);
if (i >= N || j >= N) goto INPUT;
if(!running (pace, i, j))
printf ("从您指定的这一格无法不重复地走遍整个棋盘\n");
}
swf0304
2002-07-12
打赏
举报
回复
谁能帮我改改这个程序?
#include <stdio.h>
#include <malloc.h>
#define N 8
#define MAX N * N
typedef struct tagSTACK
{
int i, j;
struct tagSTACK * next;
}STACK;//用来回溯的栈数组的元素结构,i、j为当前这一步,而将下一步的可能走法链接在后面
void print(STACK stk[], int top)
{
int i;
for (i = 0; i < top; i++)
printf ("第%2d步, 走到(i = %d, j = %d)\n", i + 1,
stk[i].i, stk[i].j);
}
void setStk(STACK stk[], int top, int i, int j)
{//将当前所在位置的下一步链接到栈中
STACK * p = (STACK *) malloc (sizeof (STACK));
p->i = i;
p->j = j;
p->next = stk[top].next;
stk[top].next = p;
}
int running(int pace[][N], int i, int j)
{
int top = 0;
STACK stk[MAX], * p;
while (top < N * N - 1)
{
stk[top].i = i;
stk[top].j = j;
stk[top].next = NULL;
if (i + 2 < N && j + 1 < N && !pace[i + 2][j + 1])
setStk (stk, top, i + 2, j + 1);
if (i + 1 < N && j + 2 < N && !pace[i + 1][j + 2])
setStk (stk, top, i + 1, j + 2);
if (i - 1 >= 0 && j + 2 < N && !pace[i - 1][j + 2])
setStk (stk, top, i - 1, j + 2);
if (i - 2 >= 0 && j + 1 < N && !pace[i - 2][j + 1])
setStk (stk, top, i - 2, j + 1);
if (i - 2 >= 0 && j - 1 >= 0 && !pace[i - 2][j - 1])
setStk (stk, top, i - 2, j - 1);
if (i - 1 >= 0 && j - 2 >= 0 && !pace[i - 1][j - 2])
setStk (stk, top, i - 1, j - 2);
if (i + 1 < N && j - 2 >= 0 && !pace[i + 1][j - 2])
setStk (stk, top, i + 1, j - 2);
if (i + 2 < N && j - 1 >= 0 && !pace[i + 2][j - 1])
setStk (stk, top, i + 2, j - 1);
if (stk[top].next == NULL)//从这一步走不下去了,需要回溯
{
do
{
pace[stk[top].i][stk[top].j] = 0;//还原状态
--top;
}while (top >= 0 && stk[top].next == NULL);
if (top < 0) return 0;
}
else
pace[i][j] = 1;
p = stk[top].next;
i = p->i;
j = p->j;
stk[top].next = p->next;//把下面要走的这一步从上一步的链表中删除
free (p);
top++;
}
print (stk, top);
return 1;
}
void main()
{
int pace[N][N], i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
pace[i][j] = 0;//初始化状态
INPUT:
printf("请指定从哪一格开始(i,j):");
scanf ("%d,%d", &i, &j);
if (i >= N || j >= N) goto INPUT;
if(!running (pace, i, j))
printf ("从您指定的这一格无法不重复地走遍整个棋盘\n");
}
swf0304
2002-07-12
打赏
举报
回复
谁能帮我改改这个程序!
#include <stdio.h>
#include <malloc.h>
#define N 8
#define MAX N * N
typedef struct tagSTACK
{
int i, j;
struct tagSTACK * next;
}STACK;//用来回溯的栈数组的元素结构,i、j为当前这一步,而将下一步的可能走法链接在后面
void print(STACK stk[], int top)
{
int i;
for (i = 0; i < top; i++)
printf ("第%2d步, 走到(i = %d, j = %d)\n", i + 1,
stk[i].i, stk[i].j);
}
void setStk(STACK stk[], int top, int i, int j)
{//将当前所在位置的下一步链接到栈中
STACK * p = (STACK *) malloc (sizeof (STACK));
p->i = i;
p->j = j;
p->next = stk[top].next;
stk[top].next = p;
}
int running(int pace[][N], int i, int j)
{
int top = 0;
STACK stk[MAX], * p;
while (top < N * N - 1)
{
stk[top].i = i;
stk[top].j = j;
stk[top].next = NULL;
if (i + 2 < N && j + 1 < N && !pace[i + 2][j + 1])
setStk (stk, top, i + 2, j + 1);
if (i + 1 < N && j + 2 < N && !pace[i + 1][j + 2])
setStk (stk, top, i + 1, j + 2);
if (i - 1 >= 0 && j + 2 < N && !pace[i - 1][j + 2])
setStk (stk, top, i - 1, j + 2);
if (i - 2 >= 0 && j + 1 < N && !pace[i - 2][j + 1])
setStk (stk, top, i - 2, j + 1);
if (i - 2 >= 0 && j - 1 >= 0 && !pace[i - 2][j - 1])
setStk (stk, top, i - 2, j - 1);
if (i - 1 >= 0 && j - 2 >= 0 && !pace[i - 1][j - 2])
setStk (stk, top, i - 1, j - 2);
if (i + 1 < N && j - 2 >= 0 && !pace[i + 1][j - 2])
setStk (stk, top, i + 1, j - 2);
if (i + 2 < N && j - 1 >= 0 && !pace[i + 2][j - 1])
setStk (stk, top, i + 2, j - 1);
if (stk[top].next == NULL)//从这一步走不下去了,需要回溯
{
do
{
pace[stk[top].i][stk[top].j] = 0;//还原状态
--top;
}while (top >= 0 && stk[top].next == NULL);
if (top < 0) return 0;
}
else
pace[i][j] = 1;
p = stk[top].next;
i = p->i;
j = p->j;
stk[top].next = p->next;//把下面要走的这一步从上一步的链表中删除
free (p);
top++;
}
print (stk, top);
return 1;
}
void main()
{
int pace[N][N], i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
pace[i][j] = 0;//初始化状态
INPUT:
printf("请指定从哪一格开始(i,j):");
scanf ("%d,%d", &i, &j);
if (i >= N || j >= N) goto INPUT;
if(!running (pace, i, j))
printf ("从您指定的这一格无法不重复地走遍整个棋盘\n");
}
wyb_Ultra
2002-07-11
打赏
举报
回复
做出来,和做得好是两回事。当然,做得太好也不行。人家的作业嘛……
xman200x
2002-07-11
打赏
举报
回复
你早晨不等我,靠。我知道了。
包,靠!!!!!!!!
qiangqiang1112
2002-07-11
打赏
举报
回复
夸张吧,你忙这么多干吗啊,写写思路就好了吧,不过还是很值得收藏的!!!
呵呵!
qiangqiang1112
2002-07-11
打赏
举报
回复
夸张吧,你忙这么多干吗啊,写写思路就好了吧,不过还是很值得收藏的!!!
呵呵!
alidiedie
2002-07-10
打赏
举报
回复
我今天作了这个程序的三个版本:都是回溯法
递归形式.
用堆栈实现
用迭代实现.
其实三者思想一样,用堆栈模拟函数递归调用,就成了用stack的程序了.
把stack中的数据存在数组中,就成了迭代形式了
都已经调试通过了.
我可是忙了一天的,楼主,分不能少啊.呵呵.
*********************************************
递归形式
*********************************************
#include <stdio.h>
#define Max 5
#define BOOL int
#define TRUE 1
#define FALSE 0
struct deta
{
int detax;
int detay;
};
struct position
{
int x;
int y;
};
struct position P[Max*Max]; /* 记录具体一步所走到的位置 */
int order[Max][Max]; /* 记录方格在路径中的序号 */
struct deta D[Max]; /* 记录所有可能转向路径的变化量 */
int B[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};
int A[Max*Max]; /* 记录具体一步已经搜索的范围 */
void initiate();
BOOL trackback(int m);
BOOL place(int x,int y,int k);
void display();
void main(void)
{ int i;
initiate();
P[0].x=0;
P[0].y=0;
order[P[0].x][P[0].y]=0;
if(trackback(1))
display();
return;
}
BOOL trackback(int m)
{
int tempx,tempy;
BOOL finished=FALSE;
while(!finished&&A[m]<8)
{tempx=P[m-1].x+D[A[m]].detax;
tempy=P[m-1].y+D[A[m]].detay;
A[m]++;
if(place(tempx,tempy,m))
{
P[m].x=tempx;
P[m].y=tempy;
order[tempx][tempy]=m;
if(m<Max*Max-1)
{finished=trackback(m+1);
if(!finished) /*回溯 */
{A[m+1]=0;
P[m].x=-1;
P[m].y=-1;
order[tempx][tempy]=-1;
}
}
else
{
finished=TRUE;
}
}
}
return finished;
}
BOOL place(int x,int y,int k) /* 判断x,y能否作为下一步的位置 */
{
if(x>=0&&x<Max&&y>=0&&y<Max&&order[x][y]==-1)
return 1;
else return 0;
}
void initiate()
{
int i,j;
FILE *fw;
fw=fopen("result.txt","w");
for(i=0;i<Max;i++) /*刚开始,所有棋盘格子都是空白 */
for(j=0;j<Max;j++)
order[i][j]=-1;
for(i=0;i<8;i++) /* 8个可变方向的变化量 */
{
D[i].detax=B[i][0];
D[i].detay=B[i][1];
}
for(i=0;i<Max*Max;i++) /* 刚开始路径为空 */
{
P[i].x=-1;
P[i].y=-1;
A[i]=0;
}
fclose(fw);
}
void display()
{
int i,j;
FILE *fw;
fw=fopen("result.txt","a");
fprintf(fw,"======================================\n");
for(i=0;i<Max;i++)
for(j=0;j<Max;j++)
{if(j==Max-1)fprintf(fw,"%4d \n",order[i][j]);
else fprintf(fw,"%4d ",order[i][j]);
}
fprintf(fw,"======================================\n");
printf("结果已经保存在result.txt文件中\n");
fclose(fw);
return;
}
**********************************************************
栈模拟
********************************************************
/*栈头文件 stack.h */
#define MAXSTACK 500
#define BOOL int
#define TRUE 1
#define FALSE 0
class Stack
{
private:
int MaxSize;
int top;
int S[MAXSTACK];
public:
Stack(int maxsize);
~Stack();
int pop();
void push(int k);
};
/* 栈实现文件 stack.cpp*/
#include "stack.h"
#include <iostream.h>
Stack::Stack(int maxsize)
{
if(maxsize<=MAXSTACK)
{
MaxSize=maxsize;
top=-1;
for(int i=0;i<MAXSTACK;i++)
S[i]=-1;
}
}
Stack::~Stack()
{
}
int Stack::pop()
{int temp;
if(top>=0)
{
temp=S[top];
S[top]=-1;
top--;
return temp;
}
else
{
cout<<"the stack is empty"<<endl;
return -1;
}
}
void Stack::push(int k)
{
if(top<MaxSize-1)
{
top++;
S[top]=k;
}
else
{
cout<<"The stack is full"<<endl;
return;
}
return;
}
/*主程序 */
#include <iostream.h>
#include <stdio.h>
#include "stack.h"
#define Max 5
struct position
{
int x;
int y;
};
int order[Max][Max]; /* 记录方格在路径中的序号 */
int B[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};
int A; /* 记录具体一步已经搜索的范围 */
int m; /* 已经搜索过的范围 */
struct position P;
void initiate();
void display();
BOOL place(int x,int y);
void main(void)
{
Stack stack(400); /* 栈大小不得小于4*Max*Max */
int tempx,tempy,tx,ty;
initiate();
/*************************************************
要特别注意压入栈的顺序与弹出栈的顺序相反
**************************************************/
stack.push(A);
stack.push(P.x);
stack.push(P.y);
stack.push(m);
L1:if(A<8) /* 递归调用返回点*/
{tempx=P.x+B[A][0];
tempy=P.y+B[A][1];
if(place(tempx,tempy))
{
P.x=tempx;
P.y=tempy;
m++;
order[tempx][tempy]=m;
stack.push(A);
stack.push(tempx);
stack.push(tempy);
stack.push(m);
A=0;
goto L1;
}
A++;
goto L1;
}
if(m==Max*Max-1) /* 已经找到答案,返回*/
{display();
return;
}
stack.pop(); /* 回溯,不能进行下去的结点弹出栈 */
ty=stack.pop();
tx=stack.pop();
A=stack.pop();
A++;
order[tx][ty]=-1;
m=stack.pop(); /* 下面四行,用于得上一个节点*/
P.y=stack.pop();
P.x=stack.pop();
int temp=stack.pop();
stack.push(temp);
stack.push(P.x);
stack.push(P.y);
stack.push(m);
goto L1;
}
void initiate()
{
int i,j;
FILE *fw;
fw=fopen("result.txt","w");
for(i=0;i<Max;i++) /*刚开始,所有棋盘格子都是空白 */
for(j=0;j<Max;j++)
order[i][j]=-1;
P.x=0;
P.y=0;
A=0;
m=0;
order[0][0]=m;
fclose(fw);
}
void display()
{
int i,j;
FILE *fw;
fw=fopen("result.txt","a");
fprintf(fw,"======================================\n");
fprintf(fw,"%d\n",m);
for(i=0;i<Max;i++)
for(j=0;j<Max;j++)
{if(j==Max-1)fprintf(fw,"%4d \n",order[i][j]);
else fprintf(fw,"%4d ",order[i][j]);
}
fprintf(fw,"======================================\n");
printf("结果已经保存在result.txt文件中\n");
fclose(fw);
return;
}
BOOL place(int x,int y)
{if(x>=0&&x<Max&&y>=0&&y<Max&&order[x][y]==-1)
return 1;
else return 0;
}
***************************************************
迭代形式
***************************************************
#include <stdio.h>
#define Max 8
#define BOOL int
#define TRUE 1
#define FALSE 0
struct deta
{
int detax;
int detay;
};
struct position
{
int x;
int y;
};
struct position P[Max*Max]; /* 记录具体一步所走到的位置 */
int order[Max][Max]; /* 记录方格在路径中的序号 */
struct deta D[Max]; /* 记录所有可能转向路径的变化量 */
int B[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};
int A[Max*Max]; /* 记录具体一步已经搜索的范围 */
void initiate();
BOOL trackback(int m);
BOOL place(int x,int y,int k);
void display();
void main(void)
{
initiate();
P[0].x=0;
P[0].y=0;
order[P[0].x][P[0].y]=0;
if(trackback(1))
display();
return;
}
BOOL trackback(int m)
{
int tempx,tempy;
BOOL finished=FALSE;
while(!finished&&A[m]<8)
{tempx=P[m-1].x+D[A[m]].detax;
tempy=P[m-1].y+D[A[m]].detay;
A[m]++;
if(place(tempx,tempy,m))
{
P[m].x=tempx;
P[m].y=tempy;
order[tempx][tempy]=m;
if(m<Max*Max-1)
{
finished=trackback(m+1);
if(!finished) /*回溯 */
{A[m+1]=0;
P[m].x=-1;
P[m].y=-1;
order[tempx][tempy]=-1;
}
}
else
{
finished=TRUE;
}
}
}
return finished;
}
BOOL place(int x,int y,int k) /* 判断x,y能否作为下一步的位置 */
{
if(x>=0&&x<Max&&y>=0&&y<Max&&order[x][y]==-1)
return 1;
else return 0;
}
void initiate()
{
int i,j;
FILE *fw;
fw=fopen("result.txt","w");
for(i=0;i<Max;i++) /*刚开始,所有棋盘格子都是空白 */
for(j=0;j<Max;j++)
order[i][j]=-1;
for(i=0;i<8;i++) /* 8个可变方向的变化量 */
{
D[i].detax=B[i][0];
D[i].detay=B[i][1];
}
for(i=0;i<Max*Max;i++) /* 刚开始路径为空 */
{
P[i].x=-1;
P[i].y
qiangqiang1112
2002-07-10
打赏
举报
回复
还是要用什么算法吗???
我们搞过分治的
swf0304
2002-07-10
打赏
举报
回复
那位高手能提示我怎样将线性链表改成栈呢?
rightyeah
2002-07-09
打赏
举报
回复
数组和栈没有什么大的区别,有问题吗?
swf0304
2002-07-09
打赏
举报
回复
我知道这个算法也不是很简单,但是希望各位高手能抽出一点时间来看看它,因为它对我这样的初学者来说太难了。
swf0304
2002-07-09
打赏
举报
回复
但是要求不一样呀!这个算法要求用栈,而且要求将结果用二维数组的形式输出,如上图!我是初学数据结构的,一点都不懂的,希望各位高手能帮帮我的忙!!!
wyb_Ultra
2002-07-09
打赏
举报
回复
To rightyeah(众妙之门):
这是数据结构的一个实习,题目要用栈。这里变成帮人做作业的地方了。可笑!可悲!
To 贴主:
真没你办法,这是我师弟用TC2做的。不知道是帮你,还是害了你。罪过罪过!!!
#include<stdio.h>
#include<stdlib.h>
int step=1,Htry1[8]={-2,-2,-1,-1,1,1,2,2},Htry2[8]={-1,1,-2,2,-2,2,-1,1};
struct PathHead
{/*路径链表的头结点*/
struct path *head;
struct path *end;
};
struct path
{/*用于存放棋子走过的路径*/
int line;
int row;
int beginp;
};
int NextStep(int n,struct PathHead *head,int *board)
{/*判断下一步的位置*/
for(;head->end->beginp<8;head->end->beginp++){
if(head->end->line+Htry1[head->end->beginp]<0 ││ head->end->line+Htry1[head->end->beginp]>=n ││ head->end- >row+Htry2[head->end->beginp]<0 ││ head->end->row+Htry2[head->end->beginp]>=n){
continue;/*判断下一步位置是否在棋盘范围之内*/
}else if(board[(head->end->line+Htry1[head->end->beginp])*n+(head->end->row+Htry2[head->end->beginp])]!=0){
continue;/*判断下一步位置是否已经走过*/
}else
return head->end->beginp;
}
return -1;/*下一步不可走,则返回-1*/
}
int RoadNum(int n,struct PathHead *head,int *board)
{/*返回下一步可走的路的数目*/
int beginp,num=0;
for(beginp=0;beginp<8;beginp++){
if(head->end->line+Htry1[beginp]<0 ││ head->end->line+Htry1[beginp]>=n ││ head->end->row+Htry2[beginp]<0 ││ head->end- >row+Htry2[beginp]>=n){
continue;/*判断下一步位置是否在棋盘范围之内*/
}else if(board[(head->end->line+Htry1[beginp])*n+(head->end->row+Htry2[beginp])]!=0){
continue;/*判断下一步位置是否已经走过*/
}else
num++;
}
return num;/*下一步不可走,则返回-1*/
}
void go(int n,struct PathHead *head,int nextstep,int *board)
{/*走一步*/
step++;
head->end->beginp=nextstep+1;
head->end++;/*重定义链尾*/
head->end->beginp=0;
head->end->line=(head->end-1)->line+Htry1[nextstep];
head->end->row=(head->end-1)->row+Htry2[nextstep];
board[head->end->line*n+head->end->row]=step;/*标记棋盘*/
}
void ungo(int n,struct PathHead *head,int *board)
{/*悔一步*/
step--;
board[head->end->line*n+head->end->row]=0;/*恢复已标记的棋盘*/
head->end--;/*从路径删除*/
/*修改beginp值*/
if((head->end->beginp=NextStep(n,head,board))==-1)
head->end->beginp=8;
}
void output(int n,int *board)
{/*输出结果*/
int i;
for(i=0;i<n*n;i++){
if(i%n==0)
printf("\n");
printf("%2d ",board);
}
printf("\n");
}
void main(int argc, char* argv[])
{
int i,nextstep,n,*board,un=0;
struct PathHead *head=(struct PathHead *)malloc(sizeof(struct PathHead));
printf("Please input chessboard's size: ");
scanf("%d",&n);
/*初始化路径*/
head->head=(struct path *)malloc(sizeof(struct path)*n*n);
head->head->beginp=0;
head->end=head->head;
/*初始化起始位置*/
printf("Please input the begin place(x y): ");
scanf("%d",&head->head->line);
scanf("%d",&head->head->row);
board=(int *)malloc(sizeof(int)*n*n);
for(i=0;i<n*n;i++,board=0);/*初始化棋盘*/
board[head->head->line*n+head->head->row]=1;/*设置起始位置*/
for(i=0;;i++){
while(step<n*n){
if((nextstep=NextStep(n,head,board))!=-1){
go(n,head,nextstep,board);
continue;
}else{
if(step==1){
printf("Trying completed.\nThere are %d method on this question.\n",i);
exit(0);
}/*尝试完成,退出程序*/
if(RoadNum(n,head,board)==0 && step>2){
/*如果未走的位置被分为两个互不相通的部分,则可以多退一步。*/
while(RoadNum(n,head,board)==1 && step>2)
ungo(n,head,board);
if(un==1)/*如果原来已经有一条掘头路,则可以多退一步。*/
ungo(n,head,board);/*因为如果有两条或以上的掘头路,显然行不通。*/
else
un=1;
}
ungo(n,head,board);
continue;
}
}
output(n,board);
ungo(n,head,board);
}
free(head->head);
free(head);
}
wyb_Ultra
2002-07-09
打赏
举报
回复
To rightyeah(众妙之门):
这是数据结构的一个实习,题目要用栈。这里变成帮人做作业的地方了。可笑!可悲!
To 贴主:
真没你办法,这是我师弟用TC2做的。不知道是帮你,还是害了你。罪过罪过!!!
#include<stdio.h>
#include<stdlib.h>
int step=1,Htry1[8]={-2,-2,-1,-1,1,1,2,2},Htry2[8]={-1,1,-2,2,-2,2,-1,1};
struct PathHead
{/*路径链表的头结点*/
struct path *head;
struct path *end;
};
struct path
{/*用于存放棋子走过的路径*/
int line;
int row;
int beginp;
};
int NextStep(int n,struct PathHead *head,int *board)
{/*判断下一步的位置*/
for(;head->end->beginp<8;head->end->beginp++){
if(head->end->line+Htry1[head->end->beginp]<0 ││ head->end->line+Htry1[head->end->beginp]>=n ││ head->end- >row+Htry2[head->end->beginp]<0 ││ head->end->row+Htry2[head->end->beginp]>=n){
continue;/*判断下一步位置是否在棋盘范围之内*/
}else if(board[(head->end->line+Htry1[head->end->beginp])*n+(head->end->row+Htry2[head->end->beginp])]!=0){
continue;/*判断下一步位置是否已经走过*/
}else
return head->end->beginp;
}
return -1;/*下一步不可走,则返回-1*/
}
int RoadNum(int n,struct PathHead *head,int *board)
{/*返回下一步可走的路的数目*/
int beginp,num=0;
for(beginp=0;beginp<8;beginp++){
if(head->end->line+Htry1[beginp]<0 ││ head->end->line+Htry1[beginp]>=n ││ head->end->row+Htry2[beginp]<0 ││ head->end- >row+Htry2[beginp]>=n){
continue;/*判断下一步位置是否在棋盘范围之内*/
}else if(board[(head->end->line+Htry1[beginp])*n+(head->end->row+Htry2[beginp])]!=0){
continue;/*判断下一步位置是否已经走过*/
}else
num++;
}
return num;/*下一步不可走,则返回-1*/
}
void go(int n,struct PathHead *head,int nextstep,int *board)
{/*走一步*/
step++;
head->end->beginp=nextstep+1;
head->end++;/*重定义链尾*/
head->end->beginp=0;
head->end->line=(head->end-1)->line+Htry1[nextstep];
head->end->row=(head->end-1)->row+Htry2[nextstep];
board[head->end->line*n+head->end->row]=step;/*标记棋盘*/
}
void ungo(int n,struct PathHead *head,int *board)
{/*悔一步*/
step--;
board[head->end->line*n+head->end->row]=0;/*恢复已标记的棋盘*/
head->end--;/*从路径删除*/
/*修改beginp值*/
if((head->end->beginp=NextStep(n,head,board))==-1)
head->end->beginp=8;
}
void output(int n,int *board)
{/*输出结果*/
int i;
for(i=0;i<n*n;i++){
if(i%n==0)
printf("\n");
printf("%2d ",board);
}
printf("\n");
}
void main(int argc, char* argv[])
{
int i,nextstep,n,*board,un=0;
struct PathHead *head=(struct PathHead *)malloc(sizeof(struct PathHead));
printf("Please input chessboard's size: ");
scanf("%d",&n);
/*初始化路径*/
head->head=(struct path *)malloc(sizeof(struct path)*n*n);
head->head->beginp=0;
head->end=head->head;
/*初始化起始位置*/
printf("Please input the begin place(x y): ");
scanf("%d",&head->head->line);
scanf("%d",&head->head->row);
board=(int *)malloc(sizeof(int)*n*n);
for(i=0;i<n*n;i++,board=0);/*初始化棋盘*/
board[head->head->line*n+head->head->row]=1;/*设置起始位置*/
for(i=0;;i++){
while(step<n*n){
if((nextstep=NextStep(n,head,board))!=-1){
go(n,head,nextstep,board);
continue;
}else{
if(step==1){
printf("Trying completed.\nThere are %d method on this question.\n",i);
exit(0);
}/*尝试完成,退出程序*/
if(RoadNum(n,head,board)==0 && step>2){
/*如果未走的位置被分为两个互不相通的部分,则可以多退一步。*/
while(RoadNum(n,head,board)==1 && step>2)
ungo(n,head,board);
if(un==1)/*如果原来已经有一条掘头路,则可以多退一步。*/
ungo(n,head,board);/*因为如果有两条或以上的掘头路,显然行不通。*/
else
un=1;
}
ungo(n,head,board);
continue;
}
}
output(n,board);
ungo(n,head,board);
}
free(head->head);
free(head);
}
swf0304
2002-07-08
打赏
举报
回复
请大家一定要注意要求,谁能帮了小弟,小弟一定会痛哭流泣的!
jane1234
2002-07-08
打赏
举报
回复
请检索“骑士问题,请帮我解决一下”,其中附有一个源程序。
zhouxinghai
2002-07-08
打赏
举报
回复
例如:
start x, y: 3,3
3 8 5 16 13 10 23 20
6 17 2 9 22 19 14 11
33 4 7 18 15 12 21 24
30 27 32 1 38 25 48 43
53 34 29 26 49 44 39 60
28 31 52 37 56 59 42 47
35 54 63 50 45 40 61 58
64 51 36 55 62 57 46 41
zhouxinghai
2002-07-08
打赏
举报
回复
#include <stdio.h>
const int Xmax = 8, Ymax = 8, depth = Xmax*Ymax;
void main()
{
const Xsel[] = { -2, -2, -1, -1, 1, 1, 2, 2};
const Ysel[] = { -1, 1, -2, 2, -2, 2, -1, 1};
int s[depth]={0,}, m[depth][Ymax]={0,}, x[depth], y[depth],
i, j, k, out[Xmax][Ymax];
printf("start x, y: ");
scanf("%d,%d", &x[0], &y[0]);
m[0][y[0]] |= (1<<x[0]);
for (i=0;;) {
if (i==depth-1) {
for (j=0; j<depth; j++) out[x[j]][y[j]]=j+1;
for (j=0; j<Ymax; j++) {
for (k=0; k<Xmax; k++) printf("%2d ", out[j][k]);
printf("\n");
}
return;
/* i--;
s[i]++;
continue; */
}
if (s[i]>7) {
if (--i<0) break;
s[i]++;
continue;
}
x[i+1] = x[i] + Xsel[s[i]];
y[i+1] = y[i] + Ysel[s[i]];
if (x[i+1]<0 || x[i+1]>=Xmax || y[i+1]<0 || y[i+1]>=Ymax ||
((m[i][y[i+1]]>>x[i+1])&1)) {
s[i]++;
continue;
}
i++;
s[i]=0;
for (j=0; j<Ymax; j++) m[i][j]=m[i-1][j];
m[i][y[i]] |= (1<<x[i]);
}
}
wyb_Ultra
2002-07-08
打赏
举报
回复
你搜索一下,这里太多这样的帖子了。
加载更多回复(2)
马踏棋盘
C语言
的完整
算法
马踏棋盘
C语言
的完整
算法
vs2013下编译运行通过
C语言
实现
马踏棋盘
使用
C语言
实现的
马踏棋盘
,利用的贪心
算法
,效率大大提升
c语言
常用
算法
集
几个不错的
c语言
算法
C语言
100
个
算法
经典例题
C语言
100
个
算法
经典例题,免费共享,需要的就下吧
JAVA近百种
算法
大全
最近找到的JAVA近百种
算法
大全
分
享一下 java
算法
大全,有近
100
多种常见
算法
的源代码,是学习JAVA
算法
的难得资料,需要的童鞋来下载吧!
数据结构与算法
33,027
社区成员
35,335
社区内容
发帖
与我相关
我的任务
数据结构与算法
数据结构与算法相关内容讨论专区
复制链接
扫一扫
分享
社区描述
数据结构与算法相关内容讨论专区
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章