解决单源最短路问题的优秀算法,堆优化后时间复杂度降到O((m+n)logn)。
#include
#include
#include
#include
#include
#include
#include
#include
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 10003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m;
int dis[N];
struct edge
{
int to,cost;
};
vectorE[N]; //这里以邻接表为例
struct node
{ //走到at节点的最短路为path
int at,path;
bool operator<(const node &_)const
{
return path>_.path; //path小的先出
}
};
void dijkstra(int s)
{
FOR(i,1,n)dis[i]=INF;
dis[s]=0;
priority_queueq;
while(!q.empty())q.pop(); //使用前测试STL是好习惯
q.push((node){s,0}); //把起点先加入队列
while(!q.empty())
{
node now=q.top();q.pop(); //取距离最小的节点
int u=now.at;
if(dis[u]dis[u]+w)
{
dis[v]=dis[u]+w;
q.push((node){v,dis[v]});
}
}
}
return;
}
int main()
{
int s;
scanf("%d%d%d",&n,&m,&s);
FOR(i,1,m)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
E[u].push_back((edge){v,w});
}
dijkstra(s);
FOR(i,1,n)printf("%d ",dis[i]);
printf("\n");
return 0;
}
Dj算法的流程如上,其实不难理解。从源点出发开始松弛,然后寻找没有作过起点的节点中距离最小的,作为新的起点进行下一轮操作。特别要提示的是,Dj算法只适用于正权图,对于有负边出现的图不好使,这也能解释为什么凡是标红的点一定是找到最短路的。
而堆优化其实是优化了寻找距离最小节点这步,从代码中不难看出,如果出现负边,就会出现死循环。因为已经作过起点的节点还会作无数次起点。
实际上是Bellman-Ford算法的优化,时间复杂度为O(kn),k一般小于等于2n.
#include
#include
#include
#include
#include
#include
#include
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 10003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m,tot;
int head[N],dis[N];
struct edge
{
int next,to,w; //E[i].next是边i的“下一条”边的序号
}E[M];
void add(int u,int v,int w) //这里以前向星为例
{
E[++tot].next=head[u]; //head[u]是以u为起点的“第一条”边的序号
E[tot].to=v;
E[tot].w=w;
head[u]=tot;
return;
}
void spfa(int s)
{
bool vis[N]={0};
vis[s]=1; //vis[i]表示i是否在队列中
queueq;
while(!q.empty())q.pop();
q.push(s);
FOR(i,1,n)dis[i]=INF;
dis[s]=0;
while(!q.empty())
{
int u=q.front();q.pop();
vis[u]=0;
for(int i=head[u];i!=0;i=E[i].next) //前向星遍历
{
int v=E[i].to,w=E[i].w;
if(dis[v]>dis[u]+w)
{
dis[v]=dis[u]+w;
if(!vis[v])
{
vis[v]=1;
q.push(v);
}
}
}
}
return;
}
int main()
{
int s;
scanf("%d%d%d",&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);
}
spfa(s);
FOR(i,1,n)printf("%d ",dis[i]);
printf("\n");
return 0;
}
spfa比较浅显,这里重点介绍前向星。
前向星是一种存图方式,它将起点相同的边互相用next链起(而邻接表是直接将它们存在同一个vector中),每次加入新的边(u,v)都会链上上一条起点为u的边,然后更新起点为u的“第一条”边。
这种存储方式,使得访问边的顺序与输入顺序相反,不过这也没关系。
弗洛伊德算法是解决多源最短路问题的优秀算法,基于动态规划,此算法的精妙之处在于核心代码只有4-5行
#include
#include
#include
#include
#include
#include
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 1003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m;
int dis[N][N]; //此算法用邻接矩阵存边
int main()
{
int s;
scanf("%d%d%d",&n,&m,&s);
FOR(i,1,n)FOR(j,1,n)dis[i][j]=INF;
FOR(i,1,n)dis[i][i]=0;
FOR(i,1,m)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
dis[u][v]=min(dis[u][v],w);
}
FOR(k,1,n) //Floyd
FOR(i,1,n)
FOR(j,1,n)
if(dis[i][k]!=INF && dis[k][j]!=INF) //这里因为题目需要,事实上如果2INF
弗洛伊德时间复杂度达到O(n³),当n在100以内时求多源最短路问题可用它很方便的解决。