Dijksatr算法是典型最短路算法,用于计算一个节点到其他所有节点的最短路径,主要特点是以起始点为中心向外层层扩展,直到拓展到终点为止。
那么dijkstra算法有什么特点呢?
(1):单源最短路径算法,时间复杂度:O(n^2)
(2)有向无向图都可以
(3)边的权值不能为负数
设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , 就将加入到集合S中,直到全部顶点都加入到S中,算法就结束了),第二组为其余未确定最短路径的顶点集合(用U表示),按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中,总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外,每个顶点对应一个距离,S中的顶点的距离就是从v到此顶点的最短路径长度,U中的顶点的距离,是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
原理图:
3.迪杰斯特拉算法的实现过程
①先取一点v[0]作为起始点,初始化dis[i],d[i]的值为v[0]到其余点v[i]的距离w[0][i],如果直接相邻初始化为权值,否则初始化为无限大;
②将v[0]标记,vis[0] = 1(vis一开始初始化为0);
③找寻与v[0]相邻的最近点v[k],将v[k]点记录下来,v[k]与v[0]的距离记为min;
④把v[k]标记,vis[k]=1;
⑤查询并比较,让dis[j]与min+w[k][j]进行比较,判断是直接v[0]连接v[j]短,还是经过v[k]连接v[j]更短,即dis[j]=MIN(dis[j],min+w[k][j]);
⑥继续重复步骤③与步骤⑤,知道找出所有点为止。
#include <stdio.h>
#include <queue>
#include <set>
#define inf 0x3f3f3f3f
using namespace std;
int maze[1010][1010],d[1010],n;
void dijkstra()
{
int vis[1010]={0},x;
for(int i=1;i<=n;i++)
d[i]=maze[i][1];
vis[1]=1;
for(int i=1;i<n;i++)
{
x=-1;
for(int j=1;j<=n;j++)
{
if(!vis[j]&&(x==-1||d[j]<d[x]))
x=j;
}
vis[x]=1;
for(int j=1;j<=n;j++)
{
if(!vis[j])
d[j]=min(d[j],d[x]+maze[j][x]);
}
}
}
int main()
{
int i,j,t;
scanf("%d%d",&t,&n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
maze[i][j]=(i==j?0:inf);
for(i=0;i<t;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
if(w<maze[u][v])//双向路径选最短的那一条
maze[u][v]=maze[v][u]=w;
}
dijkstra();
printf("%d\n",d[n]);
return 0;
}
Dijkstra 单源最短路 邻接矩阵形式 双路径信息
/*
* 单源最短路径,dijkstra算法,邻接矩阵形式,复杂度为O(n^2)
* 两点间距离存入map[][],两点间花费存入cost[][]
* 求出源st到所有点的最短路径及其对应最小花费
* 返回各点的最短路径lowdis[]以及对应的最小花费lowval[]
* 可更改路径权类型,但是权值必须为非负,下标1~n
*/
const int MAXN = 1010;
const int INF = 0x3f3f3f3f;
int n, m;
int lowdis[MAXN];
int lowval[MAXN];
int visit[MAXN];
int map[MAXN][MAXN];
int cost[MAXN][MAXN];
void dijkstra(int st)
{
int temp = 0;
for (int i = 1; i <= n; i++)
{
lowdis[i] = map[st][i];
lowval[i] = cost[st][i];
}
memset(visit, 0, sizeof(visit));
visit[st] = 1;
for (int i = 1; i < n; i++)
{
int MIN = INF;
for (int j = 1; j <= n; j++)
{
if (!visit[j] && lowdis[j] < MIN)
{
temp = j;
MIN = lowdis[j];
}
}
visit[temp] = 1;
for (int j = 1; j <= n; j++)
{
if (!visit[j] && map[temp][j] < INF)
{
if (lowdis[j] > lowdis[temp] + map[temp][j])
{
lowdis[j] = lowdis[temp] + map[temp][j];
lowval[j] = lowval[temp] + cost[temp][j];
}
else if (lowdis[j] == lowdis[temp] + map[temp][j])
{
if (lowval[j] > lowval[temp] + cost[temp][j])
{
lowval[j] = lowval[temp] + cost[temp][j];
}
}
}
}
}
return ;
}
Dijkstra 起点Start 结点有权值
st int inf = 0x3f3f3f3f;
int num[M]; // 结点权值
int map[M][M]; // 图的临近矩阵
int vis[M]; // 结点是否处理过
int ans[M]; // 最短路径结点权值和
int dis[M]; // 各点最短路径花费
int n, m, Start, End; // n结点数,m边数,Start起点,End终点
void Dij(int v)
{
ans[v] = num[v];
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; ++i)
{
if (map[v][i] < inf)
{
ans[i] = ans[v] + num[i];
}
dis[i] = map[v][i];
}
dis[v] = 0;
vis[v] = 1;
for (int i = 1; i < n; ++i)
{
int u = 0, min = inf;
for (int j = 0; j < n; ++j)
{
if (!vis[j] && dis[j] < min)
{
min = dis[j];
u = j;
}
}
vis[u] = 1;
for (int k = 0; k < n; ++k)
{
if (!vis[k] && dis[k] > map[u][k] + dis[u])
{
dis[k] = map[u][k] + dis[u];
ans[k] = ans[u] + num[k];
}
}
for (int k = 0; k < n; ++k)
{
if (dis[k] == map[u][k] + dis[u])
{
ans[k] = max(ans[k], ans[u] + num[k]);
}
}
}
printf("%d %d\n", dis[End], ans[End]); // 输出终点最短路径花费、最短路径结点权值和
}
int main()
{
scanf("%d%d%d%d", &n, &m, &Start, &End);
for (int i = 0; i < n; ++i)
{
scanf("%d", &num[i]);
}
memset(vis, 0, sizeof(vis));
memset(map, 0x3f, sizeof(map));
for (int i = 0; i < m; ++i)
{
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (map[x][y] > z)
{
map[x][y] = z;
map[y][x] = z;
}
}
Dij(Start);
return 0;