Description

给出一个图的邻接矩阵，再给出指定顶点v0，求顶点v0到其他顶点的最短路径

Input

第一行输入t，表示有t个测试实例

第二行输入n，表示第1个图有n个结点

第三行起，每行输入邻接矩阵的一行，以此类推输入n行

第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开

第四行输入v0，表示求v0到其他顶点的最短路径距离

以此类推输入下一个示例

Output

每行输出v0到某个顶点的最短距离和最短路径

每行格式：v0编号-其他顶点编号—-[最短路径]，具体请参考示范数据

Sample

#0

Input

Copy

1
5
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0

Output

Copy

0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]

dijkstra求单源最短路径：

可以先参考这篇文章，单纯的dijkstra算法求最短距离，还不用记录路径

        tips：本题要记录最短路径所经过的点

以起点 A 通往前一个点 B 的最短路径+前一个点 B 到下一个点 C 的路径与 现有的A通到C的路径距离相比较求一个最短的路劲。（这里可能不是太理解，请往下看）
首先先知道一个算法里面一个重要的东西 dis[] 数组，他的意思是起点到终点的距离
设起点为 0 
dis[0],起点 0 到 0 的最短距离
dis[1],起点 0 到 1 的最短距离
dis[2],起点 0 到 2 的最短距离

这里与开头说的联系；
假设 0 到 2 存在一条路距离为10 ，0 到 1 存在一条路距离为2 ，1到2存在一条路距离为3

dis[0]=0
dis[1]=2

此时 0 到 1 的路径是 0-1
然后最开始以 2 为前一个出发点，那到达  2  的最短距离已知的是不是10,dis[2]=10

此时 0 到 2 的路径是 0-2
然后 1 为中转点到达 2 的时候，到达2的距离是不是 到达 1 的距离+ 1 到 2的距离dis[1]+1->2=5
此时dis[1]+3<dis[2]=10
所以dis[2]更新为dis[2]=dis[1]+3

此时路径我们发现 0-2 走的路径比 0-1-2 走的长，所以我们就更新路径
所以 0 到 2 的最短路径为 0-1-2

路径：

起点 0 到 1，最短路径就是 0-1

起点 0 到 2，最短路径就是 0-1-2
起初我们记录的 0 到 2的路径是 0-2，但是我们发现走 0-1-2这条路更近，所以取而代之 

样例（自己出的样例跑一遍）

tips:这里我们记录start到dis[i]的最短路径是不包括i本身的
例如：A到C的最短路径是A-B-C，那我们记录的就只有A-B

dis[A]=无穷大 dis[B]=无穷大 dis[C]=无穷大，dis[D]=无穷大
本题设置A为起点
图如下：

令dis[]都为无穷大

令起点到自己为0，因为自己到自己距离为0嘛

然后dis[]数组中dis[A]是最小的，且没有被作为中转点走过，所以设A为中转点，然后遍历A可以到达的边。这里可以理解为A-A(中转点)-目标点
A可以到达B，C两点，且A到B，C的距离小于无穷大，所以更新起点A到B，C的最短距离为
dis[B]=2,dis[C]=3

此时A到B的最短路径为A
此时A到C的最短路径为A

✔的意思是这个点已经被作为中转点走过了

然后找未被作为起始点且起点到他的距离最短，找到B，因为dis[B]=2,dis[C]=3,dis[A]=0但是A已经作为中转点走过了。
B可以到达D点，
起初dis[D]=无穷大，意思为A到D的最短距离为无穷
现在D的路径有从B到D，他的距离为起点A到达B的最短距离+BD路径的距离
dis[B]+BD=12<无穷大
所以dis[D]=12

此时A到D的最短路径为A-B

然后继续重复步骤
此时没有被走过的点是C，D.dis[C]=3,dis[D]=12
1.C可以到达B
起点A到C的最短距离+CB为B的新一条路距离>dis[B]的前一个路径，即起点A到B的最短路径
dis[C]+CB=8 > dis[B]=2
所以不用更新dis[B]
2.C可以到达D
起点A到D的最短距离+CD为D的新一条路距离<dis[D]的前一个路径，即起点A到D的最短路径
dis[C]+CD=9 > dis[B]=12
所以需要更新起点A到D的最短距离dis[D]=9

此时A到D的路径 A-B的长度大于走A-C的长度
所以更新D的路径为A-C

