马踏棋盘的c语言实现（一.遍历法）

     题目很简单呀！！！

    在国际象棋的棋盘上，将马随意放置，之后走日字，走完即可。

    要求：8×8的棋盘 

    遍历算法：

              可以说是碰运气，当你确定在某一位置时，根据规则你自然有了八种选择，

	2		3
1				4
		H
8				6
	7		5

    分别是

             X=   {i-2, i-1, i+1, i+2, i+2, i+1, i-1, i-2};

             Y=   {i-1, i-2, i-2, i-1, i+1, i+2, i+2, i+1};

    往简单了想，当其越界或是已被占有，下一个位置的可能去向就会减少，你要做的就是检验当前步的下一步的情况中有那个是可以走，那个不可以，可以了就直接往下走，不行就跳到下一步。但注意当八种情况都不行时就必须可以回溯到上一步的位置

（重点在于获得上一步往下一步走选路情况，以便你不会再走同样的路）。幸运的话，也许能出来，不幸的话，就和我的同学一样，跑了三个小时还是没出结果。

    使用的数据结构是三个整型栈，分别存放x，y，t（当前步如何走向下一步）

    注意以下代码只能跑出（2,3）的位置，其他位置不是待检验，就是跑时间太长

      人如果你想检验正确与否，就将代码中宏定义的64,8改为36,6(其他也可以吧)，检验之后是能跑的

      

   

/*************************************************************************
    > File Name: mataqipan.c
    > Author: zh
    > Mail: 574932286@qq.com 
    > Created Time: 2014年09月28日 星期日 16时21分10秒
    > 实现马踏棋盘
  8  ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#define STACKSIZE 64 
#define MAPSIZE 8 //
#define FALSE 0
#define TURE 1

typedef struct stack * Stack;
typedef int ElementType;

int IsEmpty( Stack S );
int IsFull( Stack S );
Stack CreateStack( void  );
int Push( Stack S, ElementType X );
ElementType Pop( Stack S );
ElementType Top( Stack S );
int IntTest( int i, int j );
int Test( int i, int j, int  Map[][MAPSIZE] );
void Hua( int i, int j, int Map[][MAPSIZE] );
void ReHua( int i, int j, int Map[][MAPSIZE] );


struct stack{
    int top;
    ElementType Array[STACKSIZE];
};

int IsEmpty( Stack Q )
{
    return Q->top == -1;
}/*IsEmpty*/

int IsFull( Stack Q )
{
    return Q->top == STACKSIZE-1;
}/*IsFull*/

/*创建一个存放64个整型数的栈*/
Stack CreateStack( void )
{
    Stack S;
    S = (Stack)malloc(sizeof(struct stack));

    if( S == NULL )
    {
       exit(1);
    }
    S->top = -1;
    return S;
}/*CreateStack*/

int Push( Stack S, ElementType X )
{
    if( IsFull(S) )
    {
        return FALSE;
    }
    else
    {
         S->top++;
        S->Array[S->top] = X;
        return TURE;
    }
}/* Push */

/* 出栈并且返回出栈的值 */
ElementType Pop( Stack S )
{
    int temp;
    if( IsEmpty(S) )
    {
        printf("栈空
");
        getchar();
        exit(0);
    }
    else
    {
        temp=S->top;
        S->top--;
        return S->Array[temp];
    }
}/* Pop */

/* 输出栈顶元素 */
ElementType Top( Stack S )
{ 
    if( IsEmpty(S) )
    {
        printf("栈空
");
        system("PAUSE");
        exit(0);
    }
    else
    {
        return S->Array[S->top];
    }
}/* Top */

/* 检验被初始化的i,j 是否越位,没有越位返回TURE，否则返回FLASE */
int  IntTest( int i, int j )
{
    if( i>=0 && i<MAPSIZE && j>=0 && j<MAPSIZE )
    {
        return TURE;
    }
    else
    {
        return FALSE;
    }
}/* IntTest */

/* 判断该位置是否已经被占和该位置是否越位，符合条件返回TURE ，否则返回FLASE*/
int Test( int i, int j, int Map[][MAPSIZE] )
{
    if( Map[i][j]==1 || !IntTest(i,j) )//判断该位置是否已经被占和该位置是否越位
    {
        return FALSE;
    }
    else
    {
        return TURE;
    }
}/* Test */

/* 为MAP做标记 */
void Hua( int i, int j, int Map[][MAPSIZE] )
{
    Map[i][j] = TURE;
}/* Hua */

/* 消除Map上的标记 */
void ReHua( int i, int j, int Map[][MAPSIZE] )
{
    Map[i][j] = FALSE;
}/* ReHUa */

int main( void )
{
    Stack A, B, C ;/*3个栈分别用来存储 i,j.t[下一步棋在当前步棋八个位置中的那一个]*/
    int Map[MAPSIZE][MAPSIZE]={0};
    int a[8]={-2,-1, 1, 2,2,1,-1,-2};
    int b[8]={-1,-2,-2,-1,1,2, 2, 1};
    int i,j,t;
    int temp;

    A = CreateStack();
    B = CreateStack();
    C = CreateStack();//栈的初始化
    do{
    printf("输入x ：");
    scanf("%d",&i);
    printf("输入y ：");
    scanf("%d",&j);
    temp=IntTest( i, j );//测试输入
    }while(!temp );

    Hua( i, j, Map);
    Push( A, i );
    Push( B, j );
    Push( C, -1 );
    
    while( !IsFull(A) )
    {
        
            if( IsEmpty( A ) )
            { printf("Oh No, why ,shit ,fuck,come up 
");
              printf(" 不可能有这种走法
");
            getchar();  
              exit(0);
            }
        //栈空的可能性

        i = Top( A );
        j = Top( B );
        t = Top( C )+1;
        
        while( t<=8-1  && !Test( a[t]+i, b[t]+j , Map ) )   //    
        {
            t++;
            if( t == 8 )
                break;
        }//while,用以判断8种可能那种不合适
    
        if( t == 8 )
        {
            i = Pop( A );
            j = Pop( B );
            Pop( C );
            ReHua( i, j, Map );
        }//回溯到上一步
        else
        {
            Push( A, a[t]+i );
            Push( B, b[t]+j );
            Pop( C );
            Push( C, t );
            Push( C, -1 );
            Hua( a[t]+i, b[t]+j, Map );
        }// 下一步被确认，将i，j，t 放入栈中，并将-1放入栈,在map上标记该步

    }
    printf("OK
");
    getchar();
    for( i=0; i<MAPSIZE; i++ )
        for( j=0; j<MAPSIZE; j++ )
        {
           Map[A->Array[i*MAPSIZE+j]][B->Array[i*MAPSIZE+j]]=i*MAPSIZE+j;
        }
    for( i=0; i<MAPSIZE; i++ )
        for( j=0; j<MAPSIZE; j++ )
        {
            printf("%5d",Map[i][j]);
            if( j == MAPSIZE-1 )
                printf("
");
        }
     getchar();
     return 0;
}