深度优先算法和Ncurses - 迷宫

Posted 2021-02-13 litran

前言：

阅读此篇文章要求读者具有一些基础的ncurses库了解

深度优先算法是将各种情况分配一定的优先级，然后在某个问题出现的时候，选择优先级高的情况进行处理，特定情况下进行回退，选择优先级次之的情况进行尝试. 点击这里可以得到源码

我这里没有考虑没有出口的情况下，深度优先算法的行为结果。之后会有专门的研究文章。

---

程序主体思路

过程

• 创建一个迷宫
• 创建一个人
• 把人放到迷宫的入口
• 深度优先算法控制人，走到出口。
• 退出

代码

#include <ncurses.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


// this is the myth map.
char myth[][31] = {

    "******************************", 
    "              *          *   *",
    "*  ****       *        *    ->",
    "*     *       * ******   *****",
    "********      *              *",
    "*   **    *   *  * ******** **",
    "* * *       *    *           *",
    "* * ******* *    *  ******** *",
    "* *         *    *           *",
    "* * *  *    *    *    ***    *",        
    "******************************"
};

这里用一个字符数组来存储迷宫的信息

char book[12][30] = {0};

book数组负责这个点有没有走过的标记

int myth_starty = 0;
int myth_startx = 0;

myth_starty, myth_startx 分别负责在myth WINDOW里面的迷宫左上角起点坐标的y和x， 因为在ncurses里面，的坐标和我们的迷宫数组下标之间需要一个翻译。

// this is a person struct.
typedef struct _person
{
        int x;
        int y;
    int step;

}Person;

这是一个结构体，来存放player的信息

// this a struct for a point in game.
typedef struct _loc
{
    int x, y;
}MLoc;

一个包装了y和x两个int值的结构体， 没怎么用

// this function handle the person‘s moving.
void moveTo(WINDOW *w, Person *p, int y, int x);

这个函数负责把一个Person移动到某个窗口w的y行x列

// this function return a person pointer.
Person* con_person();

这个函数负责construct一个person，返回Person指针

// this function destroy a person.
void destroy_person(Person *p);

这个函数释放Person指针p指向的堆内存

// this funcion creates a myth in the middle of the target window.
int create_myth(WINDOW *target);

这个函数负责打印迷宫到窗口target的中心

//
void go_through(WINDOW *, Person *);

这个函数就是负责让小人走出迷宫

int main()
{
    // preparation for this program.
    initscr();
    clear();
    curs_set(0); // hide the cursor
    noecho(); // no echo.
    cbreak(); // close the line buffer.

ncurses程序初始化准备部分

init_pair(1, COLOR_RED, COLOR_BLACK);
init_pair(2, COLOR_BLACK, COLOR_WHITE);

颜色效果不太好，然后就取消掉了。这两行代码无用

// make a border for the standred screen.
wborder(stdscr,  ‘|‘, ‘|‘, ‘-‘, ‘-‘, ‘*‘, ‘*‘, ‘*‘, ‘*‘);
refresh();

给标准屏幕添加一个边框

// two var for the max size of the stdscr.
int scry, scrx;
getmaxyx(stdscr, scry, scrx);

// 把标准屏幕的宽度和高度存放在scrx，scry里面

// use a LOC var for an area. y stands for height, x stands for width.
MLoc title_part;
title_part.y =     (scry-15)/2 + 4;
title_part.x =  (scrx-50)/2;    

// 计算出title_part的大小， 用来存放一些程序信息

/* print some game info */
char *title = " GAME: Crack the myth ";
char *author = " AUTHOR: Jack ";
char *version = " VERSION: 1.0.1 ";



attron(A_REVERSE);
mvprintw((title_part.y - 3)/2, (scrx-strlen(title))/2, "%s", title);
attroff(A_REVERSE);    

attron(A_UNDERLINE);
mvprintw((title_part.y - 3)/2 + 1, (scrx-strlen(version))/2, "%s", version);
mvprintw((title_part.y - 3)/2 + 2, (scrx-strlen(author))/2, "%s", author);
attroff(A_UNDERLINE);

refresh();

把名称、作者信息、版本号打印在游戏界面中

// myth is a window for the myth map.
WINDOW *w_myth = newwin(15, 50, (scry-15)/2 + 4, (scrx-50)/2 - 20);

// we called the function which we defined to show the myth map
create_myth(w_myth);
wborder(w_myth,  ‘|‘, ‘|‘, ‘-‘, ‘-‘, ‘+‘, ‘+‘, ‘+‘, ‘+‘);
// 
mvwprintw(stdscr,  (scry-15)/2 + 4 + 6, (scrx-50)/2 - 20 + 60, "Cracking...");
refresh();
wrefresh(w_myth);

创建一个窗口来存放迷宫地图，并且给其添加边界

// put a person on myth.
Person *player = con_person();
moveTo(w_myth, player, 1, 0);


getchar();

随便得到一个字符之后，开始进行寻路

    go_through(w_myth, player);


    // get a character then exit.
    getchar();
    endwin();

    return 0;
}

以上就是程序的全部流程，不难 对吗？

深度优先算法

过程

我们测试每一个点，如果当前位置在终点位置上，那么我们就直接结束程序。或者我们就来计算下一个点的坐标。下一个点的坐标可以是右边的、下边的、左边的、上边的、（东南西北），我们在这里用一个next二维数组来处理，如果是下一个点是邻接的右边的点，那么y坐标不变，x坐标+1， 所以在next数组里面对应的是{0, 1} ( {y, x} ) 这样。

在后面用for循环遍历每一种情况的时候，会用到这个next数组。

代码

void go_through(WINDOW *w, Person *p)
{

    int cy, cx;
    int ny, nx;

    if ( p->y == 2 && p->x == 29) 
    {
        attron(A_REVERSE);
        mvwprintw(stdscr,  (LINES-15)/2 + 4 + 6, (COLS-50)/2 - 20 + 60, "    DONE   ");
        attroff(A_REVERSE);
        wrefresh(stdscr);
        wrefresh(stdscr);
        getchar();
        endwin();
        exit(0);
    }
    int next[4][2] = 
        {
            {0, 1},
            {1, 0},
            {0, -1},
            {-1, 0},
        };



    for (int i = 0; i < 4; ++i) 
    {
        // 计算下一个点的坐标
        ny = p->y + next[i][0]; 
        nx = p->x + next[i][1];

        // 保存当前坐标
        cy = p->y;
        cx = p->x;

        // 如果下个坐标值非法（越界），那么就跳过这个尝试
        // 在这里，每个循环代表的是每个方向上的尝试
        if (ny > 10 || ny < 0 || nx > 29 || nx < 0)
        {
            continue;
        }

        // 如果下一个坐标没有走过，并且不是墙
        if (book[ny][nx] == 0 && myth[ny][nx] != ‘*‘)
        {
            // 标记走过了这个点
            book[ny][nx] = 1;
            // 移动Person p走到这个点
            moveTo(w, p, ny, nx);
            // 睡100毫秒
            usleep(100000);
            // 以新的点作为起点进行尝试， 这就是递归算法。
            go_through(w, p);
            // 尝试结束后（可能是尝试失败的情况下）, 退回来。 在for循环的下一次循环中尝试其他方向
            moveTo(w, p, cy, cx);
            // book[ny][nx] = 0;
        }
    }

    return ;

}

总结

学习算法总是： 纸上得来终觉浅， 绝知此事要躬行。 另外，这个程序只是寻找一条路，而不是寻找最短路径。