迷宫出口以及迷宫最短路径的求解

原创 2017年04月20日 15:36:57

整理出来方便大家复习

//完成迷宫
#pragma warning (disable:4996)
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
#include<assert.h>


//创建迷宫->动态创建二维数组:1.int[][N]  2.int*->(二维数组是按照一维数组来存储的)
//打印迷宫
//走迷宫

const size_t N = 10;//定义全局变量N

struct Pos
{
    int _row;
    int _col;
};

//思考:三元组->适合适合什么问题?迷宫?二维数组?
void InitMaze(int maze[][N])
{
    FILE*fout = fopen("MazeMap.txt", "r");
    assert(fout);

    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N;)
        {
            //获取文件中的字符用fgetc()

            char ch = fgetc(fout);
            if (ch == '0' || ch == '1')//因为在文件中保存,所有数字均为字符数字
            {
                maze[i][j] = ch-'0';
                ++j;
            }

        }

    }
}


void PrintMaze(int maze[][N])
{
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {

            cout << maze[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

}


bool CheckAccess(int maze[][N], Pos tmp)
{
    if (tmp._row >= 0 && tmp._row < N
        &&tmp._col >= 0 && tmp._col < N
        &&maze[tmp._row][tmp._col] == 0)
    {
        return true;
    }

    return false;

}

//获取迷宫路径
void GetMazePath(int maze[][N], Pos entry)
{

    //回溯法->将路径压入栈
    //试探法,对每个方向进行试探一下

    stack<Pos>path;
    path.push(entry);

    while (!path.empty())
    {
        Pos cur = path.top();
        Pos next = cur;

        if (cur._row == N - 1)
        {
            break;
        }

        //试探法,对每个方向进行试探一下
        //上方  
        next._row--;
        if (CheckAccess(maze,next))
        {
            maze[next._row][next._col] = 2;
            path.push(next);
            continue;
        }

        next = cur;
        //右方
        next._col++;
        if (CheckAccess(maze, next))
        {
            maze[next._row][next._col] = 2;
            path.push(next);
            continue;
        }

        next = cur;

        //下方  
        next._row++;
        if (CheckAccess(maze, next))
        {
            maze[next._row][next._col] = 2;
            path.push(next);
            continue;
        }

        next = cur;

        //右方
        next._col--;
        if (CheckAccess(maze, next))
        {
            maze[next._row][next._col] = 2;
            path.push(next);
            continue;
        }

        //四个方向都走不通-》回溯法

        maze[cur._row][cur._col] = 3;

        path.pop();
    }

}



//求迷宫最优解:-》 


//考虑两个问题:1.怎么标记的,还走回去?
//2.递归怎么解决子问题
//思路:肯定要把每个出口进行遍历,比较出一条最短的路径来

bool CheckAccess(int maze[][N],size_t n, Pos next,Pos cur)
{
    if (next._row >= 0 && next._row < n
        &&next._col >= 0 && next._col < n)
    {
        if (maze[next._row][next._col] == 0 || maze[next._row][next._col]>maze[cur._row][cur._col])
        {
            return true;
        }
    }

    return false;

}


bool GetMazePathR(int maze[][N], size_t n,Pos cur,stack<Pos>&shortPath,stack<Pos>&path)
{
    path.push(cur);

    if (cur._row == n - 1)
    {
        if (shortPath.empty() || path.size() < shortPath.size())
        {
            shortPath = path;
        }

        //return true;//一旦找到路径就结束
    }

    Pos next = cur;

    //四个方向进行检测
    next._row++;

    if (CheckAccess(maze,n,next,cur))
    {
        maze[next._row][next._col] = maze[cur._row][cur._col] + 1;

        if ( GetMazePathR(maze, n, next, shortPath, path))
        {
            return true;

        }

    }

    next = cur;
    next._col++;

    if (CheckAccess(maze, n,next,cur ))
    {
        maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
        if (GetMazePathR(maze, n, next, shortPath, path))
        {
            return true;
        }

    }

    next = cur;
    next._row++;

    if (CheckAccess(maze, n,next,cur ))
    {
    maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
    if (GetMazePathR(maze, n, next, shortPath, path))
    {
        return true;

    }

    }

    next = cur;
    next._row--;
    if (CheckAccess(maze, n,next,cur ))
    {
    maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
    if (GetMazePathR(maze, n, next, shortPath, path))
    {
        return true;

    }

    }
    path.pop();//退到上一个路径上
    return false;

}




int main()
{
    int maze[N][N];
    InitMaze(maze);
    PrintMaze(maze);

    Pos entry = { 1,0 };
    //GetMazePath(maze, entry);
    //PrintMaze(maze);


    stack<Pos>path;
    stack<Pos>shortPath;
    GetMazePathR(maze,N,entry,shortPath,path );
    PrintMaze(maze);


    return 0;
}

迷宫通路:
这里写图片描述
迷宫最优解:
这里写图片描述

版权声明:惜不吝赐教,欢迎指点。

相关文章推荐

BFS求解迷宫最短路径

本文使用BFS广度优先搜索算法实现求解迷宫的最短路径(C++),使用到了队列先进先出的性质,依次搜索路径直到找到目标出口(如果迷宫能走通)求解到的路径即为该迷宫的最短路径,本文使用vexmap一个ma...

迷宫求解最短路径问题java版

对于计算,面对错乱复杂的迷宫探路问题也不可能一步就找到最优路径,而是把所有可行路径全部走过然后通过比较找出最优路径,对于每走一步都有4个可行方向可走,然后通过循环借助计算机的高效率找出最优路径。代码如...

AStar算法求解迷宫最短路径问题

我这个仅针对7行7列的迷宫写的,写的比较急,要计算n行m列的迷宫稍微改下就行了 代码如下,若有不妥请高手指点: #include #include #include #include ...

递归和栈求解迷宫的最短路径

采用递归的方式求最短路径 1、用一个栈专门用来保存有效的路径 2、再用一个栈来辅助保存所有走过的路径。 3、然后再用一个栈用来保存最短的路径 4、如果每次找到了出口,那么必然有两个栈一个保存了...

迷宫最短路径问题(ShortestPath)的求解——利用链式队列

迷宫最短路径问题(ShortestPath)的求解——利用链式队列 注:借助于栈求解迷宫问题时,并不能保证找到一条从迷宫入口到迷宫出口的最短路径。而借助于队列,可以找到从迷宫入口到迷宫出口的最短路径...

迷宫最短路径

  • 2013-06-24 11:44
  • 26KB
  • 下载

迷宫的最短路径实现

BFS 迷宫的最短路径

迷宫的最短路径 给定一个大小为N*M的迷宫。迷宫由通道和墙壁组成,每一步可以  向邻接的上下左右四个方位的通道移动,请求出从起点到终点所需的最小不熟。 此题假设一定能从起点到终点 ...
  • SY_Yu
  • SY_Yu
  • 2016-01-08 21:52
  • 276

迷宫 最短路径

内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)