引用一下某机构的PPT
无权图BFS算法很简单,到达顶点经过几轮最短路径就是几,不详细说明。
Dijkstra
解决单源最短路径的问题。
dijkstra的算法实现和prim最小生成树的思想很像。
此处未给出path数组的信息,待更新
//G全局变量;数组d为源点到各点的最短路径长度,s为起点
Dijkstra(G,d[],s)
{
初始化;
for (循环n次)//每次找到一个最短路径
{
u = 使d[u]最小的还未被访问的顶点的编号;//中转点,松弛操作的点
记u已被访问;
for(从u除法能到达的所有顶点v)
if v未被访问 && 以u为中介点使s到顶点v的最短距离d[v]更优
优化d[v];
}
}
//邻接矩阵版
int n,G[MAXV][MAXV];//
int d[MAXV];//起点到各点的最短路径长度
bool vis[MAXV] = {false};//标记数组
void Dijkstra(int s){//s start
fill(d,d + MAXV,INF);//fill函数将整个d数组赋为INF
d[s] = 0;//起点到大自身的距离是0
int ans = 0;//边权之和
for(int i = 0; i <n;i++){
int u = -1,MIN = INF;//u使d[u]最小,MIN存放最小的d[u]
for(int j =0;j < n;j++){//找到为访问的顶点中d[]最小的
if(vis[j] == false && d[j] < MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],剩下的顶点和集合s不连通
if(u = -1) return;
vis[u] = true;
for(int v =0 ;v < n;v ++){
//v未访问且u能达到v且以u为中介点可以使距离集合s更近
if(vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]){
d[v] = d[u] + G[u][v];//d[v] 值更新
}
}
}
}
邻接表版
//邻接表版
int n,G[MAXV][MAXV];//
int d[MAXV];//七点到大各点的最短路径长度
bool vis[MAXV] = {false};//标记数组
void Dijkstra(int s){//s start
fill(d,d + MAXV,INF);//fill函数将整个d数组赋为INF
d[s] = 0;//七点到大自身的距离是0
int ans = 0;//边权之和
for(int i = 0; i <n;i++){
int u = -1,MIN = INF;//u使d[u]最小,MIN存放最小的d[u]
for(int j =0;j < n;j++){//找到为访问的顶点中d[]最小的
if(vis[j] == false && d[j] < MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],剩下的顶点和集合s不连通
if(u = -1) return;
vis[u] = true;//标记u已访问
for(int j = 0;j < Adj[u].size();j++){
int v = Adj[u][i].v;//通过邻接表直接获得u能到达的顶点v
if(vis[v] == false && Adj[u][j].dis < d[v]){
//v未访问且u能达到v且以u为中介点可以使距离集合s更近
d[v] = Adj[u][j].dis;//d[v] 值更新
}
}
}
}
Bellma-Ford 算法
Dijkstra算法在计算negtive-cost-edge时会陷入循环,Bellma-Ford算法不会
代码先码上了,现在害不想看。
Bellman-Ford(G,d[],s)
{
for (循环n-1次)
{
for(each edge u->v)
if(d[u]+lenth[u->v] < d[v])
{
d[v] = d[u] + length[u->v]; //松弛操作
}
}
for(each edge u->v)
if(d[u]+lenth[u->v] < d[v])
{
d[v] = d[u] + length[u->v]; //如果仍然可以被1松弛,说明有负环
return false;
}
}
return true;
}
struct Node{
int v,dis;//v为邻接边的目标顶点,dis为邻接边的边权
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool Bellman(int s){
fill(d,d+MAXV,INF);
d[s] = 0;//s到自身的距离为0
for(int i = 0; i <n -1 ;i ++){//执行n-1轮操作
for(int u = 0;u < n;u++){//每轮操作都遍历所有边
for(int j = 0;j < Adj[u].size() ;j ++){
int v = Addj[u][j].v;//邻接边的顶点
int dis = Adj[u][j].dis;//邻接边的边权
if(d[u] + dis < d[v]){
d[v] = d[u] + dis;
}
}
}
}
//判断负环
for(int u = 0;u < n;u++){//每轮操作都遍历所有边
for(int j = 0;j < Adj[u].size() ;j ++){
int v = Addj[u][j].v;//邻接边的顶点
int dis = Adj[u][j].dis;//邻接边的边权
if(d[u] + dis < d[v]){
return false;//说明图中有从源点可达的负环
}
}
}
return true;//数组d的所有值都已达到最优
}
SPFA算法
SPFA算法时对BF算法的优化
借助队列
queu<int> Q;
源点s入队;
while(队列非空)
{
取出队首元素u;
fro(u的所有邻接边u->)v{
if(d[u]+ dis < d[v])
d[v] = d[u] + dis;
if(v当前不在队列)
v入队;
if(v的如对次数大于n-1)
说明有可达负环,return;
}
}
vector<Node> Adj[MAXV];
int n,d[MAXV],num[MAXV];
bool inq[MAXV];//顶点是否在队列中
bool SPFA(int s){
//初始化部分
meset(inq,false,sizeof(inq));
meset(num,0,sizeof(num));
fill(d,d+MAXV,INF);
//源点入队部分
queue<int> Q;
Q.push(s);
inq[s] = true;
num[s]++;
d[s] = 0;
//主体部分
while(!Q.empty()){
int u = Q.front();
Q.pop();
inq[u] = false;
//遍历u的所有邻接边v
for(int j = 0;j < Adj[u].size();j++){
int v = Adj[u][j].v;
int dis = Adj[u][j].dis;
//松弛操作
if(d[u] + dis < d[v]){
d[v] = d[u] + dis;
if(!inq[v]){
Q.push(v);//v入队
inq[v] = true;
num[v] ++ ;
if(num[v] >= n) return false;//有可达 负环
}
}
}
}
return false;
}
Foryd算法
Ford算法需要2个数组,一个存放结点距离的信息,一个存放路径的前驱结点。
枚举顶点k属于[1,n]
以顶点k作为中介点,枚举所有顶点对i和j(i属于[1,n],j属于[1,n])
如果dis[i][k] + dis[k][j] < dis[i][j] 成立
赋值dis[i][j] = dis[i][k] + dis[k][j];
全源最短路径
枚举顶点 k 属于 [1,n]
以顶点k为中介点,而迷局所有顶点对i和j(i belong [1,n] j [1,n])
如果dis[i][k] + dis[k][j] < dis [i][j] 成立
赋值dis[i][j] = dis [i][k] + dis[k][j]
#include <stdio.h>
#include <algorithm>
using namespace std;
const int INF = 1000000000;
const int MAXV = 200;
int n,m;//n顶点数,m边数
int dis[MAXV][MAXV];//dis[i][j] 表示顶点i和顶点j1的最短距离
void Floyd(){
for(int k = 0;k < n;k ++){
for(int i = 0;i < n; i++){
for(int j = 0;j < n;j++){
if(dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j] < dis [i][j] ) {
dis[i][j] = dis [i][k] + dis[k][j] ;
}
}
}
}
}