Floyd算法
题目
提示
小Ho道：“你说的很有道理，我只需要从每个节点开始使用Dijstra算法就可以了！”
小Hi摇摇头道：“解决问题不是关键，学到知识才是关键，而且知识本身也远远没有掌握学习的方法重要！”
小Ho只得答道：“好的好的，听你说便是了!”
于是小Hi便开心道：“这次要说的算法叫做Floyd算法，是一种用于求图结构上任意两点间最短距离的算法！”
小Ho嘀咕道：“你都写标题上了，能不知道么？”
小Hi强行装作没听到，继续说道：“这个算法的核心之处在于数学归纳法——MinDistance(i, j)之间最短路径中可以用到的节点是一点点增加的！”
“你这话每一个字我都听得懂，但是这句话为什么我听不懂呢……”小Ho无奈道。
“那我这么说吧，首先，最开始的时候，MinDistance(i, j)——即从第i个点到第j个点的最短路径的长度，拥有一个限制：这条路径不能经过任何节点。”小Hi道。
“那就是说如果从i个点到第j个点之间没有直接相连的边的话，这个长度就是无穷大咯？”小Ho总结道：“只需要把输入的边填进MinDistance中即可！”
“对！”小Hi满意于小Ho的上道，继续说道：“然后我放开限制，我允许MinDistance(i, j)——从第i个点到第j个点的最短路径的长度，拥有的限制，变为：这条路径仅允许经过1号节点。”
“这个也简单，对于两个节点i, j，我只需要比较MinDistance(i, j)原来的值和MinDistance(i, 1)+MinDistance(1, j)的值，取较小的一个作为新的MinDistance(i, j)就可以了——毕竟原来的MinDistance都是不经过任何节点，那么这样求出来的新的MinDistance(i, j)只有可能经过1号节点。”
“那么接下来就是关键的了，我将限制继续放宽——路径仅允许经过1、2号节点。”小Hi继续说道。
“那其实也没有任何变化吧，对于两个节点i, j，我只需要比较MinDistance(i, j)原来的值和MinDistance(i, 2)+MinDistance(2, j)的值，取较小的一个作为新的MinDistance(i, j)，之所以可以这样是因为，原来的MinDistance都是在限制“仅允许经过1号节点”下，求出来的，所以新求出来的MinDistance(i, j)也只有可能经过1、2号节点！“
“那我继续放开限制呢？”小Hi问道。
“也没有什么区别了，每放开一个新的节点k允许作为路径中的节点，就对于任意的i, j，用MinDistance(i, k)+MinDistance(k, j)去更新MinDistance(i, j)，直到1…N号节点都被添加进限制，此时也就等于没有限制了，那么这个时候的MinDistance(i, j)就是我们所想要求的值，写成伪代码就是这样！”
for k = 1 .. N
for i = 1 .. N
for j = 1 .. N
若i, j, k各不相同
MinDistance[i, j] = min{
MinDistance[i, j], MinDistance[i, k] + MinDistance[k, j]}
“看来你已经很明白了呢！”小Hi嘿嘿一笑，往鬼屋深处跑了去——那么接下来就是小Ho利用求出的最短路径，去找到小Hi的时候了！
代码
#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3,"Ofast","inline")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#define RI register int
#define re(i,a,b) for(RI i=a; i<=b; i++)
#define ms(i,a) memset(a,i,sizeof(a))
#define MAX(a,b) (((a)>(b)) ? (a):(b))
#define MIN(a,b) (((a)<(b)) ? (a):(b))
using namespace std;
typedef long long LL;
const int N=1005;
const int inf=0x3f3f3f;
int n,m;
int f[N][N];
int main() {
scanf("%d%d",&n,&m);
memset(f,inf,sizeof(f));
for(int i=1; i<=m; i++) {
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
f[u][v]=MIN(f[u][v],w);
f[v][u]=MIN(f[v][u],w);
}
for(int k=1; k<=n; k++)
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
f[i][j]=MIN(f[i][j],f[i][k]+f[k][j]);
for(int i=1; i<=n; i++) {
for(int j=1; j<=n; j++)
printf("%d ",(i==j) ? 0 : f[i][j]);
printf("\n");
}
return 0;
}
Dijkstra算法
题目
提示
小Ho想了想说道：“唔……我觉得动态规划可以做，但是我找不到计算的顺序，如果我用f[i]表示从S到达编号为i的节点的最短距离的话，我并不能够知道f[1]…f[N]的计算顺序。”
“所以这个问题不需要那么复杂的算法啦，我就稍微讲讲你就知道了！”小Hi道：“路的长度不可能为负数对不对？”
“那是自然，毕竟人类还没有发明时光机器……”小Ho点点头。
于是小Hi问道：“那么如果就看与S相邻的所有节点中与S最近的那一个S’，并且从S到S’的距离为L，那么有可能存在另外的道路使得从S到S’的距离小于L么？”
“不能，因为S’是与S相邻的所有节点中与S最近的节点，那么从S到其他相邻点的距离一定是不小于L的，也就是说无论接下来怎么走，回到L点时总距离一定大于L。”小Ho思考了一会，道。
“也就是说你已经知道了从S到S’的最短路径了是么？”小Hi继续问道。
“是的，这条最短路径的长度是L。”小Ho答道。
小Hi继续道：“那么现在，我们不妨将S同S’看做一个新的节点？称作S1，然后我就计算与S相邻或者与S’相邻的所有节点中，与S最近的哪一个节点S’’。注意，在这个过程中，与S相邻的节点与S的距离在上一步就已经求出来了，那么我要求的只有与S’相邻的那些节点与S的距离——这个距离等于S与S’的距离加上S’与这些结点的距离，对于其中重复的节点——同时与S和S’相邻的节点，取两条路径中的较小值。”
小Ho点了点头：“那么同之前一样，与S1（即S与S’节点）相邻的节点中与S’距离最近的节点如果是S’‘的话，并且这个距离是L2，那么我们可以知道S到S’'的最短路径的长度便是L2，因为不可能存在另外的道路比这个更短了。”
于是小Hi总结道：“接下来的问题不就很简单了么，只需要以此类推，每次将与当前集合相邻（即与当前集合中任意一个元素）的所有节点中离S最近的节点（这些距离可以通过上一次的计算结果推导而出）选出来添加到当前集合中，我就能够保证在每一个节点被添加到集合中时所计算的离S的距离是它与S之间的最短路径！”
“原来是这样！但是我的肚子更饿了呢！”言罢，小Ho的肚子咕咕叫了起来。
代码
Dijkstra：
#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3,"Ofast","inline")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#define RI register int
#define re(i,a,b) for(RI i=a; i<=b; i++)
#define ms(i,a) memset(a,i,sizeof(a))
#define MAX(a,b) (((a)>(b)) ? (a):(b))
#define MIN(a,b) (((a)<(b)) ? (a):(b))
using namespace std;
typedef long long LL;
const int N=1005;
const int inf=0x3f3f3f;
int n,m,s,t;
int d[N],vis[N];
int a[N][N];
void dijkstra() {
memset(vis,0,sizeof(vis));
for(int i=1; i<=n; i++) d[i]=inf;
d[s]=0;
for(int i=1; i<=n; i++) {
int k=-1;
for(int j=1; j<=n; j++)
if(!vis[j] && (k==-1 || d[k]>d[j])) k=j;
vis[k]=1;
for(int j=1; j<=n; j++)
if(!vis[j] && d[k]+a[k][j]<d[j])
d[j]=d[k]+a[k][j];
}
}
int main() {
scanf("%d%d%d%d",&n,&m,&s,&t);
memset(a,inf,sizeof(a));
for(int i=1; i<=m; i++) {
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
a[u][v]=MIN(a[u][v],w);
a[v][u]=MIN(a[v][u],w);
}
dijkstra();
printf("%d\n",d[t]==inf ? -1 : d[t]);
return 0;
}
堆优化Dijkstra：
#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3,"Ofast","inline")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#define RI register int
#define re(i,a,b) for(RI i=a; i<=b; i++)
#define ms(i,a) memset(a,i,sizeof(a))
#define MAX(a,b) (((a)>(b)) ? (a):(b))
#define MIN(a,b) (((a)<(b)) ? (a):(b))
using namespace std;
typedef long long LL;
const int N=1005;
const int M=10005;
const int inf=0x3f3f3f;
struct Edge {
int to,nt,w;
} e[M<<1];
struct Node {
int index,dist;
bool operator < (const Node &rhs) const {
return dist>rhs.dist;
}
};
int n,m,s,t,cnt;
int d[N],vis[N],h[N];
priority_queue<Node> q;
inline void add(int u,int v,int w) {
e[++cnt].to=v;
e[cnt].nt=h[u];
e[cnt].w=w;
h[u]=cnt;
}
void dijkstra() {
memset(vis,0,sizeof(vis));
for(int i=1; i<=n; i++) d[i]=inf;
d[s]=0;
q.push((Node){
s,0});
while(!q.empty()) {
Node x=q.top();
q.pop();
int u=x.index;
if(vis[u]) continue;
vis[u]=1;
for(int i=h[u]; i; i=e[i].nt) {
int v=e[i].to;
if(d[v]>d[u]+e[i].w) {
d[v]=d[u]+e[i].w;
q.push((Node){
v,d[v]});
}
}
}
}
int main() {
scanf("%d%d%d%d",&n,&m,&s,&t);
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);
}
dijkstra();
printf("%d\n",d[t]==inf ? -1 : d[t]);
return 0;
}
Spfa算法
题目
提示
“唔……地点很多，道路很少，这个鬼屋是一个稀疏图，既然这一点被特地标注出来，那么想来有其作用的咯？”小Ho道。
“是的，正好有一种最短路径算法，它的时间复杂度只和边的条数有关，所以特别适合用来解决这种边的数量很少的最短路问题！”小Hi点了点头道：“它就是SPFA算法，即Shortest Path Faster Algorithm。”
“听上去很厉害的样子，但是实际上怎么做的呢？”小Ho问道。
“你会用宽度优先搜索写这道题么？”小Hi反问道。
“这个当然会啊，构造一个队列，最开始队列里只有(S, 0)——表示当前处于点S，从点S到达该点的距离为0，然后每次从队首取出一个节点(i, L)——表示当前处于点i，从点S到达该点的距离为L，接下来遍历所有从这个节点出发的边(i, j, l)——表示i和j之间有一条长度为l的边，将(j, L+l)加入到队尾，最后看所有遍历的(T, X)节点中X的最小值就是答案咯~”小Ho对于搜索已经是熟稔于心，张口便道。
“SPFA算法呢，其实某种意义上就是宽度优先搜索的优化——如果你在尝试将(p, q)加入到队尾的时候，发现队列中已经存在一个(p, q’)了，那么你就可以比较q和q’：如果q>=q’，那么(p, q)这个节点实际上是没有继续搜索下去的必要的——算是一种最优化剪枝吧。而如果q<q’，那么(p, q’)也是没有必要继续搜索下去的——但是它已经存在于队列里了怎么办呢？很简单，将队列中的(p, q’)改成(p, q)就可以了！”
“那我该怎么知道队列中是不是存在一个(p, q’)呢？” <额，维护一个position[1…n]的数组就可以了，如果不在队列里就是-1，否则就是所在的位置！”< p>
“所以说这本质上就是宽度优先搜索的剪枝咯？”小Ho问道。
小Hi笑道：“怎么可能！SPFA算法其实是BELLMAN-FORD算法的一种优化版本，只不过在成型之后可以被理解成为宽度优先搜索的！这个问题，我们会在之后好好讲一讲的！”
代码1
用vector实现。
#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3,"Ofast","inline")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#define RI register int
#define re(i,a,b) for(RI i=a; i<=b; i++)
#define ms(i,a) memset(a,i,sizeof(a))
#define MAX(a,b) (((a)>(b)) ? (a):(b))
#define MIN(a,b) (((a)<(b)) ? (a):(b))
using namespace std;
typedef long long LL;
const int N=1e5+5;
const int inf=1e9;
int n,m,s,t;
int v[N],d[N];
vector<int> a[N],b[N];
queue<int> q;
int spfa() {
for(int i=1; i<=n; i++) d[i]=inf;
q.push(s);
v[s]=1;
d[s]=0;
while(!q.empty()) {
int x=q.front();
q.pop();
v[x]=0;
for(int i=0; i<a[x].size(); i++) {
int tp=a[x][i];
if(d[tp]>d[x]+b[x][i]) {
d[tp]=d[x]+b[x][i];
if(!v[tp]) {
q.push(tp);
v[tp]=1;
}
}
}
}
if(d[t]==inf) d[t]=-1;
return d[t];
}
int main() {
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1; i<=m; i++) {
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
a[u].push_back(v);
b[u].push_back(w);
a[v].push_back(u);
b[v].push_back(w);
}
printf("%d\n",spfa());
return 0;
}
代码2
用链式前向星实现。
#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3,"Ofast","inline")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#define RI register int
#define re(i,a,b) for(RI i=a; i<=b; i++)
#define ms(i,a) memset(a,i,sizeof(a))
#define MAX(a,b) (((a)>(b)) ? (a):(b))
#define MIN(a,b) (((a)<(b)) ? (a):(b))
using namespace std;
typedef long long LL;
const int N=1e5+5;
const int M=1e6+5;
const int inf=1e9;
struct Edge {
int to,nt,w;
} e[M<<1];
int n,m,s,t,cnt;
int v[N],d[N],h[N];
queue<int> q;
inline void add(int a,int b,int c) {
e[++cnt]=(Edge){
b,h[a],c};
h[a]=cnt;
}
int spfa() {
for(int i=1; i<=n; i++) d[i]=inf;
q.push(s);
v[s]=1;
d[s]=0;
while(!q.empty()) {
int x=q.front();
q.pop();
v[x]=0;
for(int i=h[x]; i; i=e[i].nt) {
int tp=e[i].to;
if(d[tp]>d[x]+e[i].w) {
d[tp]=d[x]+e[i].w;
if(!v[tp]) {
q.push(tp);
v[tp]=1;
}
}
}
}
if(d[t]==inf) d[t]=-1;
return d[t];
}
int main() {
scanf("%d%d%d%d",&n,&m,&s,&t);
memset(h,-1,sizeof(h));
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);
}
printf("%d\n",spfa());
return 0;
}