Dijsktra算法堆优化

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int inf = 1e9 + 7;
int n, m, dis[51];
int head[51], cnt = 0;

struct Edge {
    int to, next, w;
}e[101];

struct Node {
    int pos, w;
    Node(int p, int wt) :pos(p), w(wt) {};
    bool operator<(const Node& a)const {
        return w > a.w;
    }
};

void add_edge(int u, int v, int w) {
    e[++cnt].to = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt;
}

void dij() {
    priority_queue<Node> q;
    fill(dis + 2, dis + 2 + n, inf);
    q.push(Node(1,0));
    while (q.size()) {
         Node tmp = q.top(); q.pop();
         for (int i = head[tmp.pos]; i; i = e[i].next) {
             int v = e[i].to, w = e[i].w;
             //不需要对已选入的结点进行讨论的原因是dis[v]已经存储的是最小值，后面再遇到重复的都不会比它小
             if (dis[tmp.pos] + w < dis[v]) {
                 dis[v] = dis[tmp.pos] + w;
                 q.push({ v,dis[v]});
             }
         }
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int u, v, w; cin >> u >> v >> w;
        add_edge(u, v, w);
    }
    dij();
    for (int i = 2; i <= n; ++i) {
        cout << dis[i] << ' ';
    }
    return 0;
}

prim算法和dijsktra算法虽然求的东西不同，但是思路和算法的结构都非常相似，在这里大致记录一下我现阶段对于它们不同点的理解：

• prim算法的dis数组中存储的是最小生成树的每条边的长度（具体是哪条边由算法过程确定），而dijsktra算法的dis数组存储的是从源点出发到第i个节点的最短路径长度。
• 堆优化也由细微的差别，prim算法要借助辅助数组vis，判断堆顶的节点是否已经并入最小生成树，如果已经并入，则出队。而dijsktra算法不需要辅助数组，因为假如一个点已经确定了最短路径，那么接下来的路径长度都不可能小于dis数组中存储的值，所以碰到已确定路径的结点直接出队即可。

void prim() {
    fill(dis + 1, dis + 1 + n, inf);
    priority_queue<Node> q;
    q.push({ 1,0 });
    while (q.size()) {
        Node tmp = q.top(); q.pop();
        if (!vis[tmp.pos]) {
            vis[tmp.pos] = 1; ans += tmp.w;
            for (int i = head[tmp.pos]; i; i = e[i].next) {
                int v = e[i].to, w = e[i].w;
                if (!vis[v]) {
                    if (w < dis[v]) {
                        dis[v] = w;
                        q.push({ v,dis[v] });
                    }
                }
            }
        }
    }
}

void dij() {
    priority_queue<Node> q;
    fill(dis + 2, dis + 2 + n, inf);
    q.push(Node(1,0));
    while (q.size()) {
         Node tmp = q.top(); q.pop();
         for (int i = head[tmp.pos]; i; i = e[i].next) {
             int v = e[i].to, w = e[i].w;
             //不需要对已选入的结点进行讨论的原因是dis[v]已经存储的是最小值，后面再遇到重复的都不会比它小
             if (dis[tmp.pos] + w < dis[v]) {
                 dis[v] = dis[tmp.pos] + w;
                 q.push({ v,dis[v]});
             }
         }
    }
}