马踏棋盘--C语言算法（小弟请教高手）100分！

[swf0304]

我最近在做课程设计，题目是用C语言编一个马踏棋盘的非递归程序，必须用栈。要求将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中，马按走棋规则进行移动，要求每个方格只进一次，走遍棋盘上64格，求出马的行走路线，并按马的行走路线将1到64依次填入一个8*8的方阵，输出之。已经过去一个多礼拜了还是没有做出来，有的地方根本不知怎么做，感觉特别难。希望各位高手能帮帮小弟的忙！

[wyb_Ultra]

你搜索一下，这里太多这样的帖子了。

[zhouxinghai]

#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]);
}
}

[zhouxinghai]

例如：
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

[jane1234]

请检索“骑士问题，请帮我解决一下”，其中附有一个源程序。

[swf0304]

请大家一定要注意要求，谁能帮了小弟，小弟一定会痛哭流泣的！

[wyb_Ultra]

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]

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]

但是要求不一样呀！这个算法要求用栈，而且要求将结果用二维数组的形式输出，如上图！我是初学数据结构的，一点都不懂的，希望各位高手能帮帮我的忙！！！

[swf0304]

我知道这个算法也不是很简单，但是希望各位高手能抽出一点时间来看看它，因为它对我这样的初学者来说太难了。

[rightyeah]

数组和栈没有什么大的区别，有问题吗？

[swf0304]

那位高手能提示我怎样将线性链表改成栈呢？

[qiangqiang1112]

还是要用什么算法吗？？？
我们搞过分治的

[alidiedie]

我今天作了这个程序的三个版本:都是回溯法
递归形式.
用堆栈实现
用迭代实现.

其实三者思想一样,用堆栈模拟函数递归调用,就成了用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]

夸张吧，你忙这么多干吗啊，写写思路就好了吧，不过还是很值得收藏的！！！
呵呵！

[qiangqiang1112]

夸张吧，你忙这么多干吗啊，写写思路就好了吧，不过还是很值得收藏的！！！
呵呵！

[xman200x]

你早晨不等我，靠。我知道了。
包，靠！！！！！！！！

[wyb_Ultra]

做出来，和做得好是两回事。当然，做得太好也不行。人家的作业嘛……

[swf0304]

谁能帮我改改这个程序！
#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]

谁能帮我改改这个程序？
#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]

谁能帮我改改这个算法？
#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");
}