tips:更新的方法是我们前面已经保存了A到C的路径（不包括C自己），就是路径A，那我们是不是在路径A里面加入要走的C就可以了，就是A-C

最后以D为中转点走，即A到D的最短路径 出发去别的点，但是已经没有D可以到达的点了，所以就结束了

最后得到起点A到别的点的距离
dis[A]=0
dis[B]=2
dis[C]=3
dis[D]=9

最后我们start到各点的最短路径是：

B:A
C:A
D:A-C

最后我们输出实际路径的时候输出完路径再输出终点本身就好了

更新路径的写法：

为什么要清除之前的路径呢。

就比如 A-B-C-D要走10m
但是     A-E-F-D要走5m
那你的最短路径是不是从A到C的最短路径+D变成A到E的最短路径+D
那就把A到C的路径删掉，然后换成A到F的最短路径然后+D

tips：本人写法的最短路径是不包括其本身的
所以A到C的最短路径就是A-B，A到F的最短路径是A-E
所以A到D更新前的路径是A-B-C
更新后的是A到F的最短路径A-E加上F，就是A-E-F

enmmm，意思是到end之前最短路径所经过的点，就是不包括end。
那我求end的最短路径是不是end-1之前最短路径所经过的点加end-1这个点

具体代码实现：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string.h>
using namespace std;
int t, n, start;
const int maxn = 2e3 + 10;
int dp[maxn][maxn];//建立的邻接矩阵数组
vector<int>p[maxn];///二维动态数组，记录p[i],起点start到i所需要经过的路径
int vis[maxn];///判断这个点是否有被中转过
int dis[maxn];///dis[i]，表示起点start到终点i的最小距离
void irit()
{
    for (int i = 0; i < n; i++)
    {
        vis[i] = 0;///初始化都没有被作为中转点过
        dis[i] = 0x3f3f3f;///初始化全都是无穷大，start到i的最短距离为无穷大
    }
}
void dijkstra()
{
    dis[start] = 0;///start到start自己的最短距离是0
    for (int i = 0; i < n; i++)///  总共需要n个中转点，次数也是n就够了
    {
        int minm = 0x3f3f3f, pre = 0;///
        for (int j = 0; j < n; j++)///遍历所有dis[],找最小距离的点且没有被作为中转点走过的点
        {
            //vis[k]=0即没有被作为中转点，dis[k]即比较dis距离找距离最小的点
            if (!vis[j] && dis[j] < minm)
            {
                minm = dis[j];//更新最短距离
                pre = j;//找距离最小的点
            }
        }
        vis[pre] = 1;///将这个点设置为已经被中转过了
        for (int j = 0; j < n; j++)///找这个中转点可以到达的k点，如果起点到K的距离小于通过中转点到K的距离就不用更新
        {
            ///如果起点到K的距离大于通过中转点到K的距离就需要更新
            ///dp[j][k]，j到k是否存在边
       
            if (dp[pre][j] != 0 && dis[j] > dis[pre] + dp[pre][j])
            {
                dis[j] = dis[pre] + dp[pre][j];
                int len = p[pre].size();
                p[j].clear();///把到j的前一个路径清除
                for (int k = 0; k < len; k++)///将start到pre的路径复制下来
                {
                    p[j].push_back(p[pre][k]);
                }
                p[j].push_back(pre);///然后加入pre点
            }

            ///这么干的原因是，上一条路径的长度走的比经过pre中转的点长
            ///那我们就走pre走过的点作为路径，不是比前一条路更短吗
        }
    }
}
int main()
{
    cin >> t;
    while (t--)
    {
        cin >> n;
        irit();
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                cin >> dp[i][j];//构建邻接矩阵
            }
        }
        cin >> start;///输入起点
        dijkstra();
        for (int i = 0; i < n; i++)
        {
            if (i == start)
                continue;
            cout << start << "-" << i << "-" << dis[i] << "----";
            cout << "[";
            int len = p[i].size();
            for (int j = 0; j < len; j++)///输出到j所走过最短路径的点，这个点是不包括他自身的
            {
                cout << p[i][j] << " ";
            }
            cout << i << " ]" << endl;///输出j自身
        }
    }
    return 0;
}

---

就写到这吧，跟我的追星dijkstra追星还是不说一模一样但也十有八九
原理其实是一样的，但是重要的是掌握我的路径数组的意思，是不包括最后终点自身的

幸苦大家看这么多字了！

夜深了，晚安各位！！！！(￣o￣) . z Z