最短路算法总结

迪杰斯特拉算法

一.定义（个人理解）
一种基于贪心思想进行的最短路求解方法。（即每次计算距离当前起点最短的点（标记），并以上以距离最短的点为新起点，如此反复遍历所以未标记的节点。)
二.优点
1.朴素算法时间复杂度(n^2),堆优化后mlogN.
不仅可以计算起点与终点之间的最短路，还能算出起点与其他所有点之间的最短路。
三.缺点
1.不能处理负权图。
四.模板
朴素算法(n^2)会被10e5的数据卡死，所以这里贴优化后的版本。（源自某位大佬）

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int inf=2147483647;
const int manx=1e4+5; //与n相对，对应顶点的个数
const int mamx=5e5+5; //与m相对，对应边的个数
priority_queue< pair<int,int> >q; 
struct node{ 
    int next,v,w;
}edge[mamx];  //边去mamx，其余取manx
bool vis[manx];  //这里的标记数组与spfa的vis数组含义不同，这里标记是否入过队列
int head[manx],d[manx];
int k=0;
int n,m,s,e; //s作为起点，e作为终点
void add(int u,int v, int w) //链式前向星存图
{
    edge[++k].next=head[u];
    edge[k].v=v;
    edge[k].w=w;
    head[u]=k;
}
void dijkstra()
{
    for(int i=1;i<=n;i++) //初始化vis d 数组
        d[i]=inf,vis[i]=0;
    d[s]=0; //s作为起点
    q.push(make_pair(0,s));
    while(q.size()){
        int x=q.top().second; //取出队头
        q.pop();
        if(vis[x]) continue; //如果点x访问过，跳过，访问下一个队头
        vis[x]=1; //访问x做标记
        for(int i=head[x];i;i=edge[i].next){
            int v=edge[i].v,w=edge[i].w;
            if(d[v]>d[x]+w){ //松弛操作，更新距离
                d[v]=d[x]+w;
                q.push(make_pair(-d[v],v)); //把更新的距离和点入队，这里距离取负变成小根堆
            }
        }
    }
}

spfa算法

一,定义（个人理解·）
SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同，为 O(VE)（百度百科）（其实就是用了队列的bfs搜索） 。
二.优点
1.用于求含负权边的单源最短路径，以及判负权环。
2.通常时间复杂度不怎么高，很容易套模板。
三.缺点（spfa已死 ）
1.复杂度相对稳定。但在稠密图中复杂度比迪杰斯特拉算法差（容易被极端数据卡死）。
4.模板
spfa算法 优先队列版本，用链式前向星存图

#include<iostream>
#include<cstdio>
#include<queue>
const long long int inf=214748647;
const int manx=1e5+5;  //与n相对，对应顶点的个数
const int mamx=5e5+5; //与m相对，对应边的个数
using namespace std;
int n,m,s,e,k=0;
int dis[manx],head[manx];
bool vis[manx]; //这里的标记是判断点是否在队列中
struct Edge{
    int next,to,dis;
}edge[mamx];
void add(int from,int to, int dis) //链式前向星
{
    edge[++k].next=head[from];
    edge[k].to=to;
    edge[k].dis=dis;
    head[from]=k;
}
void spfa()
{
    queue<int >q; //建立队列
    for(int i=1;i<=n;i++)  //初始化dis vis数组
        dis[i]=inf,vis[i]=0;
    q.push(s)；//s作为起点
    dis[s]=0；//此处开始与dij不同
    vis[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0; //出队列的时候改标记
        for(int i=head[u];i;i=edge[i].next)
        {
            int v=edge[i].to,w=edge[i].dis;
            if(dis[v]>dis[u]+w)   //如果存在边使得两顶点距离更小进行更新
            {
                dis[v]=dis[u]+w;
                if(vis[v]==0)   //如果不在队列中就入队
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    //无向图  add(v,u,w);
    }
    spfa();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
}

例题
有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到(100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终得到的s币金额数能否增加

货币的交换是可以重复多次的，所以我们需要找出是否存在正权回路，且最后得到的s金额是增加的

怎么找正权回路呢？（正权回路：在这一回路上，顶点的权值能不断增加即能一直进行松弛）

  Sample Input3 2 1 20.0

1 2 1.00 1.00 1.00 1.00
2 3 1.10 1.00 1.10 1.00
Sample OutputYES
题解
一种货币就是一个点

一个“兑换点”就是图上两种货币之间的一个兑换方式，是双边，但A到B的汇率和手续费可能与B到A的汇率和手续费不同。

唯一值得注意的是权值，当拥有货币A的数量为V时，A到A的权值为K，即没有兑换

而A到B的权值为(V-Cab)*Rab

本题是“求最大路径”，之所以被归类为“求最小路径”是因为本题题恰恰与bellman-Ford算法的松弛条件相反，求的是能无限松弛的最大正权路径，但是依然能够利用bellman-Ford的思想去解题。

因此初始化dis(S)=V 而源点到其他点的距离（权值）初始化为无穷小（0），当s到其他某点的距离能不断变大时，说明存在最大路径；如果可以一直变大，说明存在正环。判断是否存在环路，用Bellman-Ford和spfa都可以。

弗洛伊德算法

一.定义（个人理解）
一种用中转点来更新两点间的最短距离，遍历所有中转点，起点，终点；从而得出任意两点之间的最短距离的算法。
二.优点
可以求出任意两点之间的最短路，怎么样？看起来很厉害吧。
三.缺点
但时间复杂度是O(n^3)很高，只能处理小数据（1000左右，大数据必TE。
四.模板

memset( d , 0x3f , sizeof(d) );  //初始化距离
 for(int i=1 ;i<=n ;i++) d[i][i]= 0; // 同一点距离为0
 for(int i=1 ;i<=m ;i++){
  int u, v, w;
  cin>>u>> v>> w;
  a[u][v]=min( a[u][v] , w);
 }
 for(int k=1 ;k<=n ;k++) //注意k为阶段必须放在最外层
  for(int i=1 ;i<=n ;i++)
   for(int j=1 ;j<=n ;j++)
    d[i][j] = min( d[i][j] , d[i][k] +d[k][j]);

个人关于最短路的总结
刷了一小半的kuangbing的最短路专题（水题），关于最短路有如下看法。
1.最短路的题目的形式虽然可以不断变换， 但都有相应算法去解决；如求最短路（无负环）可以用迪杰斯特拉（大范围数据）或者弗洛伊德（小范围数据），判负环可以用布尔曼福德算法解决。
2.最短路题目有很多坑点， 比如说题目简单但建图很麻烦，不怎么好建图。或者是题目要求最短路中的最大边（最短路变形）。
3.学了蛮久但只是记住了基本模板和简单做法， 最短路还有待提高。