利用BFS求最短路

利用BFS求图的最短路,

POJ3984

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 5;

struct Node {
    int x, y;
    Node(int a=0, int b=0) :x(a), y(b) {}
};//node表示一个点，x为x坐标，y为y坐标
int G[maxn][maxn];//G存储的是迷宫的信息，0为障碍物
int dis[maxn][maxn];//到起点的距离
Node path[maxn][maxn];//存储此节点的“父亲”

const int dir[4][2] = { { 0, 1 }, { 0, -1 }, { -1, 0 }, { 1, 0 } };
bool isleg(int x, int y)
{
    return ( x>=0 && y >= 0 && x < maxn&&y < maxn
             && dis[x][y] == -1 && !G[x][y] );//dis[x][y]==-1表示未经过此点
}
void bfs()
{
    queue<Node>Q;
    Q.push(Node(0, 0));
    memset(dis, -1, sizeof(dis));
    dis[0][0] = 0;
    while (!Q.empty()) {
        Node u = Q.front();
        Q.pop();
        for (int i = 0; i < 4; i++) {
            int dx = u.x +dir[i][0];
            int dy = u.y + dir[i][1];
            if (isleg(dx, dy)) {
                dis[dx][dy] = dis[u.x][u.y] + 1;//
                path[dx][dy] = u;
                Q.push(Node(dx, dy));
            }
        }
    }
}
void printPath(Node u)
{
    if (!u.x&&!u.y) {
        printf("(0, 0)\n");
        return;
    }
    printPath(path[u.x][u.y]);
    printf("(%d, %d)\n", u.x, u.y);
}
int main()
{
    int i, j;
    for (i = 0; i < maxn; i++)
        for (j = 0; j < maxn; j++)
            scanf("%d", &G[i][j]);
    bfs();
    printPath(Node(4, 4));//递归打印路径
    return 0;
}

在这里,BFS求出了每个点到起点的最短距离

注意, 只要"某个点到起点的距离"从初始状态被赋值, 那么这个值就是最优的, 因为可以把BFS之后的图看为是一个BFS树, 某点的所在的"层数"就是其到起点的距离, 当其被BFS第二次的时候的"层数"一定 大于或等于 第一次的"层数", 即离起点更远了