C程序-马踏棋盘

原理

马踏棋盘原理就是，在一个8*8方格中，定义一个起点根据马走日的原理，将方格中所有位置都走一遍，但不走重复的位置。

栈、结构体法

#include <stdlib.h>
#include <stdio.h>
#define ROW 8
#define COL 8
#define DIR 8

//初始化结构体
struct Node
{
    int x;
    int y;
    int dir;
    int count;
    struct Node *next;
};

//新建头节点
struct Node *head;
//新增头节点
void push(struct Node *node);
//返回头节点
struct Node *pop();
//删除指定结点
void delete ();
//打印节点
void print();

void printNode(struct Node *node);
//初始化节点
void initChess(int chess[ROW][COL]);
//开始执行马踏棋盘
void playChess(int chess[ROW][COL]);
//打印马踏棋盘
void printChess(int chess[ROW][COL]);
//新建添加节点
struct Node *createNode(int x, int y, int dir, int count);

int main()
{
    head = NULL;

    //struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    //node->x = 0;
    //node->y = 0;
    //node->dir = 0;
    //node->next = NULL;
    //push(node);

    //struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    //node2->x = 1;
    //node2->y = 1;
    //node2->dir = 1;
    //node2->next = NULL;
    //push(node2);

    //print();

    //struct Node* node3 = pop();
    //printNode(node3);

    //delete();
    //free(node3);

    //print();

    int chess[ROW][COL];
    initChess(chess);
    playChess(chess);
    printChess(chess);
}

void push(struct Node *node)
{
    if (NULL == head)
    {
        head = node;
        head->next = NULL;
    }
    else
    {
        node->next = head;
        head = node;
    }
}

struct Node *pop()
{
    return head;
}

void delete ()
{
    head = head->next;
}

void print()
{
    struct Node *node = head;
    while (node != NULL)
    {
        printNode(node);
        node = node->next;
    }
}
//打印结构体内容
void printNode(struct Node *node)
{
    printf("x=%d,y=%d,dir=%d\n", node->x, node->y, node->dir);
}

void initChess(int chess[ROW][COL])
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            chess[i][j] = 0;
        }
    }
}

void playChess(int chess[ROW][COL])
{
    int x = 0, y = 0, dir = -1;
    printf("请您输入马踏棋盘开始坐标：");
    scanf("%d %d", &x, &y);
    int xDir[DIR] = {2, 2, 1, 1, -2, -2, -1, -1};
    int yDir[DIR] = {-1, 1, -2, 2, -1, 1, -2, 2};

    chess[x][y] = 1;
    struct Node *node = createNode(x, y, dir, 1);
    push(node);

    struct Node *currentNode = pop();

    while (NULL != currentNode)
    {
        if (currentNode->count == 64)
        {
            break;
        }

        int findNext = 0;
        for (int currentDir = (currentNode->dir + 1); currentDir < DIR; currentDir++)
        {
            int nextX = currentNode->x + xDir[currentDir];
            int nextY = currentNode->y + yDir[currentDir];
            if (nextX >= 0 && nextX < ROW && nextY >= 0 && nextY < COL && 0 == chess[nextX][nextY])
            {
                chess[nextX][nextY] = currentNode->count + 1;

                currentNode->dir = currentDir;

                struct Node *nexNode = createNode(nextX, nextY, -1, currentNode->count + 1);
                push(nexNode);
                findNext = 1;
                break;
            }
        }

        if (0 == findNext)
        {
            chess[currentNode->x][currentNode->y] = 0;
            delete ();
            free(currentNode);
        }

        currentNode = pop();
    }
}

void printChess(int chess[ROW][COL])
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            printf("%-4d", chess[i][j]);
        }
        printf("\n");
    }
}

struct Node *createNode(int x, int y, int dir, int count)
{
    struct Node *node = (struct Node *)malloc(sizeof(struct Node));
    node->x = x;
    node->y = y;
    node->dir = dir;
    node->count = count;
    node->next = NULL;
    return node;
}

回溯法

#include <stdio.h>
#define X 8
#define Y 8
#define a 0
int chess[X][Y];

