马踏棋盘--C语言算法(小弟请教高手)100分!

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

...全文
198 22 打赏 收藏 转发到动态 举报
写回复
用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)
1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题:1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二查找算法(非递归)、算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容:本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度析、二查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二查找算法(非递归)、算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

33,006

社区成员

发帖
与我相关
我的任务
社区描述
数据结构与算法相关内容讨论专区
社区管理员
  • 数据结构与算法社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