最短路迪杰斯特拉回炉重造

发现很多都忘了，重新看看。

找了个简单的最短路板子题测试代码:POJ 2387

普通版迪杰斯特拉

迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。

显然是$O(n^2)$的时间复杂度。

代码：

ll mp[1010][1010];
ll dis[1010], vis[1010];

int main()
{
    fill(mp[0], mp[0] + 1010 * 1010, INF);
    for (int i = 1; i <= 1000; i++)
        mp[i][i] = 0;
    ll t, n;
    cin >> t >> n;
    while (t--)
    {
        ll u, v, w;
        cin >> u >> v >> w;
        mp[u][v] = mp[v][u] = min(mp[u][v], w);
    }
    fill(dis, dis + 1010, INF);
    dis[1] = 0;
    for (int i = 1; i <= n; i++)
    {
        ll minn = INF, v = -1;
        for (int j = 1; j <= n; j++) //每次找距离起点最近的且没有用过的点v来进行更新
        {
            if (dis[j] < minn && !vis[j])
            {
                minn = dis[j];
                v = j;
            }
        }
        if (v == -1)
            break;
        vis[v] = 1;
        for (int j = 1; j <= n; j++) //用找到的点v来更新其他点
            if (dis[j] > dis[v] + mp[v][j])
                dis[j] = dis[v] + mp[v][j];
    }
    cout << dis[n] << endl;
}

堆优化迪杰斯特拉

普通版迪杰斯特拉的时间复杂度为$O(n^2)$
优化1：我们可以用一个小顶堆来$O(1)$取最近的点v，插入点的时间复杂度为$O(logn)$
优化2：松弛操作不需要遍历所有点，只需要找和点v相连的点即可，因此可以用邻接表或者链式前向星进行优化

到此，堆优化+链式前向星优化的迪杰斯特拉的时间复杂度为$O(mlogn)$，其中n是顶点数，m是边数。

代码：

ll dis[1010];
ll head[1010];

struct node
{
    ll v, w, next;
} e[10010];
ll ct = 1;

void add(ll u, ll v, ll w)
{
    e[ct].v = v;
    e[ct].w = w;
    e[ct].next = head[u];
    head[u] = ct++;
}
priority_queue<pll> q;
ll vis[1010];

void dij(ll s)
{
    fill(dis, dis + 1010, INF);
    dis[s] = 0;
    q.push(make_pair(0, 1));
    while (q.size())
    {
        ll u = q.top().second; //O1取到起点最近的点
        q.pop();
        if (vis[u])
            continue;
        vis[u] = 1;
        for (int i = head[u]; i; i = e[i].next)
        {
            ll w = e[i].w;
            ll v = e[i].v;
            if (dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                q.push(make_pair(-dis[v], v));
            }
        }
    }
}

int main()
{
    int t, n;
    cin >> t >> n;
    while (t--)
    {
        ll u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, w);
    }
    dij(1);
    cout << dis[n] << endl;
    return 0;
}