前言
王国维《人间词话》中曾提出，古今之成大事业者，须经过三重境界。这三重境界体现的正是儒家精神，所以正是路径所在。
第一重境界是“昨夜西风凋碧树，独上高楼，望尽天涯路”。登上高楼，远眺天际，正是踌躇满志，志存高远，高瞻远瞩，一腔抱负。人生，志向决定方向，格局决定高度；小溪只能入湖，大河则能入海。所以做事，要先立心中志向；成事，要先拓胸中格局。
第二重境界是“衣带渐宽终不悔，为伊消得人憔悴”。事情是需要去做才能成的，成越大的事业，需要越大的努力和付出，甚至要经受越大的磨难和困苦。这个世间，从来都是“艰难困苦，玉汝于成”；所以无论如何，都要“天行健，君子以自强不息”。
第三重境界是“众里寻她千百度，蓦然回首，那人却在，灯火阑珊处”。这说的是历经磨难而逐渐成熟、成长，最终豁然贯通、水到渠成。这其中蕴含一个重要道理，就是苏东坡所说的“厚积而薄发”。只有厚积才能薄发，人要做的，就是不断厚积，等待薄发。这就是拿得起的完整路径，也是事业成功的完整过程。
刚好Dijkstra算法也可以借用三重境界。
思想
Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T
1.初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。
2.从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，此时完成一个顶点，
3.继续从dis数组选择最小值，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。
4.重复上述动作，直到T中包含了图的所有顶点。
算法演示
这张图就是一个Dijkstra算法的过程，1为根节点start
1.此时集合内只有1节点 最短距离为1~2的距离7，把2加入集合，更新1-2距离
2.此时集合内有1，2节点，最短距离为1~3的距离9，把3加入集合，更新1-3距离
3.此时集合内有1，2，3节点，最短距离为3~6的距离2，把6加入集合，更新1-6距离
4.此时集合内有1，2，3，6节点，最短距离为3~4的距离11，把4加入集合，更新1-4距离
5.最后，最短距离为6~5的距离9，更新1-5距离，结束
三个代码模板
步入正轨，既然说了有三重境界，那肯定有三个代码。
代码1，实现并打印出路径
打印路径这里，新建一个数组p记录路径整合的节点，利用栈的性质打印出路径
#include <bits/stdc++.h>
using namespace std;
const int MAX_CITY_NUM = 100;//节点数目的最大值
const int MAX_POLICY = 1e7;//节点权值的最大值
int mp[MAX_CITY_NUM][MAX_CITY_NUM];
int dist[MAX_CITY_NUM];//源点到其他节点的距离
int p[MAX_CITY_NUM];//记录路径
int n, m;
bool flag[MAX_CITY_NUM];
void dijkstra(int start)
{
for (int i = 1; i <= n; ++i)//初始化
{
flag[i] = false;
dist[i] = mp[start][i];
if (dist[i] != MAX_POLICY)
{
p[i] = start;
}
else
{
p[i] = -1;
}
}
flag[start] = true;
dist[start] = 0;
for (int i = 1; i <= n; ++i)
{
int min_dist = MAX_POLICY, t = start;
for (int j = 1; j <= n; j++) //找到最小权值
{
if (dist[j] < min_dist && !flag[j])
{
min_dist = dist[j];
t = j;
}
}
if (t == start) return;//标记退出循环
flag[t] = true;
for (int j = 1; j <= n; j++)//记录最小边
{
if (mp[t][j] < MAX_POLICY && !flag[j])
{
if (dist[j] > (dist[t] + mp[t][j]))
{
dist[j] = dist[t] + mp[t][j];
p[j] = t;
}
}
}
}
}
void showProcess(int start)//利用栈的性质 输出路径
{
int value;
stack<int> stack;
for (int i = 1; i <= n; ++i)
{
value = p[i];
cout << start << "到"<< i << "的路径是";
while (value != -1)
{
stack.push(value);
value = p[value];
}
while (!stack.empty())
{
int node = stack.top();
stack.pop();
cout << node << "-";
}
if(dist[i]==MAX_POLICY)
{
cout<< i <<" "<< "最短距离为" << "无穷大" <<endl;
}
else cout<< i <<" "<< "最短距离为" << dist[i] <<endl;
}
}
int main()
{
int u, v, w, start;
cin >> n;
cin >> m;
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= n; ++j)
{
mp[i][j] = MAX_POLICY;
}
}
for (int i = 0; i < m; ++i)
{
cin >> u >> v >> w;
mp[u][v] = min(mp[u][v], w);
}
cin >> start;
dijkstra(start);
showProcess(start);
return 0;
}
代码2 堆优化邻接矩阵存图
想优化时间效率，别急，既然我们每次都是找与集合最小的，那么就出现了优先级，可以使用优先队列来优化
#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f //定义一个很大的数
struct Node
{
int num,val; //存放结点编号和到初始点的距离
}nod;
priority_queue<Node> qq;; //优先从小到大
bool operator < (Node a,Node b)
{
if(a.val == b.val) return a.num>b.num;
return a.val>b.val; //先出小
}
int book[100]; //检查这个点是否用过
int dis[100]; //到原点最短距离
int D[100][100]; //记录路径长度
int V,E;
int start;
int main()
{
int a,b,d;
cin>>V>>E; //输入顶点数和边数
//while(!qq.empty()) qq.pop(); //清空
memset(book,0,sizeof(book));
memset(D,-1,sizeof(D));
for(int i=0;i<E;i++)
{
cin>>a>>b>>d;
D[a][b] = d;
}
cin>>start;
for(int i=1;i<=V;i++)
dis[i]=INF;
dis[start]=0;
nod.num=start;
nod.val=0;
qq.push(nod); //将起点放入队列
while(!qq.empty()) //不为空时
{
for(int i=1;i<=V;i++)
{
if(i==start) continue;
if(D[qq.top().num][i]!=-1&&dis[i]>dis[qq.top().num] + D[qq.top().num][i])
{
dis[i]=dis[qq.top().num] + D[qq.top().num][i];
nod.num=i; nod.val=dis[i];
qq.push(nod);
}
}
qq.pop();
}
for(int i=1;i<=V;i++)
{
cout<<dis[i]<<" ";
}
return 0;
}
代码3 堆优化邻接表存图 并输出路径数量
终极版，模板就用他了，当二维数组过小runtime不能有效存图时，邻接表登场，因为最短路径可能不止一条，如果考到，不好意思，万事俱备,还可以根据有向图无向图进行修改，完美模板
#include<bits/stdc++.h>
using namespace std;
const int MaxN = 100010, MaxM = 500010;
struct edge
{
int to, dis, next;
};
edge e[MaxM];
int head[MaxN], dis[MaxN], cnt=0;
bool vis[MaxN];
int n, m, s;
int ans[MaxN];//记录数量
int mod=100003;
inline void add_edge( int u, int v, int d )
{
cnt++;
e[cnt].dis = d;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
struct node
{
int dis;//h
int pos;//vis
bool operator <( const node &x )const
{
return x.dis < dis;
}
};
priority_queue<node> q;
inline void dijkstra(int s)
{
dis[s] = 0;
q.push( ( node ){0, s} );
while( !q.empty() )
{
node tmp = q.top();
q.pop();
int x = tmp.pos, d = tmp.dis;
if( vis[x] )
continue;
vis[x] = 1;
for( int i = head[x]; i; i = e[i].next )
{
int y = e[i].to;
if( dis[y] > dis[x] + e[i].dis )
{
dis[y] = dis[x] + e[i].dis;
ans[y]=ans[x];
if( !vis[y] )
{
q.push( ( node ){dis[y], y} );
}
}
else if(dis[y]==dis[x]+e[i].dis)
{
ans[y]+=ans[x];
ans[y]%=mod;
}
}
}
}
int main()
{
cin>>n>>m;cin>>s;
ans[s]=1;
for(int i = 1; i <= n; ++i)dis[i] = 0x7fffffff;
for(int i = 0; i < m; ++i)
{
int u, v, d;
cin>>u>>v;//d=1;
cin>>d;
add_edge( u, v, d );
//add_edge( v, u, d );
}
dijkstra(s);
for( int i = 1; i <= n; i++ )cout<<dis[i]<<" ";
//for( int i = 1; i <= n; i++ )cout<<ans[i]<<endl;
return 0;
}