int nextxy(int* x, int* y, int count)  //找到基于x,y位置的下一个可走的位置
{
    switch (count)
    {
    case 0:
        if (*x + 2 <= X - 1 && *y - 1 >= 0 && chess[*x + 2][*y - 1] == 0)
        {
            *x = *x + 2;
            *y = *y - 1;
            return 1;
        }
        break;
    case 1:
        if (*x + 2 <= X - 1 && *y + 1 <= Y - 1 && chess[*x + 2][*y + 1] == 0)
        {
            *x = *x + 2;
            *y = *y + 1;
            return 1;
        }
        break;
    case 2:
        if (*x + 1 <= X - 1 && *y - 2 >= 0 && chess[*x + 1][*y - 2] == 0)
        {
            *x = *x + 1;
            *y = *y - 2;
            return 1;
        }
        break;
    case 3:
        if (*x + 1 <= X - 1 && *y + 2 <= Y - 1 && chess[*x + 1][*y + 2] == 0)
        {
            *x = *x + 1;
            *y = *y + 2;
            return 1;
        }
        break;
    case 4:
        if (*x - 2 >= 0 && *y - 1 >= 0 && chess[*x - 2][*y - 1] == 0)
        {
            *x = *x - 2;
            *y = *y - 1;
            return 1;
        }
        break;
    case 5:
        if (*x - 2 >= 0 && *y + 1 <= Y - 1 && chess[*x - 2][*y + 1] == 0)
        {
            *x = *x - 2;
            *y = *y + 1;
            return 1;
        }
        break;
    case 6:
        if (*x - 1 >= 0 && *y - 2 >= 0 && chess[*x - 1][*y - 2] == 0)
        {
            *x = *x - 1;
            *y = *y - 2;
            return 1;
        }
        break;
    case 7:
        if (*x - 1 >= 0 && *y + 2 <= Y - 1 && chess[*x - 1][*y + 2] == 0)
        {
            *x = *x - 1;
            *y = *y + 2;
            return 1;
        }
        break;
    default:
        break;
    }
    return 0;
}

int TravelChessBoard(int x, int y, int tag)  //深度优先搜索地"马踏棋盘"
{
    int x1 = x, y1 = y, flag = 0, count = 0;
    chess[x][y] = tag;
    if (tag == X * Y)
    {
        return 1;
    }
    flag = nextxy(&x1, &y1, count);
    while (flag == 0 && count < 7)
    {
        count = count + 1;
        flag = nextxy(&x1, &y1, count);
    }
    while (flag)
    {
        if (TravelChessBoard(x1, y1, tag + 1))
            return 1;
        x1 = x;
        y1 = y;
        count = count + 1;
        flag = nextxy(&x1, &y1, count);  //寻找下一个(x,y)
        
        while (flag == 0 && count < 7)
        {  //循环地寻找下一个(x,y)
            count = count + 1;
            flag = nextxy(&x1, &y1, count);
        }
    }
    if (flag == 0)
        chess[x][y] = 0;
    //printf("循环次数：%d\n", a);
    return 0;
}
int main()
{
    int i, j , d ,b;
    for (i = 0; i < X; i++)
        for (j = 0; j < Y; j++)
            chess[i][j] = 0;
    printf("请输入初始坐标：");
    scanf_s("%d %d",&d, &b);
    if (TravelChessBoard(d, b, 1))
    {
        for (i = 0; i < X; i++)
        {
            for (j = 0; j < Y; j++)
                printf("%-5d", chess[i][j]);
            printf("\n");
        }
        printf("The horse has travelled the chess borad\n");
    }
    else
        printf("The horse cannot travel the chess board\n");
    return 0;
}

贪心法

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 8
#define COL 8
#define MAX_STEPS ROW*COL //64

//栈结构体
typedef struct stack {
    int x_adr;      //纵坐标
    int y_adr;      //横坐标
    int direction;  //方向
}HORSE_CHESS_STACK;

//存储路径棋盘
int chess[ROW + 1][COL + 1];

//下一步方向
//一号
int dir[8][2] = { {2,-1},{-2,-1},{-2,1},{2,1},
                 {1,-2},{-1,-2},{-1,2},{1,2} };

//二号
// int dir[8][2] = {{1,2},{-1,-2},{-2,1},{2,1},
//                {2,-1},{1,-2},{-1,2},{-2,-1}};

                  //栈顶
int top;
HORSE_CHESS_STACK Adr_Stack[MAX_STEPS];

//出栈次数
int out_stack;

//初始化数据
void init() {
    int n = MAX_STEPS;//N=64
    while (n--) {
        Adr_Stack[n].x_adr = 0;
        Adr_Stack[n].y_adr = 0;
        Adr_Stack[n].direction = -1;
    }
    Adr_Stack[0].x_adr = 0;
    Adr_Stack[0].y_adr = 0;
    Adr_Stack[0].direction = -1;

    for (int i = 1; i <= ROW; i++) {
        for (int j = 1; j <= COL; j++) {
            chess[ROW][COL] = 0;
        }
    }

    top = -1;
    out_stack = 0;
}

//debug 打印栈的情况
void print_stack() {
    printf("栈的情况:\n");
    for (int i = 0; i < MAX_STEPS; i++) {
        printf("x:%d  y:%d direction = %d\n", Adr_Stack[i].y_adr, Adr_Stack[i].x_adr, Adr_Stack[i].direction);
    }
    printf("\n\n");
}

