最短路径

【最短路径】之Dijkstra算法

单源最短路径：计算源点到其他各顶点的最短路径的长度
全局最短路径：图中任意两点的最短路径
Dijkstra、Bellman-Ford、SPFA求单源最短路径
Floyed可以求全局最短路径，但是效率比较低
SPFA算法是Bellman-Ford算法的队列优化
Dijkstra算法不能求带负权边的最短路径，而SPFA算法、Bellman-Ford算法、Floyd-Warshall可以求带负权边的最短路径。
Bellman-Ford算法的核心代码只有4行，Floyd-Warshall算法的核心代码只有5行。
深度优先遍历可以求一个点到另一个点的最短路径的长度

Dijkstra算法

Dijkstra() {
  初始化;
  for(循环n次) {
    u = 使dis[u]最小的还未被访问的顶点的编号;
    记u为确定值;
    for(从u出发能到达的所有顶点v){
      if(v未被访问 && 以u为中介点使s到顶点v的最短距离更优)
        优化dis[v];
    }
  }
}

Dijkstra() {

初始化;

for(循环n次) {

u = 使dis[u]最小的还未被访问的顶点的编号;

记u为确定值;

for(从u出发能到达的所有顶点v){

if(v未被访问 && 以u为中介点使s到顶点v的最短距离更优)

优化dis[v];

}

//邻接矩阵
int n, e[maxv][maxv];
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool vis[maxv] = {false};
void Dijkstra(int s) {
  fill(dis, dis + maxv, inf);
  dis[s] = 0;
  for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身
  for(int i = 0; i < n; i++) {
    int u = -1, minn = inf;
    for(int j = 0; j < n; j++) {
      if(visit[j] == false && dis[j] < minn) {
        u = j;
        minn = dis[j];
      }
    }
    if(u == -1) return;
    visit[u] = true;
    for(int v = 0; v < n; v++) {
      if(visit[v] == false && e[u][v] != inf && dis[u] + e[u][v] < dis[v]) {
        dis[v] = dis[u] + e[u][v];
        pre[v] = u; // pre用来标注当前结点的前一个结点
      }
    }
  }
}

//邻接矩阵

int n, e[maxv][maxv];

int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点

bool vis[maxv] = {false};

void Dijkstra(int s) {

fill(dis, dis + maxv, inf);

dis[s] = 0;

for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身

for(int i = 0; i < n; i++) {

int u = -1, minn = inf;

for(int j = 0; j < n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = dis[j];

}

if(u == -1) return;

visit[u] = true;

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf && dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

pre[v] = u; // pre用来标注当前结点的前一个结点

}

//邻接表
struct node {
  int v, dis;
}
vector<node> e[maxv];
int n;
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool visit[maxv] = {false};
for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身
void Dijkstra(int s) {
  fill(dis, dis + maxv, inf);
  dis[s] = 0;
  for(int i = 0; i < n; i++) {
    int u = -1, minn = inf;
    for(int j = 0; j < n; j++) {
      if(visit[j] == false && dis[j] < minn) {
        u = j;
        minn = dis[j];
      }
    }
    if(u == -1) return ;
    visit[u] = true;
    for(int j = 0; j < e[u].size(); j++) {
      int v = e[u][j].v;
      if(visit[v] == false && dis[u] + e[u][j].dis < dis[v]) {
        dis[v] = dis[u] + e[u][j].dis;
        pre[v] = u;
      }
    }
  }
}

//邻接表

struct node {

int v, dis;

}

vector<node> e[maxv];

int n;

int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点

bool visit[maxv] = {false};

for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身

void Dijkstra(int s) {

fill(dis, dis + maxv, inf);

dis[s] = 0;

for(int i = 0; i < n; i++) {

int u = -1, minn = inf;

for(int j = 0; j < n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = dis[j];

}

if(u == -1) return ;

visit[u] = true;

for(int j = 0; j < e[u].size(); j++) {

int v = e[u][j].v;

if(visit[v] == false && dis[u] + e[u][j].dis < dis[v]) {

dis[v] = dis[u] + e[u][j].dis;

pre[v] = u;

}

void dfs(int s, int v) {
  if(v == s) {
    printf("%d\n", s);
    return ;
  }
  dfs(s, pre[v]);
  printf("%d\n", v);
}

void dfs(int s, int v) {

if(v == s) {

printf("%d\n", s);

return ;

}

dfs(s, pre[v]);

printf("%d\n", v);

}

三种附加考法：第一标尺是距离，如果距离相等的时候，新增第二标尺

新增边权（第二标尺），要求在最短路径有多条时要求路径上的花费之和最小

for(int v = 0; v < n; v++) { //重写v的for循环
  if(visit[v] == false && e[u][v] != inf) {
    if(dis[u] + e[u][v] < dis[v]) {
      dis[v] = dis[u] + e[u][v];
      c[v] = c[u] + cost[u][v];
    }else if(dis[u] + e[u][v] == dis[v] && c[u] + cost[u][v] < c[v]) {
      c[v] = c[u] + cost[u][v];
    }
  }
}

for(int v = 0; v < n; v++) { //重写v的for循环

if(visit[v] == false && e[u][v] != inf) {

if(dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

c[v] = c[u] + cost[u][v];

}else if(dis[u] + e[u][v] == dis[v] && c[u] + cost[u][v] < c[v]) {

c[v] = c[u] + cost[u][v];

}

给定每个点的点权（第二标尺），要求在最短路径上有多条时要求路径上的点权之和最大

for(int v = 0; v < n; v++) {
  if(visit[v] == false && e[u][v] != inf) {
    if(dis[u] + e[u][v] < dis[v]) {
      dis[v] = dis[u] + e[u][v];
      w[v] = w[u] + weight[v];
    }else if(dis[u] + e[u][v] == dis[v] && w[u] + weight[v] > w[v]) {
      w[v] = w[u] + weight[v];
    }
  }
}

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf) {

if(dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

w[v] = w[u] + weight[v];

}else if(dis[u] + e[u][v] == dis[v] && w[u] + weight[v] > w[v]) {

w[v] = w[u] + weight[v];

}

直接问有多少条最短路径

增加一个数组num[]，num[s] = 1，其余num[u] = 0，表示从起点s到达顶点u的最短路径的条数为num[u]

for(int v = 0; v < n; v++) {
  if(visit[v] == false && e[u][v] != inf) {
    if(dis[u] + e[u][v] < dis[v]) {
      dis[v] = dis[u] + e[u][v];
      num[u] = num[v];
    }else if(dis[u] + e[u][v] == dis[v]) {
      num[v] = num[v] + num[u];
    }
  }
}

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf) {

if(dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

num[u] = num[v];

}else if(dis[u] + e[u][v] == dis[v]) {

num[v] = num[v] + num[u];

}

例子：比如说又要路径最短，又要点权权值最大，而且还要输出个数，而且还要输出路径

for(int v = 0; v < n; v++) {
  if(visit[v] == false && e[u][v] != inf) {
    if(dis[u] + e[u][v] < dis[v]) {
      dis[v] = dis[u] + e[u][v];
      num[v] = num[u];
      w[v] = w[u] + weight[v];
      pre[v] = u;
    } else if(dis[u] + e[u][v] == dis[v]) {
      num[v] = num[v] + num[u];
      if(w[u] + weight[v] > w[v]) {
        w[v] = w[u] + weight[v];
        pre[v] = u;
      }
    }
  }
}

void printPath(int v) {
    if(v == s) {
        printf("%d", v);
        return ;
    }
    printPath(pre[v]);
    printf("%d ", v);
}

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf) {

if(dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

num[v] = num[u];

w[v] = w[u] + weight[v];

pre[v] = u;

} else if(dis[u] + e[u][v] == dis[v]) {

num[v] = num[v] + num[u];

if(w[u] + weight[v] > w[v]) {

w[v] = w[u] + weight[v];

pre[v] = u;

}

void printPath(int v) {

if(v == s) {

printf("%d", v);

return ;

}

printPath(pre[v]);

printf("%d ", v);

}

of course, 可以不用这么麻烦，用Dijkstra求最短路径和pre数组，然后用深度优先遍历来获取想知道的一切，包括点权最大，边权最大，路径个数，路径
因为可能有多条路径，所以Dijkstra部分的pre数组使用vector<int> pre[maxv];

//Dijkstra部分
if(dis[u] + e[u][v] < dis[v]) {
  dis[v] = dis[u] + e[u][v];
  pre[v].clear();
  pre[v].push_back(u);
} else if(dis[i] + e[u] == dis[v]) {
  pre[v].push_back(u);
}

//Dijkstra部分

if(dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

pre[v].clear();

pre[v].push_back(u);

} else if(dis[i] + e[u] == dis[v]) {

pre[v].push_back(u);

}

既然已经求得pre数组，就知道了所有的最短路径，然后要做的就是用dfs遍历所有最短路径，找出一条使第二标尺最优的路径

int optvalue;
vector<int> pre[maxv];
vector<int> path, temppath;
void dfs(int v) { // v为当前访问结点
  if(v == start) {
    temppath.push_back(v);
    int value = 路径temppath上的value值;
    if(value 优于 optvalue) {
      optvalue = value;
      path = temppath;
    }
    temppath.pop_back();
    return ;
  }
  temppath.push_back(v);
  for(int i = 0; i < pre[v].size(); i++)
    dfs(pre[v][i]);
  temppath.pop_back();
}

int optvalue;

vector<int> pre[maxv];

vector<int> path, temppath;

void dfs(int v) { // v为当前访问结点

if(v == start) {

temppath.push_back(v);

int value = 路径temppath上的value值;

if(value 优于 optvalue) {

optvalue = value;

path = temppath;

}

temppath.pop_back();

return ;

}

temppath.push_back(v);

for(int i = 0; i < pre[v].size(); i++)

dfs(pre[v][i]);

temppath.pop_back();

}

解释：
- 对于递归边界而言，如果当前访问的结点是叶子结点（就是路径的开始结点），那么说明到达了递归边界，把v压入temppath，temppath里面就保存了一条完整的路径。如果计算得到的当前的value大于最大值，就path = temppath，然后把temppath的最后一个结点弹出，return ;
- 对于递归式而言，每一次都是把当前访问的结点压入，然后找他的pre[v][i]，进行递归，递归完毕后弹出最后一个结点
计算当前temppath边权或者点权之和的代码：

// 边权之和
int value = 0;
for(int i = tempptah.size() - 1; i > 0; i--) {
  int id = temppath[i], idnext = temppath[i - 1];
  value += v[id][idnext];
}
// 点权之和
int value = 0;
for(int i = temppath.size(); i >= 0; i--) {
  int id = temppath[i];
  value += w[id];
}

// 边权之和

int value = 0;

for(int i = tempptah.size() - 1; i > 0; i--) {

int id = temppath[i], idnext = temppath[i - 1];

value += v[id][idnext];

}

// 点权之和

int value = 0;

for(int i = temppath.size(); i >= 0; i--) {

int id = temppath[i];

value += w[id];

}

计算路径直接在Dijkstra部分写就可以
例子：计算最短距离的路径和最小花费

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int n, m, s, d;
int e[510][510], dis[510], cost[510][510];
vector<int> pre[510];
bool visit[510];
const int inf = 99999999;
vector<int> path, temppath;
int mincost = inf;
void dfs(int v) {
    if(v == s) {
        temppath.push_back(v);
        int tempcost = 0;
        for(int i = temppath.size() - 1; i > 0; i--) {
            int id = temppath[i], nextid = temppath[i-1];
            tempcost += cost[id][nextid];
        }
        if(tempcost < mincost) {
            mincost = tempcost;
            path = temppath;
        }
        temppath.pop_back();
        return ;
    }
    temppath.push_back(v);
    for(int i = 0; i < pre[v].size(); i++)
        dfs(pre[v][i]);
    temppath.pop_back();
}
int main() {
    fill(e[0], e[0] + 510 * 510, inf);
    fill(dis, dis + 510, inf);
    scanf("%d%d%d%d", &n, &m, &s, &d);
    for(int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        scanf("%d", &e[a][b]);
        e[b][a] = e[a][b];
        scanf("%d", &cost[a][b]);
        cost[b][a] = cost[a][b];
    }
    pre[s].push_back(s);
    dis[s] = 0;
    for(int i = 0; i < n; i++) {
        int u = -1, minn = inf;
        for(int j = 0; j < n; j++) {
            if(visit[j] == false && dis[j] < minn) {
                u = j;
                minn = j;
            }
        }
        if(u == -1) break;
        visit[u] = true;
        for(int v = 0; v < n; v++) {
            if(visit[v] == false && e[u][v] != inf) {
                if(dis[v] > dis[u] + e[u][v]) {
                    dis[v] = dis[u] + e[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                } else if(dis[v] == dis[u] + e[u][v]) {
                    pre[v].push_back(u);
                }
            }
        }
    }
    dfs(d);
    for(int i = path.size() - 1; i >= 0; i--)
        printf("%d ", path[i]);
    printf("%d %d", dis[d], mincost);
    return 0;
}
//注意路径path因为是从末端一直压入push_back到path里面的，所以要输出路径的时候倒着输出

#include <cstdio>

#include <algorithm>

#include <vector>

using namespace std;

int n, m, s, d;

int e[510][510], dis[510], cost[510][510];

vector<int> pre[510];

bool visit[510];

const int inf = 99999999;

vector<int> path, temppath;

int mincost = inf;

void dfs(int v) {

if(v == s) {

temppath.push_back(v);

int tempcost = 0;

for(int i = temppath.size() - 1; i > 0; i--) {

int id = temppath[i], nextid = temppath[i-1];

tempcost += cost[id][nextid];

}

if(tempcost < mincost) {

mincost = tempcost;

path = temppath;

}

temppath.pop_back();

return ;

}

temppath.push_back(v);

for(int i = 0; i < pre[v].size(); i++)

dfs(pre[v][i]);

temppath.pop_back();

}

int main() {

fill(e[0], e[0] + 510 * 510, inf);

fill(dis, dis + 510, inf);

scanf("%d%d%d%d", &n, &m, &s, &d);

for(int i = 0; i < m; i++) {

int a, b;

scanf("%d%d", &a, &b);

scanf("%d", &e[a][b]);

e[b][a] = e[a][b];

scanf("%d", &cost[a][b]);

cost[b][a] = cost[a][b];

}

pre[s].push_back(s);

dis[s] = 0;

for(int i = 0; i < n; i++) {

int u = -1, minn = inf;

for(int j = 0; j < n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = j;

}

if(u == -1) break;

visit[u] = true;

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf) {

if(dis[v] > dis[u] + e[u][v]) {

dis[v] = dis[u] + e[u][v];

pre[v].clear();

pre[v].push_back(u);

} else if(dis[v] == dis[u] + e[u][v]) {

pre[v].push_back(u);

}

dfs(d);

for(int i = path.size() - 1; i >= 0; i--)

printf("%d ", path[i]);

printf("%d %d", dis[d], mincost);

return 0;

}

//注意路径path因为是从末端一直压入push_back到path里面的，所以要输出路径的时候倒着输出

【最短路径】：Dijkstra算法、SPFA算法、Bellman-Ford算法和Floyd-Warshall算法

求最短路径最常用的算法有：
Dijkstra算法、SPFA算法、Bellman-Ford算法和Floyd-Warshall算法。
Dijkstra算法、SPFA算法、Bellman-Ford算法这三个求单源最短路径，最后一个Floyd-Warshall算法可以求全局最短路径也可以求单源路径，效率比较低。
SPFA算法是Bellman算法的队列优化。
Dijkstra算法不能求带负权边的最短路径，而SPFA算法、Bellman-Ford算法、Floyd-Warshall可以求带负权边的最短路径。
Bellman-Ford算法的核心代码只有4行，Floyd-Warshall算法的核心代码只有5行。

1.最基本的求单源最短路径方法是图的深度优先遍历：
用 min = 99999999 记录路径的最小值，book[i]标记结点 i 是否被访问过~

#include <iostream>
using namespace std;
int minn = 99999999;
int book[101];
int n;
int e[101][101];

//cur是当前所在的城市编号，dis是当前已经走过的路程
void dfs(int cur, int dis) {
    if (dis > minn)
        return ;
    if (cur == n) {
        if (dis < minn)
            minn = dis;
        return ;
    }
    for (int i = 1; i <= n; i++) {//从cur到所有结点依次尝试
        if (e[cur][i] != 99999999 && book[i] == 0) {
            book[i] = 1;
            dfs(i, dis + e[cur][i]);//从i结点出发到其他所有结点依次尝试直到遇到要求的n结点为止
            book[i] = 0;
        }
    }
    return ;
}

int main() {
    int m;
    cin >> n >> m;
    int a, b, c;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j)
                e[i][j] = 0;
            else
                e[i][j] = 99999999;
        }
    }
    for(int i = 1; i <= m; i++) {
        cin >> a >> b >> c;
        e[a][b] = c;
    }
    book[1] = 1;
    dfs(1, 0);
    cout << minn;
    return 0;
}

#include <iostream>

using namespace std;

int minn = 99999999;

int book[101];

int n;

int e[101][101];

//cur是当前所在的城市编号，dis是当前已经走过的路程

void dfs(int cur, int dis) {

if (dis > minn)

return ;

if (cur == n) {

if (dis < minn)

minn = dis;

return ;

}

for (int i = 1; i <= n; i++) {//从cur到所有结点依次尝试

if (e[cur][i] != 99999999 && book[i] == 0) {

book[i] = 1;

dfs(i, dis + e[cur][i]);//从i结点出发到其他所有结点依次尝试直到遇到要求的n结点为止

book[i] = 0;

}

return ;

}

int main() {

int m;

cin >> n >> m;

int a, b, c;

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= n; j++) {

if (i == j)

e[i][j] = 0;

else

e[i][j] = 99999999;

}

for(int i = 1; i <= m; i++) {

cin >> a >> b >> c;

e[a][b] = c;

}

book[1] = 1;

dfs(1, 0);

cout << minn;

return 0;

}

2.单源最短路径：Dijkstra算法
dis[i]是需要不断更新的数组，它表示当前结点1(源点)到其余各结点的最短路径长度~
book[i]标记当前结点最短路径是确定值还是估计值~
算法实现的过程是：每次找到离结点1最近的那个点，然后以该结点为中心扩展，最终得到源点到所有点的最短路径~~每次新扩展一个距离最短的点，更新与其相邻的点的距离。当所有边权都为正时，由于不会存在一个距离更短的没扩展过的点，所以这个点的距离永远不会再被改变，因而保证了算法的正确性。不过根据这个原理，用Dijkstra求最短路的图不能有负权边，因为扩展到负权边的时候会产生更短的距离，有可能就破坏了已经更新的点距离不会改变的性质~~
找到所有估计值当中最小的值min以及它的结点u，然后把该结点u标记为确定值，通过这个确定值为中转点更新别的所有值的最短路径(松弛别的两个顶点连接的边)

//邻接矩阵
int n, e[maxv][maxv];
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool vis[maxv] = {false};
void Dijkstra(int s) {
  fill(dis, dis + maxv, inf);
  dis[s] = 0;
  for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身
  for(int i = 0; i < n; i++) {
    int u = -1, minn = inf;
    for(int j = 0; j < n; j++) {
      if(visit[j] == false && dis[j] < minn) {
        u = j;
        minn = dis[j];
      }
    }
    if(u == -1) return;
    visit[u] = true;
    for(int v = 0; v < n; v++) {
      if(visit[v] == false && e[u][v] != inf && dis[u] + e[u][v] < dis[v]) {
        dis[v] = dis[u] + e[u][v];
        pre[v] = u; // pre用来标注当前结点的前一个结点
      }
    }
  }
}

//邻接矩阵

int n, e[maxv][maxv];

int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点

bool vis[maxv] = {false};

void Dijkstra(int s) {

fill(dis, dis + maxv, inf);

dis[s] = 0;

for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身

for(int i = 0; i < n; i++) {

int u = -1, minn = inf;

for(int j = 0; j < n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = dis[j];

}

if(u == -1) return;

visit[u] = true;

for(int v = 0; v < n; v++) {

if(visit[v] == false && e[u][v] != inf && dis[u] + e[u][v] < dis[v]) {

dis[v] = dis[u] + e[u][v];

pre[v] = u; // pre用来标注当前结点的前一个结点

}

//邻接表
struct node {
  int v, dis;
}
vector<node> e[maxv];
int n;
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool vis[maxv] = {false};
for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身
void Dijkstra(int s) {
  fill(d, d + maxv, inf);
  dis[s] = 0;
  for(int i = 0; i < n; i++) {
    int u = -1, minn = inf;
    for(int j = 0; j < n; j++) {
      if(visit[j] == false && dis[j] < minn) {
        u = j;
        minn = dis[j];
      }
    }
    if(u == -1) return ;
    visit[u] = true;
    for(int j = 0; j < e[u].size(); j++) {
      int v = e[u][j].v;
      if(visit[v] == false && dis[u] + e[u][j].dis < dis[v]) {
        dis[v] = dis[u] + e[u][j].dis;
        pre[v] = u;
      }
    }
  }
}

//邻接表

struct node {

int v, dis;

}

vector<node> e[maxv];

int n;

int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点

bool vis[maxv] = {false};

for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身

void Dijkstra(int s) {

fill(d, d + maxv, inf);

dis[s] = 0;

for(int i = 0; i < n; i++) {

int u = -1, minn = inf;

for(int j = 0; j < n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = dis[j];

}

if(u == -1) return ;

visit[u] = true;

for(int j = 0; j < e[u].size(); j++) {

int v = e[u][j].v;

if(visit[v] == false && dis[u] + e[u][j].dis < dis[v]) {

dis[v] = dis[u] + e[u][j].dis;

pre[v] = u;

}

3.Bellman-Ford算法——解决负权边
算法思想：对所有的边进行n-1次“松弛”操作

核心算法四行：
for (k = 1; k <= n - 1; k++)
    for (i = 1; i <= m; i++)
        if (dis[v[i]] > dis[u[i]] + w[i])
            dis[v[i]] = dis[u[i]] + w[i];
进行n-1轮的原因：在一个含有n个顶点的图中，任意两点之间的最短路径最多包含n-1边。

//检验负权回路
如果在进行最短路径算法后，仍然有可以松弛的边，那么就是存在负权回路
flag = 0;
for (i = 1; i <= m; i++)
    if (dis[v[i]] > dis[u[i]] + w[i])
        flag = 1;
if (flag == 1)
    printf("此图含有负权回路");

核心算法四行：

for (k = 1; k <= n - 1; k++)

for (i = 1; i <= m; i++)

if (dis[v[i]] > dis[u[i]] + w[i])

dis[v[i]] = dis[u[i]] + w[i];

进行n-1轮的原因：在一个含有n个顶点的图中，任意两点之间的最短路径最多包含n-1边。

//检验负权回路

如果在进行最短路径算法后，仍然有可以松弛的边，那么就是存在负权回路

flag = 0;

for (i = 1; i <= m; i++)

if (dis[v[i]] > dis[u[i]] + w[i])

flag = 1;

if (flag == 1)

printf("此图含有负权回路");

如果在新一轮的松弛中数组dis没有发生变化，则可以提前跳出循环
#include <iostream>
#include <cstdio>
//n个结点，m条边
using namespace std;
int main() {
    int dis[10], bak[10], n, m, u[10], v[10], w[10], check, flag;
    int inf = 99999999;
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= m; i++)
        scanf("%d %d %d", &u[i], &v[i], &w[i]);
    
    for (int i = 1; i <= n; i++)
        dis[i] = inf;
    dis[1] = 0;
    
    for (int k = 1; k <= n - 1; k++) {
        for (int i = 1; i <= n; i++)
            bak[i] = dis[i];//将dis数组备份入bak数组中，为了下面的检查是否更新而进行剪枝
        for (int i = 1; i <= m; i++)
            if (dis[v[i]] > dis[u[i]] + w[i])
                dis[v[i]] = dis[u[i]] + w[i];
        check = 0;
        for (int i = 1; i < n; i++)
            if (bak[i] != dis[i]) {
                check = 1;
                break;
            }
        // 如果对于所有的结点，dis的值都没有被更新，那就提前跳出循环，说明不需要进行n-1次了
        if (check == 0)
            break;
    }
    //检查是否含有负权回路（可省略）
    flag = 0;
    for (int i = 1; i <= m; i++)
        if (dis[v[i]] > dis[u[i]] + w[i])
            flag = 1;
    if (flag == 1)
        printf("此图含有负权回路");
    else {
        for (int i = 1; i <= n; i++) 
            printf("%d ", dis[i]);
    }
    return 0;
}

如果在新一轮的松弛中数组dis没有发生变化，则可以提前跳出循环

#include <iostream>

#include <cstdio>

//n个结点，m条边

using namespace std;

int main() {

int dis[10], bak[10], n, m, u[10], v[10], w[10], check, flag;

int inf = 99999999;

scanf("%d %d", &n, &m);

for (int i = 1; i <= m; i++)

scanf("%d %d %d", &u[i], &v[i], &w[i]);

for (int i = 1; i <= n; i++)

dis[i] = inf;

dis[1] = 0;

for (int k = 1; k <= n - 1; k++) {

for (int i = 1; i <= n; i++)

bak[i] = dis[i];//将dis数组备份入bak数组中，为了下面的检查是否更新而进行剪枝

for (int i = 1; i <= m; i++)

if (dis[v[i]] > dis[u[i]] + w[i])

dis[v[i]] = dis[u[i]] + w[i];

check = 0;

for (int i = 1; i < n; i++)

if (bak[i] != dis[i]) {

check = 1;

break;

}

// 如果对于所有的结点，dis的值都没有被更新，那就提前跳出循环，说明不需要进行n-1次了

if (check == 0)

break;

}

//检查是否含有负权回路（可省略）

flag = 0;

for (int i = 1; i <= m; i++)

if (dis[v[i]] > dis[u[i]] + w[i])

flag = 1;

if (flag == 1)

printf("此图含有负权回路");

else {

for (int i = 1; i <= n; i++)

printf("%d ", dis[i]);

}

return 0;

}

4.Bellman-Ford的队列优化(SPFA算法)
每次选取首顶点u，对u的所有出边进行松弛操作~如果有一条u->v的边，通过这条边使得源点到顶点v的路程变短，且顶点v不在当前队列中，就把这个顶点v放入队尾。同一个顶点在队列中出现多次是毫无意义的，所以用一个数组来判重复，判断哪些点已经在队列中。对顶点u的所有出边都松弛完毕后，就将顶点v出队~

#include <iostream>
#include <cstdio>
using namespace std;
int main() {
    int n, m;
    int u[8], v[8], w[8];
    int first[6], next[8];
    int dis[6] = {0}, book[6] = {0};
    int que[101] = {0};
    int head = 1;
    int tail = 1;
    int inf = 99999999;
    scanf("%d %d", &n, &m);
    
    for (int i = 1; i <= n; i++)
        dis[i] = inf;
    dis[1] = 0;
    
    for (int i = 1; i <= n; i++)
        book[i] = 0;
    
    for (int i = 1; i <= n; i++)
        first[i] = -1;
    
    for (int i = 1; i <= m; i++) {
        scanf("%d %d %d", &u[i], &v[i], &w[i]);
        next[i] = first[u[i]];
        first[u[i]] = i;
    }
    
    que[tail] = 1;
    tail++;
    book[1] = 1;
    
    int k;
    while (head < tail) {
        k = first[que[head]];
        while (k != -1) {
            if (dis[v[k]] > dis[u[k]] + w[k]) {
                dis[v[k]] = dis[u[k]] + w[k];
                if (book[v[k]] == 0) {
                    que[tail] = v[k];
                    tail++;
                    book[v[k]] = 1;
                }
            }
            k = next[k];
        }
        book[que[head]] = 0;
        head++;
    }
    
    for (int i = 1; i <= n; i++)
        printf("%d ", dis[i]);
    return 0;
}

#include <iostream>

#include <cstdio>

using namespace std;

int main() {

int n, m;

int u[8], v[8], w[8];

int first[6], next[8];

int dis[6] = {0}, book[6] = {0};

int que[101] = {0};

int head = 1;

int tail = 1;

int inf = 99999999;

scanf("%d %d", &n, &m);

for (int i = 1; i <= n; i++)

dis[i] = inf;

dis[1] = 0;

for (int i = 1; i <= n; i++)

book[i] = 0;

for (int i = 1; i <= n; i++)

first[i] = -1;

for (int i = 1; i <= m; i++) {

scanf("%d %d %d", &u[i], &v[i], &w[i]);

next[i] = first[u[i]];

first[u[i]] = i;

}

que[tail] = 1;

tail++;

book[1] = 1;

int k;

while (head < tail) {

k = first[que[head]];

while (k != -1) {

if (dis[v[k]] > dis[u[k]] + w[k]) {

dis[v[k]] = dis[u[k]] + w[k];

if (book[v[k]] == 0) {

que[tail] = v[k];

tail++;

book[v[k]] = 1;

}

k = next[k];

}

book[que[head]] = 0;

head++;

}

for (int i = 1; i <= n; i++)

printf("%d ", dis[i]);

return 0;

}