目录
一.迪杰斯特拉算法（dijkstra）
1.实现原理：
dijkstra算法能实现的原因是它保证了在第一次出队之后，答案一定为最短。也就是出队之后
，一定不会再有更短的路径出队，而dijkstra算法的实现就是基于边权不为负的情况下。
实现步骤：
1.初始化所有点到起点1的距离为正无穷，且dis[1]=0。
2.将起点信息(0,1)入队进行bfs拓展。
3.将起点相连点入队，即(1,2)，（2,3）入队。更新点2,3的距离信息。
4.继续拓展节点2，3，将(9,4)，(5,4)以及(9,5)入队。此时队首为(5,4)，将该节点出队，得到dis[4]=5。
5.继续拓展，直到终点出队...
2.代码实现：
用dis数组记录到每个点的具体距离，每一次循环后，加上相应的边权
cpp
priority_queue<node> q;
void dijkstra(int x) {
memset(dis,0x3f,sizeof dis);
dis[x]=0;
q.push({0,x});
while(!q.empty()) {
node t=q.top();
q.pop();
int y=t.p;
vis[y]=true;
for(int i=he[y]; i; i=nxt[i]) {
int z=per[i],w=ed[i];
if(vis[z]==false && dis[z]>dis[y]+w) {
dis[z]=dis[y]+w;
q.push({dis[z],z});
}
}
}
}3.例题：
求单源最短路
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值(边权小于10000)。
请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。第一行包含整数n和m(n<=1e5,m<=2e5)。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。
用例输入 1
正确代码：
cpp
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,tot,ed[N*2],nxt[N*2],he[N],per[N*2],dis[N*2];
bool vis[N*2];
void add(int x,int y,int z) {//邻接表
++tot;
per[tot]=y,ed[tot]=z,nxt[tot]=he[x],he[x]=tot;
}
struct node {
int d,p;
};
bool operator < (node x,node y) {//重载运算符，明确在优先队列中的排序依据
return x.d>y.d;
}
priority_queue<node> q;
void dijkstra(int x) {
memset(dis,0x3f,sizeof dis);
dis[x]=0;
q.push({0,x});
while(!q.empty()) {
node t=q.top();
q.pop();
int y=t.p;
vis[y]=true;
for(int i=he[y]; i; i=nxt[i]) {
int z=per[i],w=ed[i];
if(vis[z]==false && dis[z]>dis[y]+w) {//比较最小
dis[z]=dis[y]+w;
q.push({dis[z],z});//入队
}
}
}
}
int main() {
cin>>n>>m;
for(int i=1; i<=m; i++) {
int x,y,z;
cin>>x>>y>>z;
add(x,y,z);//有向图
}
dijkstra(1);
if(dis[n]==0x3f3f3f3f) cout<<-1;//是否遍历到过，没有就没法从医到这个点
else cout<<dis[n];
return 0;
}二.spfa算法：
对于全是正边权的图，我们可以使用dijkstra处理最短路问题。但是如果带有负边边，dijkstra算法无法保证节点出队时一定得到最短路，spfa算法则可以解决这个问题。
1.实现原理：
在求解各点到起点的最小距离dis值时，若某点i产生一个更小的dis[i]，那么节点i后续指向的节点都会重新更新，因此我们可以将该点i再次入队，重新更新。
在枚举到3->5的时候由于它小于之前入队的数，所以要进行出对，并进行更新后再次入队。
2.代码实现：
在dijlstra算法的基础上，加入重新出对与再入队的代码
cpp
void spfa() {
queue<int>q;
q.push(1);
memset(dis,0x3f,sizeof dis);
dis[1]=0;
vis[1]=true;
while(!q.empty()) {
int x=q.front();q.pop();
vis[x]=false;//出队之后将原来的标记清除
for(int i=he[x]; i; i=nxt[i]) {
int y=per[i],w=ed[i];
if(dis[x]+w<dis[y]){
dis[y]=dis[x]+w;
if(vis[y]==false){
q.push(y);
vis[y]=true;
}
}
}
}
}3.例题：
带负权的最短路计算
给定一个n个点m条边(n<=1e5,m<=2e5)的有向图，图中可能存在重边和自环，边权绝对值小于104。数据保证图中不存在负权回路。
请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。
第一行包含整数n和m(n<=1e5,m<=2e5)。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。
正确代码：
cpp
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int n,m,he[N],per[N],nxt[N],tot,dis[N],ed[N];
bool vis[N];
void add(int x,int y,int z) {
++tot;
per[tot]=y,ed[tot]=z,nxt[tot]=he[x],he[x]=tot;
}
long long read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-') f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
void spfa() {
queue<int>q;
q.push(1);
memset(dis,0x3f,sizeof dis);
dis[1]=0;
vis[1]=true;
while(!q.empty()) {
int x=q.front();q.pop();
vis[x]=false;
for(int i=he[x]; i; i=nxt[i]) {
int y=per[i],w=ed[i];
if(dis[x]+w<dis[y]){
dis[y]=dis[x]+w;
if(vis[y]==false){
q.push(y);
vis[y]=true;
}
}
}
}
}
int main() {
n=read(),m=read();
for(int i=1; i<=m; i++) {
int x,y,z;
x=read(),y=read(),z=read();
add(x,y,z);
}
spfa();
if(dis[n]==0x3f3f3f3f) cout<<-1;
else cout<<dis[n];
return 0;
}三.贝尔曼福特（bellman_ford）
上面讲到的两种最短路算法(dijkstra与spfa)，他们都是由枚举已知顶点更新未知点。如果我们要在最短路上增加边数限定，即不超过k条边所能构成的最短路，我们就需要将边编号，通过枚举边来实现。
1.实现原理：
枚举边，若左端点值已知，则更新右端点的值。初始化所有点的dis值为正无穷，且dis[1]=0。第1次枚举边：得到dis[2]=1，dis[3]=8第2次枚举边：得到dis[4]=1第3次枚举边：得到dis[5]=2
已知：任意一条路径都是由若干条边组成的链。第一次枚举所有边，可以求出与起点直连的点的最短路。第二次枚举所有边，可以求出不超过2条边所构成的最短路。第k次枚举所有边，可以求出不超过k条边所构成的最短路。
2.代码实现：
使用bellman_ford枚举边，所有用结构体存边并且进行编号。
cpp
void bellman_ford(){
memset(dis,0x3f,sizeof dis);
dis[1]=0;
for(int i=0;i<k;i++){
memcpy(dis_old,dis,sizeof dis_old);
for(int i=1;i<=m;i++) dis[a[i].y]=min(dis[a[i].y],dis_old[a[i].x]+a[i].w);
}
}3.例题：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x
到点 y 的有向边，边长为 z。
点的编号为 1∼n。
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
正确代码：
cpp
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
bool vis[N];
vector<int> v[N];
int n,m,k,dis[N],dis_old[N];//用dis_old记录上一个·点，以此来实现标记边
long long read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-') f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
struct node{
int x,y,w;
}a[N];
void bellman_ford(){
memset(dis,0x3f,sizeof dis);
dis[1]=0;
for(int i=0;i<k;i++){
memcpy(dis_old,dis,sizeof dis_old);
for(int i=1;i<=m;i++) dis[a[i].y]=min(dis[a[i].y],dis_old[a[i].x]+a[i].w);
}
}
int main() {
n=read(),m=read(),k=read();
for(int i=1;i<=m;i++) a[i].x=read(),a[i].y=read(),a[i].w=read();
bellman_ford();
if(dis[n]>0x3f3f3f3f) cout<<"impossible";
else cout<<dis[n];
return 0;
}四.弗洛伊德（floyd）
floyd算法专门针对多源最短路问题。floyd可以用一个二维矩阵表示两点之间的最短路径，即我们只需要维护图中最小距离的邻接矩阵。floyd本质上就是通过不断为两点的路径上增加中间点(所以又称为插点法)，进而对邻接矩阵进行更新迭代，每加入一个点，矩阵信息就可能变化一次，从而维护该最小距离矩阵。
1.实现原理：
每次枚举是加入一个中间点k，矩阵中有些点对的距离就有可能减小。同时也说明两点的最短路径链上就可能会增加该中间点k。当所有点都作为中间点加入且完成矩阵的更新后，最终矩阵一定存储任意两点之间的距离最小值。
在这幅图中，如果不进行插点，它的初始矩阵是这样的：
|---|------------|------------|------------|---|
| | 1 | 2 | 3 | 4 |
| 1 | 0 | 0x3f3f3f3f | 0x3f3f3f3f | 3 |
| 2 | 1 | 0 | 0x3f3f3f3f | 8 |
| 3 | 2 | 5 | 0 | 3 |
| 4 | 0x3f3f3f3f | 0x3f3f3f3f | 0x3f3f3f3f | 0 |
而在插入1为中间点后，它的矩阵就变成了这样：
|---|------------|------------|------------|---|
| | 1 | 2 | 3 | 4 |
| 1 | 0 | 0x3f3f3f3f | 0x3f3f3f3f | 3 |
| 2 | 1 | 0 | 0x3f3f3f3f | 4 |
| 3 | 2 | 5 | 0 | 3 |
| 4 | 0x3f3f3f3f | 0x3f3f3f3f | 0x3f3f3f3f | 0 |
在插入2为中间点后，它的矩阵又变成这样：
|---|------------|------------|------------|---|
| | 1 | 2 | 3 | 4 |
| 1 | 0 | 0x3f3f3f3f | 0x3f3f3f3f | 3 |
| 2 | 1 | 0 | 0x3f3f3f3f | 4 |
| 3 | 2 | 5 | 0 | 3 |
| 4 | 0x3f3f3f3f | 0x3f3f3f3f | 0x3f3f3f3f | 0 |
最后插入三为中间点后，它的矩阵是这样的：
|---|------------|------------|------------|---|
| | 1 | 2 | 3 | 4 |
| 1 | 0 | 0x3f3f3f3f | 0x3f3f3f3f | 3 |
| 2 | 1 | 0 | 0x3f3f3f3f | 4 |
| 3 | 2 | 5 | 0 | 3 |
| 4 | 0x3f3f3f3f | 0x3f3f3f3f | 0x3f3f3f3f | 0 |
（这只是一个特殊样例，并不是所有可能都只会在插入第一个中间点后才会改变，但经过n-1次插点后路径一定最短）
2.代码实现：
图中存在负边权，且无负权环。n较小，m较大特别稠密，可以使用邻接矩阵存边。最后涉及到多次询问，使用floyd可以维护邻接矩阵，快速求解。
cpp
void floyd(){
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(k==i||k==j||i==j) continue;//可有可无
if(g[i][j]>g[i][k]+g[k][j]) g[i][j]=g[i][k]+g[k][j],pat[i][j]=k;//修改最短路径
}
}
}
}3.例题：
给定由n个点m条边的构成无向图，边权可能为负，图中可能存在重边，不存自环以及负权环。
现在给定q组询问，请输出每组询问中节点i到j的最短距离及其路径。
第一行 n,m,q，其中n≤500,m≤106,q≤104。
接下来m行表示这两个点之间有边相连，边权绝对值小于10000。
随后q行，代表接下来有q个询问，每个询问由ai,bi构成。
一共输出q行，如果两点不存在路径则输出-1，否则每行第一个数字表示两点之间的最短距离，随后输出其路径(如果存在多条最短路径，则输出字典序最小的一个)
正确代码：
cpp
#include<bits/stdc++.h>
using namespace std;
int n,m,q,g[505][505],pat[505][505];
long long read() {
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') {
if(c=='-') f=-1;
c=getchar();
}
while(c>='0'&&c<='9') {
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
void floyd(){
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(k==i||k==j||i==j) continue;
if(g[i][j]>g[i][k]+g[k][j]) g[i][j]=g[i][k]+g[k][j],pat[i][j]=k;
}
}
}
}
void print(int x,int y){
if(pat[x][y]==0){
cout<<" "<<y;
return;
}
print(x,pat[x][y]),print(pat[x][y],y);
}
int main(){
n=read(),m=read(),q=read();
memset(g,0x3f,sizeof g);
for(int i=1;i<=m;i++){
int x,y,w;
x=read(),y=read(),w=read();
g[x][y]=g[y][x]=min(g[x][y],w);
}
floyd();
for(int i=1;i<=q;i++){
int x,y;
x=read(),y=read();
if(g[x][y]==-1) cout<<-1<<endl;
else{
cout<<g[x][y]<<" "<<x;
print(x,y);
cout<<endl;
}
}
return 0;
}4.floyd性质探索：
（1）.性质一
插入中间点的顺序对结果没有影响。
插入一个中间点k后，此时矩阵中任意两点的距离就可能因为该中间点变小，即点k加入了其中两点的路径中。因此，我们只需要保证点1-n都作为中间点插入一次，从而更新矩阵，对插入顺序不作要求。
（2）.性质二
floyd算法在第执行k次插点后，最短路径上的边数一定不会超过k+1。
第1次插点后：
两端点由(i->j)直连变成可能加入一个中间点k相连，变成(i->k->j)，即最短路径上存在不超过两条边。
第2次插点后：
两端点最短路径有可能还是只有一条边构成(i->j)，当然也有可能在第1次插点的基础上增加为两条边构成(i->k->j)，此时插点有可能再增加一个点p，变成3条边。即(i->p->k->j) 或 (i->k->p->j)。
第n次插点后：
两端点最短路径上最多由n+2个点构成，即存在不超过n+1条边
（3）.性质三
在执行第k次插点操作前，所求任意两端点的最短路径上，一定不包含k以及k后的若干点。
与性质1类似插入某一个点，则说明把该点放到两端点的路径上，从而尝试更新两端点的最小距离。同理，未插入的点是没有更新任意两端点的距离。必不在现有的路径上。
5.floyd传递闭包问题
传递闭包是离散数学中的一个概念，简单来说就是维护关系的传递性。如a<b,b<c则有a<c。
我们以前学习过使用并查集解决部分具有关系传递性的问题。在这里，我们可以通过floyd算法去建立与维护关系矩阵。从而快速判断任意两点是否具备当前关系。可以通过g数组来记录每一个点之间的关系，若g[a][b]=1就代表a>b，若g[a][b]=0，则a<b。如果a、b的关系需要通过k来传递，我们可以通过g[a][b] |= (g[a][k] & g[k][b])来转移他们的关系。