迷宮問題思路

根據昨天的博客，有如下幾種解決方案

1. 克魯斯卡爾 ，為避免死迴圈，需要設定優化路徑的次數。
2. Prim，為避免死迴圈，需要設定優化路徑的次數，暫定200次。
3. BFS ， 實現簡單，無死迴圈。
4. DFS , 實現簡單，無死迴圈，複雜度較低。
5. 動態規劃，實時根據權重調整方向，目前看來最合適的解決方案。需要以數據證明。

綜上，本次優先選擇BFS，首先不存在死迴圈的風險，其次演算法複雜度較低，容易理解且實現。適合初步練手。

一. 思路及程式演算法

首先建立迷宮，將其看作點位矩陣，先把牆堆起來，剩下的就是路。

而每個點都有四個方向（上、下、左、有），每個方向上都對應一個點。在這四個點中，有一個點是當前站立點的“上一個點”，另外三個點是當前站立點的“下一個點”，如圖1.1所示，紅色框為當前站立點，藍色框為“上一個點”，黃色框為三個“下一個點”。

圖1.1站立點的四個方向

當前站立點有三種狀態，分別是“終點”、“通路”和“死路”。如果當前站立點是“終點”，則停止搜索；如果當前站立點是“通路”，則向下繼續走；如果當前站立點是“死路”，則要向回走，然後搜索其它路徑。其流程如圖1.2所示。

圖1.2判斷迷宮路徑流程圖

二. 實現

實現效果如圖2.1所示：

圖2.1 BFS迷宮求解實現圖

BFS迷宮求解實現代碼如下：

#include <bits/stdc++.h>
using namespace std;
#define coordi(x,y) ( m*(x-1)+y )
const int maxn = 30;
const int dx[] = {0,0,1,-1};
const int dy[] = {1,-1,0,0};

int mp[maxn+10][maxn+10];
int nxtx[maxn+10][maxn+10];
int nxty[maxn+10][maxn+10];
bool vis[maxn+10][maxn+10];
int fa[(maxn+10)*(maxn+10)];
int n , m;
int stx , sty , edx , edy;

inline int check( int x , int y )
{
    return 1<=x && x<=n && 1<=y && y<=m;
}
inline void print_map()
{
    puts("\n==============================================");
    for( int i = 1; i <= n; i++ )
    {
        for( int j = 1; j <= m; j++ )
            printf("%c",mp[i][j]);
        putchar('\n');
    }
    puts("==============================================");
}
// 並查集
int getfa( int x )
{
    return x==fa[x]?x:fa[x] = getfa(fa[x]);
}
void unio( int a , int b )
{
    int fx = getfa(a) , fy = getfa(b);
    if ( fx != fy ) fa[fx] = fy;
}
// 並查集

void connect()
{
    int t = n*m/3*2;
    for( int i = 1; i <= n*m; i++ ) fa[i] = i;
    int fs = getfa(coordi(stx,sty)) , ft = getfa(coordi(edx,edy));
    while( fs != ft || t > 0 )
    {
        t--;
        int px = rand()%n+1 , py = rand()%m+1;
        if ( mp[px][py] == 'X' )
        {
            mp[px][py] = '.';
            for( int k = 0 ; k< 4; k++ )
            {
                int xx = px + dx[k] , yy = py + dy[k];
                if ( check(xx,yy) && mp[xx][yy] != 'X' ) unio( coordi(px,py) , coordi(xx,yy) );
            }
        }
        fs = getfa(coordi(stx,sty)) , ft = getfa(coordi(edx,edy));
    }
}

void init()
{
    srand(time(0));
    n = rand()%maxn+10;
    m = rand()%maxn+10;
    cout<<"map size : "<<n<<" * "<<m<<endl;
    for( int i = 1; i <= n; i++ )
        for( int j = 1; j <= m; j++ ) mp[i][j] = 'X';
    stx = rand()%n+1 , sty = rand()%m+1;
    edx = rand()%n+1 , edy = rand()%m+1;
    while( abs(edx-stx) + abs(edy-sty) <= 1 ) edx = rand()%n+1 , edy = rand()%m+1;
    mp[stx][sty] = 'S' , mp[edx][edy] = 'T';
    cout<<"start:("<<stx<<","<<sty<<")"<<endl;
    cout<<"end:("<<edx<<","<<edy<<")"<<endl;
    connect();
    print_map();
}

void print_path() // path = '*'  st = S , ed = T   ,  road = . , wall =  X
{
    int x = edx , y = edy;
    while( !( x == stx && y == sty ) )
    {
        mp[x][y] = '*';
        int tx = nxtx[x][y];
        y = nxty[x][y];
        x = tx;
    }
    mp[edx][edy] = 'T';
    print_map();
}

void bfs()
{
    queue< pair<int,int> > q;
    q.push( make_pair(stx,sty) );
    memset(vis,0,sizeof(vis));
    vis[stx][sty] = true;
    while( !q.empty() )
    {
        pair<int,int> temp = q.front();
        q.pop();
        if ( temp.first == edx && temp.second == edy )
        {
            print_path();
            return;
        }
        for( int k = 0; k < 4; k++ )
        {
            int xx = temp.first + dx[k] , yy = temp.second + dy[k];
            if ( !check(xx,yy) || vis[xx][yy] || mp[xx][yy] == 'X' ) continue;
            vis[xx][yy] = 1 , nxtx[xx][yy] = temp.first , nxty[xx][yy] = temp.second;
            q.push( make_pair(xx,yy) );
        }
    }
}

int main()
{
    init();
    bfs();
    return 0;
}