//入栈
void push_stack(int x_real, int y_real) {
    top++;
    Adr_Stack[top].x_adr = x_real;
    Adr_Stack[top].y_adr = y_real;
    Adr_Stack[top].direction = -1;  //初始化走的方向
}

//出栈
void pop_stack() {
    Adr_Stack[top].x_adr = 0;
    Adr_Stack[top].y_adr = 0;
    Adr_Stack[top].direction = -1;  //初始化走的方向
    top--;
}

//标记位置
void mark_chess(int x, int y) {
    chess[y][x] = top + 1;
}

//打印路径
void print_chess_board() {
    printf("\nroute:\n");
    for (int i = 1; i <= ROW; i++) {
        for (int j = 1; j <= ROW; j++) {
            printf("%4d ", chess[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

//打印每一步的位置
int t = 1;
void print_steps() {
    printf("(%d,%d)", Adr_Stack[top].y_adr, Adr_Stack[top].x_adr);
    t++;
    if (t == ROW) {
        printf("\n");
        t = 0;
    }
}


void run_horse_tanxin() {
    int x_now, y_now;
    while (1) {

        //已经走完全图
        if (top >= MAX_STEPS - 1) {
            //打印棋盘
            print_chess_board();
            break;
        }

        //现在位置
        x_now = Adr_Stack[top].x_adr;
        y_now = Adr_Stack[top].y_adr;

        //对方向进行排序
        int next[ROW] = {};
        for (int i = 0; i < ROW; i++) {
            //下一步坐标
            int x_next = x_now + dir[i][0];
            int y_next = y_now + dir[i][1];

            if ((x_next > 0 && x_next <= COL) && (y_next > 0 && y_next <= ROW) && chess[y_next][x_next] == 0) {
                //对下一步的下一步判断是否可以走
                for (int j = 0; j < ROW; j++) {
                    int x_next_next = x_next + dir[j][0];
                    int y_next_next = y_next + dir[j][1];

                    //可以走,next 对应下标+1
                    if ((x_next_next > 0 && x_next_next <= COL) && (y_next_next > 0 && y_next_next <= ROW) && chess[y_next_next][x_next_next] == 0) {
                        next[i]++;
                    }
                }
            }
        }

        //依次返回 next 中最小元素的下标，返回后将元素赋值为最大
        int real_next[8] = { 0 };
        int k = 0;
        int t = ROW + 1;
        for (int i = 0; i < ROW; i++) {
            t = ROW + 1;
            for (int j = 0; j < 8; j++) {
                if (next[j] < t) {
                    real_next[i] = j;
                    t = next[j];
                    k = j;
                }
            }
            next[k] = ROW + 1;
        }

        //走下一步
        int dir_now = 0;
        for (dir_now = Adr_Stack[top].direction + 1; dir_now < ROW; dir_now++) {
            int x_real = x_now + dir[real_next[dir_now]][0];
            int y_real = y_now + dir[real_next[dir_now]][1];

            Adr_Stack[top].direction += 1;

            if ((x_real <= COL && x_real > 0) && (y_real <= ROW && y_real > 0) && chess[y_real][x_real] == 0) {
                //入栈
                push_stack(x_real, y_real);
                //标记棋盘
                mark_chess(x_real, y_real);
                break;
            }
        }

        //如果下一步走不了，则出栈回溯
        if (Adr_Stack[top].direction >= 7) {
            printf("\n out:(%d,%d) \n", Adr_Stack[top].y_adr, Adr_Stack[top].x_adr);
            chess[Adr_Stack[top].y_adr][Adr_Stack[top].x_adr] = 0;
            //记录出栈次数
            out_stack++;
            pop_stack();
        }

        //打印栈
        // print_stack();
        //打印走了以后所处位置
print_steps();
    }
}

int main() {
    int st_x, st_y;
    while (1) {
        printf("Please input: x  y :");
        scanf_s("%d %d", &st_x, &st_y);

        if (st_x > 0 && st_x <= ROW && st_y > 0 && st_y <= COL) {
            printf("Get x and y success!\n");
            break;
        }

        printf("Input wrong!please input x y again:");
    }
    init();
    //print_stack();
    //获得开始时间
    clock_t start = clock();

    //将起始位置入栈
    push_stack(st_x, st_y);
    //标记起始位置
    mark_chess(st_x, st_y);

    printf("\nroute address:\n");
    printf("(%d,%d)", st_x, st_y);

    //开始算法
    run_horse_tanxin();

    //计算结束时间
    clock_t finish = clock();
    double run_time = (double)(finish - start) / CLOCKS_PER_SEC;

    printf("Running time：%f seconds  \nOut stack times:%d\n", run_time, out_stack);
}