最短路径算法之Dijkstra算法
Dijkstra算法
概述
Dijksatr算法是典型最短路算法,用于计算一个节点到其他所有节点的最短路径,主要特点是以起始点为中心向外层层扩展,直到拓展到终点为止。
算法描述
设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , 就将加入到集合S中,直到全部顶点都加入到S中,算法就结束了),第二组为其余未确定最短路径的顶点集合(用U表示),按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中,总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外,每个顶点对应一个距离,S中的顶点的距离就是从v到此顶点的最短路径长度,U中的顶点的距离,是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
算法模板
Dijkstra 单源最短路 邻接矩阵形式
const int MAXN = 1010;
const int INF = 0x3f3f3f3f;
bool vis[MAXN];
int pre[MAXN];
void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg)
{
for (int i = 0; i < n; i++)
{
lowcost[i] = INF;
vis[i] = false;
pre[i] = -1;
}
lowcost[beg] = 0;
for (int j = 0; j < n; j++)
{
int k = -1;
int min = INF;
for (int i = 0; i < n; i++)
{
if (!vis[i] && lowcost[i] < min)
{
min = lowcost[i];
k = i;
}
}
if (k == -1)
{
break;
}
vis[k] = true;
for (int i = 0; i < n; i++)
{
if (!vis[i] && lowcost[k] + cost[k][i] < lowcost[i])
{
lowcost[i] = lowcost[k] + cost[k][i];
pre[i] = k;
}
}
}
}
Dijkstra 单源最短路 邻接矩阵形式 双路径信息
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 结点有权值
#define M 505
const int inf = 0x3f3f3f3f;
int num[M];
int map[M][M];
int vis[M];
int ans[M];
int dis[M];
int 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;
}
Dijkstar 堆优化
const int INF = 0x3f3f3f3f;
const int MAXN = 1000010;
struct qNode
{
int v;
int c;
qNode(int _v = 0, int _c = 0) : v(_v), c(_c) {}
bool operator < (const qNode &r) const
{
return c > r.c;
}
};
struct Edge
{
int v;
int cost;
Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost) {}
};
vector<Edge> E[MAXN];
bool vis[MAXN];
int dist[MAXN];
void Dijkstra(int n, int start)
{
memset(vis, false, sizeof(vis));
memset(dist, 0x3f, sizeof(dist));
priority_queue<qNode> que;
while (!que.empty())
{
que.pop();
}
dist[start] = 0;
que.push(qNode(start, 0));
qNode tmp;
while (!que.empty())
{
tmp = que.top();
que.pop();
int u = tmp.v;
if (vis[u])
{
continue;
}
vis[u] = true;
for (int i = 0; i < E[u].size(); i++)
{
int v = E[tmp.v][i].v;
int cost = E[u][i].cost;
if (!vis[v] && dist[v] > dist[u] + cost)
{
dist[v] = dist[u] + cost;
que.push(qNode(v, dist[v]));
}
}
}
}
void addEdge(int u, int v, int w)
{
E[u].push_back(Edge(v, w));
}