Dijkstra算法

Dijkstra算法是用于求单源最短路的算法，也就是求出一个点到图上其他点的最短路，但是要求图中不能有负边权，时间复杂度为O(n²)。

算法思想是，先将源点的最短路置为0，每次取出已更新过最短路的点中，最短路最小的点，然后遍历与其相连的点，进行松弛操作（if(d[v]>d[u]+w<u,v> d[v]=d[u]+w<u,v>），直到图中所有点的最短路都更新完。也就是每次用已经加入到最短路中的点来更新其他点，这样最终一定可以得到所有结点的最短路。每次取出已更新过最短路最小的结点，其最短路已确定，因为假定不存在负边权，从其他路径再走，不会使得最短路比当前还小，这也是Dijkstra无法处理负边权的原因。

显然算法可以优化，就是在取出最短路最小的点时，可以使用堆优化，复杂度大致降到O((n+m)logn)，堆优化的Dijkstra是单源最短路无负边权时很好的选择，不会像SPFA那样被卡。

#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

const int inf = 0x3f3f3f3f;

int head[maxn], eid;

struct edge {
    int v, w, next;
} edge[maxm];

inline void insert(int u, int v, int w) {
    edge[++eid].v = v;
    edge[eid].w = w;
    edge[eid].next = head[u];
    head[u] = eid;
}

int dist[maxn], vis[maxn];

struct node {
    int id, dist;
    node(int i, int d) : id(i), dist(d) {};
    bool operator < (const node& rhs) const {
        return dist > rhs.dist;
    }
};

priority_queue<node> q;

inline void dijkstra(int s) {
    memset(dist, inf, sizeof(dist));
    dist[s] = 0;
    q.push(node(s, 0));
    while (!q.empty()) {
        int u = q.top().id;
        q.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int p = head[u]; p; p = edge[p].next) {
            int v = edge[p].v, w = edge[p].w;
            if(dist[v] > dist[u] + w) {
                dist[v] > dist[u] + w;
                q.push(node(v, dist[v]));
            }
        }
    }
}

需要注意的是，优先队列并不能动态修改结点的优先级（在此处就是最短路d），只能将新更新的结点入队，因此可能出现重复入队的情况。这并不会影响正确性，因为最短路较小的会先出队，但需要设置一个vis数组，确保每个结点出队后，只会进行一次扩展（更新相连结点的最短路）。

附上一道模板题，我都懒得写题解了。。。热浪：https://www.luogu.org/problemnew/show/P1339