【LeetCode】最短路径条数问题（BFS)

【分析】
这是权值相同的最短路径问题，即单源点Dijkstra算法退化为BFS（广度优先搜索）。
假定起点为0，终点为N

【思路】
step[i]:到达某点的最短路径的步数，如k点：step[9] = 3;
pathNum[i]:最短路径的条数，如k点：pathNum[9] = 2;
pathNum[0] = 1:自己不动就是一种路径的选择

假设当前节点为F，①若邻结点K处，step[j] = 0（初始化的值），说明这个点还未走到过。则i（F）结点就是j（K）结点的第一个发现者。则对于K来说，到达K（j）结点的最短路径为：到达(i)结点的最短路径步长+1，即step[j] = step[i]+1； 同时，从A->F(i)的最短路径条数 一定也等于 A->K(j)的最短路径条数，即pathN[i] = pathN[j]
②若第j个结点曾经走到过，即step[j]的值不为初始化的0，而等于step[i]+1（即执行过步骤①），则
A->j的最短路径条数 为之前走过时的pathN[j]+pathN[i]
即：若step[j] == step[i]+1,即之前走到过j结点，故当前step[j]与之前所赋值的step[i] +1相同（保持不变），但这是一个新路径（与第一次走到该点的路径不同），故最短路径条数在原有的基础上，再加上当前路径的pathN[i]（与第一次的pathN[i]不同。），即pathN[j] += pathN[i]；

代码实现：
（C++）（完整AC）

#include "stdafx.h"
#include <iostream>
#include <queue>
#define N 16 //宏替换不可加分号！ 图的x、y坐标：0~15, 共16个！！！
using namespace std;

int Calc(int G[N][N]) 
{
    int step[N];//每个结点的步长,一共15个结点
    int pathN[N];//到每个结点的最短路径条数
    memset(step, 0, sizeof(int)* N);//将两数组中的元素初始化为0
    memset(pathN, 0, sizeof(int) * N);
    pathN[0] = 1;//在起点不移动也是一种路径选择。
    queue<int> q;//当前搜索的节点
    q.push(0);
    int from, i, stepLen;//stepLen:当前的步长
    while (!q.empty()) {
        from = q.front();
        q.pop();//最终需要将q
        stepLen = step[from] + 1;
        //遍历当前结点from的所有可能路径.
        for (i = 1; i < N; i++) {//注意！！！0是起点，不遍历，否则会死循环！！！
            if (G[from][i] == 1) {//当前结点（from）到i可通行
                //若i之前未走过 或发现更快的路（权值不同才行，此题不可能，因为图G中所有的通路权值均为1）
                //则将当前step[i]设为step[from]+1,即stepLen; pathN[from]与当前pathN[i]是同一路径。
                if ((step[i] == 0) || (step[i] > stepLen) ) {
                    step[i] = stepLen;
                    pathN[i] = pathN[from];
                    q.push(i);//将当前的最短路径新结点放入队列q

                }
                else if(step[i] == stepLen)//之前走到过 && 相同长度的（最短）路径
                {
                    pathN[i] += pathN[from];

                }
            }
        }

    }
    return pathN[N - 1];//返回从起点到终点处所有最短路径的条数
}

int main()
{
    int G[N][N];
    memset(G, 0, sizeof(int)* N * N);//将图中所有结点的初值设为0
    G[0][1] = G[0][4] = 1;//将所有连通路径初值设为1
    G[1][5] = G[1][2] = G[1][0] = 1;
    G[2][1] = G[2][3] = G[2][6] = 1;
    G[3][2] = G[3][7] = 1;
    G[4][0] = G[4][5] = 1;
    G[5][4] = G[5][1] = G[5][9] = G[5][6] = 1;
    G[6][2] = G[6][5] = G[6][7] = G[6][10] = 1;
    G[7][3] = G[7][6] = 1;
    G[8][9] = G[8][12] = 1;
    G[9][8] = G[9][13] = G[9][10] = 1;
    G[10][9] = G[10][14] = G[10][11] = 1;
    G[11][10] = G[11][15] = 1;
    G[12][8] = G[12][13] = 1;
    G[13][9] = G[13][14] = G[13][12] = 1;
    G[14][13] = G[14][10] = G[14][15] = 1;
    G[15][11] = G[15][14] = 1;

    cout << Calc(G) << endl;
    return 0;
}