利用图的宽度优先搜索（层次遍历）实现查找从迷宫左上

　　
　　// 查找从迷宫左上角到右下角的最优路径（路径最短）
　　// 利用图的宽度优先搜索（层次遍历）实现
　　int SearchMaze(int *A, int m, int n, vector &path)
　　{
　　    // 迷宫位置类型
　　    typedef pair Position;
　　
　　    // 移动操作类型
　　    typedef unsigned char MoveType;
　　    const MoveType UNVISITED = 'N';       // 未访问
　　    const MoveType START = 'S';           // 起点
　　    const MoveType UP = 'U';              // 向上
　　    const MoveType RIGHT = 'R';           // 向右
　　    const MoveType DOWN = 'D';            // 向下
　　    const MoveType LEFT = 'L';            // 向左
　　
　　    // 用于暂存位置的队列
　　    queue posQueue;
　　
　　    // 标记，用于区分层次遍历的各层，以便计算路径长度
　　    Position tag(-1, -1);
　　    // 目标位置
　　    Position target(m - 1, n - 1);
　　
　　    // 状态数组，用于记录迷宫的每个位置是否已经访问
　　    vector state(m * n, UNVISITED);
　　
　　    // 标记能否到达目标位置
　　    bool succeed = false;
　　
　　    // 把起始位置压入队列，开始搜索
　　    posQueue.push(make_pair(0, 0));
　　    posQueue.push(tag);
　　    int pathLength = 1;
　　    state[0] = START;
　　   
　　    // 搜索目标位置
　　    while (!posQueue.empty()) {
　　        Position cur = posQueue.front();
　　        posQueue.pop();
　　
　　        if (cur == target) {
　　            // 找到目标位置
　　            succeed = true;
　　            break;
　　        }
　　
　　        if (cur == tag) {
　　            // 本层遍历结束，进入下一层
　　            if (!posQueue.empty()) {
　　                ++pathLength;
　　                posQueue.push(tag);
　　            }
　　            continue;
　　        }
　　
　　        // 从当前位置向上、下、左、右搜索
　　        int i = cur.first;
　　        int j = cur.second;
　　        int index;
　　
　　        // 向上
　　        index = (i - 1) * n + j;
　　        if (i > 0 && A[index] == 0 && state[index] == UNVISITED) {
　　            posQueue.push(Position(i - 1, j));
　　            state[index] = UP;
　　        }
　　
　　        // 向右
　　        index = i * n + j + 1;
　　        if (j < n - 1 && A[index] == 0 && state[index] == UNVISITED) {
　　            posQueue.push(Position(i, j + 1));
　　            state[index] = RIGHT;
　　        }
　　
　　        // 向下
　　        index = (i + 1) * n + j;
　　        if (i < m - 1 && A[index] == 0 && state[index] == UNVISITED) {
　　            posQueue.push(Position(i + 1, j));
　　            state[index] = DOWN;
　　        }
　　
　　        // 向左
　　        index = i * n + j - 1;
　　        if (j > 0 && A[index] == 0 && state[index] == UNVISITED) {
　　            posQueue.push(Position(i, j - 1));
　　            state[index] = LEFT;
　　        }
　　    }
　　
　　    if (succeed) {
　　        // 能够到达目标位置，输出移动操作序列
　　        path.clear();
　　        path.reserve(pathLength);
　　
　　        int i = m - 1;
　　        int j = n - 1;
　　        int index = i * n + j;
　　        for (; state[index] != START; index = i * n + j) {
　　            assert(state[index] != UNVISITED && "不可能是未访问位置！");
　　            path.push_back(state[index]);
　　            switch (state[index])
　　            {
　　            case UP:
　　                ++i;
　　                break;
　　
　　            case RIGHT:
　　                --j;
　　                break;
　　
　　            case DOWN:
　　                --i;
　　                break;
　　
　　            case LEFT:
　　                ++j;
　　                break;
　　            }
　　        }
　　        reverse(path.begin(), path.end());
　　
　　        return pathLength;
　　    }
　　
　　    return -1;
　　}
　　
　　int main()
　　{
　　    const int m = 8;
　　    const int n = 8;
　　    int A[m * n] = {
　　        0, 0, 0, 0, 1, 0, 0, 0,
　　        1, 0, 1, 0, 0, 0, 1, 0,
　　        0, 0, 1, 0, 1, 0, 1, 0,
　　        0, 1, 1, 0, 0, 0, 1, 0,
　　        0, 0, 0, 0, 1, 1, 0, 0,
　　        0, 1, 1, 0, 0, 0, 0, 1,
　　        0, 0, 0, 0, 1, 0, 1, 1,
　　        1, 0, 0, 0, 1, 0, 0, 0,
　　    };
　　
　　    vector path;
　　
　　    int length = SearchMaze(A, 8, 8, path);
　　
　　    if (length > 0) {
　　        cout << "Shortest path length: " << length << endl;
　　        cout << "The Path: ";
　　        copy(path.begin(), path.end(), ostream_iterator(cout));
　　        cout << endl;
　　    } else {
　　        cout << "Can't reach the destination!" << endl;
　　    }
　　
　　}