最短路径
常用算法：dijkstra、bellman-ford、spfa、floyd
一、Dijkstra
dijkstra用于解决单源点最短路径问题，对应所有边权都是非负的情况。
对于有负数用spfa最好。其次用STL中的优先队列对待查的d[u]处理可以节省时间。
dijkstra思路：设置集合S存放已被访问的顶点，然后执行n次下面的两个步骤：
1）每次从集合v-s中选择与起点s的最短距离最小的一个顶点（记为u），访问并加入集合s。
2）之后，令顶点u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离。
具体实现要点：
1）集合s可用bool数组vis[]
2）int型数组d[]表示起点s到达顶点vi的最短距离，初始时除了起点s的d[s]赋为0，其余顶点为很大的数
（0x3fffffff，不可0x7fffffff，因为相加时可能会爆掉）
伪码：
Dijkstra(G,d[],s)
{
初始化;
for(循环n次){
u=使d[u]最小的还未被访问的顶点的标号;
记u已被访问;
for(从u出发能到达的所有顶点v)
{
if(v未被访问&&以u为中介点使s到顶点v的最短距离d[v]更优){
优化d[v];
}
}
}
}
邻接矩阵与邻接表实现时的主要区别：邻接矩阵要枚举所有顶点来查看v是否可由u到达；邻接表可以直接得到u能达到v。
1）邻接矩阵：适用于点数不大
const int maxv=1000;
const int inf=0x3fffffff;
int n,g[maxv][maxv];
int d[maxv];
bool vis[maxv]={false};
void Dijkstra(int s)
{
fill(d,d+maxv,inf);//fill函数将整个d数组赋为inf；慎用memset
d[s]=0;//起点s到达自身的距离为0
//u=使d[u]最小的还未被访问的顶点的标号;
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++)
{
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为中介点可以使d[v]更优
if(vis[v]==false && g[u][v]!=inf && d[u]+g[u][v]<d[v])
d[v]=d[u]+g[u][v];
}
}
}
2）邻接表
const int maxv=1000;
const int inf=0x3fffffff;
//区别一：定义不一样
struct node
{
int v,dis;//v为边的目标顶点，dis为边权
};
vector<node> adj[maxv];
int n;
int d[maxv];
bool vis[maxv]={false};
void Dijkstra(int s)
{
fill(d,d+maxv,inf);//fill函数将整个d数组赋为inf；慎用memset
d[s]=0;//起点s到达自身的距离为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++)
{
if(vis[j]==false && d[j]<Min){
u=j;
Min=d[j];
}
}
//找不到小于inf的d[u],说明剩下的顶点和起点s不连通
if(u==-1) return;
vis[u]=true;
//区别二：vector操作
for(int j=0;j<adj[u].size();j++)
{
int v=adj[u][j].v;
//如果v未访问 && u能到达v && 以u为中介点可以使d[v]更优
if(vis[v]==false && d[u]+adj[u][v].dis<d[v])
d[v]=d[u]+adj[u][v].dis
}
}
}
升级：
1）如何解决最短路径计算，即把每一段都能加上。采用一个pre[]数组记录前驱结点即可。此时就可以用DFS或者并查集访问这个数组找出路径。
void DFS(int s,int v)
{
if(v==s){
printf("%d\n",s);
return;
}
DFS(s,pre[v]);
//从最深处return回来，输出每一层的顶点号。
printf("%d\n",v);
2）优化：
记录多个前驱结点：vector pre[maxv];也可以用set以便于查询某个顶点u是否在顶点v的前驱中，使用pre[v].count(u)十分方便。
可使用dijkstra记录多组最优路径：
void Dijkstra(int s)
{
fill(d,d+maxv,inf);//fill函数将整个d数组赋为inf；慎用memset
d[s]=0;//起点s到达自身的距离为0
//u=使d[u]最小的还未被访问的顶点的标号;
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++)
{
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为中介点可以使d[v]更优
if(vis[v]==false && g[u][v]!=inf)
{
if(d[v]>d[u]+g[u][v]){
d[v]=d[u]+g[u][v];
pre[v].clear();
pre[v].push_back(u);
}
else if(d[v]==d[u]+g[u][v]){
pre[v].push_back(u);
}
}
}
}
}
3)优化:找出第二标尺最优的路径
方案：a、设置第二标尺optvalue
b、记录最优路径的数组path
c、临时记录DFS遍历到叶子结点时的路径temppath
vector<int> pre[maxv];
vector<int> path,temppath;
void DFS(int v)
{
if(v==st)//到达叶子节点st，即路径的起点
{
tempath.push_back(v);//将起点st加入临时路径temppath的最后面
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 value=0;
for(int i=temppath.szie()-1;i>=0;i--)
{
int id=temppath[i],nextid=temppath[i-1];
value+=v[id][nextid];
}
点权之和
int value=0;
for(int i=temppath.size()-1;i>=0;i--)
{
int id=temppath[i];
value+=w[id];
}
*/
2）变式 多标尺（第一标尺：距离）
==a、给每条边增加一个边权（比如花费），在有多条最短路径时找花费最小。
b、给每个点加点权，（比如物资），在最短路径有多条时，求路径上点权最大的情况。
c、直接问有多少条最短路径。
修改核心：增加一个数组存放新增的边权或者点权或最短路径条数，然后修改优化d[v]。
变式：
a、新增边权。用cost[u][v]表示u->v的花费，并增加一个数组c[]（表示起点s到顶点u的最少花费为c[u]），初始化时只有c[s]为0、其余c[u]为inf。==
修改如下：
for(int v=0;v<n;v++)
{
if(vis[v]==false && g[u][v]!=inf)
{
if(d[u]+g[u][v]<d[v])
{
d[v]=d[u]+g[u][v];
c[v]=c[u]+cost[u][v];
}
else if(d[u]+g[u][v]==d[v] && c[u]+cost[u][v]<c[v])
c[v]=c[u]+cost[u][v];
}
}
b、新增点权。同理weight[u]当物资更大时则优化
for(int v=0;v<n;v++)
{
if(vis[v]==false && g[u][v]!=inf)
{
if(d[u]+g[u][v]<d[v])
{
d[v]=d[u]+g[u][v];
w[v]=w[u]+weight[v];
}
else if(d[u]+g[u][v]==d[v] && w[u]+weight[v]>w[v])
w[v]=w[u]+weight[v];
}
}
c、求最短路径条数
增加一个num[]记录到该点的最短路径数
for(int v=0;v<n;v++)
{
if(vis[v]==false && g[u][v]!=inf)
{
if(d[u]+g[u][v]<d[v])
{
d[v]=d[u]+g[u][v];
num[v]=num[u];
}
else if(d[u]+g[u][v]==d[v])
num[v]+=num[u];
}
}
二、Bellman-ford和Spfa
解决有负权的最短路径
BF解决单源最短路径问题。如果图中有负环，且从源点可以到达，那么就会影响最短路径的求解；但如果图中的负环无法从源点出发到达，则最短路径的求解不会受影响。
BF：存在从源点可达的负环，那么函数将返回false，数组中d[]（记录源点u到v的最短距离）不再存储最短路径。
其次，与dijkstra的不同时 每次遍历的是边 ——邻接表最适合！最后再把全部边遍历一遍，看是否有使原假设（d[]中存储最优距离）不成立（即再次遍历仍然有d[u]+length[u->v]<d[v]成立），那么有负环。
代码：
struct Node
{
int dis,v;
};
vector<Node> adj[maxv];
int n,d[maxv];
bool bellman(int s)
{
fill(d,d+maxv,inf);
d[s]=0;
for(int i=0;i<n-1;i++) //n个顶点，只需要检查n-1个边即可
{
for(int u=0;u<n;u++)
{
for(int j=0;j<n;j++)
{
int v=adj[u][j].v;
int di=adj[u][j].dis;
if(d[u]+di<d[v]) d[v]=di+d[u];
}
}
}
//负环判断
for(int u=0;u<n;u++)
{
for(int j=0;j<adj[u].size();j++)
{
int v=adj[u][j].v;
int di=adj[u][j].dis;
if(d[u]+di<d[v])return false;
}
}
return true;
}
对于PAT [1003]使用BF全部边访问的方法：
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
const int maxv=510;
const int inf=100000000;
struct Node
{
int dis,v;
Node(int _v,int _dis):v(_v),dis(_dis) {}
};
vector<Node> adj[maxv];
int n,d[maxv],m,st,ed,weight[maxv],w[maxv],num[maxv];
set<int> pre[maxv];
bool bellman(int s)
{
fill(d,d+maxv,inf);
memset(w,0,sizeof(w));
memset(num,0,sizeof(num));
d[s]=0;
w[s]=weight[s];
num[s]=1;
for(int i=0;i<n-1;i++)
{
for(int u=0;u<n;u++)
{
for(int j=0;j<n;j++)
{
int v=adj[u][j].v;
int di=adj[u][j].dis;
if(d[u]+di<d[v]) {
d[v]=di+d[u];
w[v]=w[u]+weight[v];
num[v]=num[u];
pre[v].clear();
pre[v].insert(u);
}
else if(d[u]+di==d[v]){
if(w[u]+weight[v]>w[v]) w[v]=weight[v]+w[u];
pre[v].insert(u);
num[v]=0;
set<int>::iterator it;
for(it=pre[v].begin();it!=pre[v].end();it++) num[v]+=num[u];
}
}
}
}
}
int main()
{
scanf("%d %d %d %d",&n,&m,&st,&ed);
for(int i=0;i<n;i++) scanf("%d",&weight[i]);
int u,v,wt;
for(int i=0;i<m;i++){
scanf("%d %d %d",&u,&v,&wt);
adj[u].push_back(Node(v,wt));
adj[v].push_back(Node(u,wt));
}
bellman(st);
printf("%d %d",num[ed],w[ed]);
return 0;
}
优化：
1）难点：统计最短路径的条数。 set pre[maxv];当遇到一条已有最短路径长度相同的路径时，必须重新计算最短路径条数。
2）减少O（VE）的时间复杂度：分析——（核心）只有当某个顶点u的d[u]值改变时，从它出发的边的邻接点v的d[v]才可能改变。利用队列反复进行出队和入队操作，当超过v-1时，说明有负环。
这就是SPFA算法。其期望时间复杂度是O（kE），如果图中有从源点可达的负环，，就会退化会O（VE）。
如果负环从源点不可达，则需要添加一个辅助顶点C，并添加一条从源点到达C的有向边及V-1条从C到达除源点外各顶点的有向边才能判断负环是否存在（解释：简化为子图A五负环，子图B有负环，则需要一个顶点C构成一个大图，才能使用）
伪码：
queue<int> q;
源点s入队;
while(队列非空){
取出队首元素;
for(u的所有邻接边u->v){
if(d[u]+dis<d[v])
{
d[v]=d[u]+dis;
if(v当前不在队列)
{
v入队；
if(v入队次数大于n-1){
说明有可达负环,return;
}
}
}
}
}
struct Node
{
int dis,v;
};
vector<Node> adj[maxv];
int n,d[maxv];
bool inq[maxv];
bool spfa(int s)
{
//初始化
memset(inq,false,sizeof(inq));
memset(num,0,sizeof(num));
fill(d,d+maxv,inf);
//从源点开始、
queue<int> q;
q.push(s);
inq[s]=true;
num[s]++; //学习1：源点入队次数加1
d[s]=0;
//主体部分
while(!q.empty())
{
int u=q.front();
q.pop();
inq[u]=false; //学习1：设置u为不在队列中
//遍历u的所有邻接边v
for(int j=0;j<adj[u].size();j++)
{
int v=adj[u].v;
int di=adj[u].dis;
//学习2：松弛操作
if(d[u]+di<d[v])
{
d[v]=di+d[u];
if(!inq[v])
{
q.push(v);
inq[v]=true;
num[v]++;
if(num[v]>=n) return false;
}
}
}
}
return true;
}
对于SPFA的优化：
==1）优先队列替换队列
2）队列替换成双端队列，使用SLF优化和LLL优化
3）DFS版的SPFA，bfs适合在一些拓扑关系强的图中使用，但其缺点在于破坏了拓展的延续性 ==
三、Floyd
Floyd非常适合用邻接矩阵。全源4最短路问题
原理经过顶点k使得i->j的距离缩短，即d[i][k]+d[k][j]<d[i][j]
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];
}
}
}
}