2021-02-04

图论

最短路
朴素dijkstra
解决非负权图的单源最短路问题，适合稠密图，用邻接矩阵存储，时间复杂度o(n ^ 2)

算法思想
算法流程
初始时把其他点到起点1的距离赋值为INF，dist[1] = 0;
每次找到不在集合s中的点到起点1的最短距离的点t，把t加入到集合s中去
用t更新其他不在集合s中的点的距离
重复2,3步骤n - 1次
代码

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n - 1; i ++)//迭代n - 1次就行
    {
        int t = -1;// 在还未确定最短路的点中，寻找距离最小的点
        for(int j = 1; j <= n; j ++)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        st[t] = true;//找到当前距离最小的点加到集合s中去
        // 用t更新其他未在集合s中的点的距离，已经在集合s中的点的距离不会被更新，这样写代码更简洁
        for(int j = 1; j <= n; j ++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);


    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

堆优化dijkstra
解决非负权图的单源最短路问题，适合稀疏图，用邻接表存储，时间复杂度o(mlogn)

代码
typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 稀疏图用邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定
void add(int a, int b, int c)//建用边权的图
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII> > heap;//定义pair类型的小根堆，first表示dist， second表示节点编号
    heap.push({0, 1});
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int ver = t.second, d = t.first;
        if(st[ver]) continue;//去掉冗余的点，优化时间
        st[ver] = true;

        for(int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > d + w[i])
            {
                dist[j] = d + w[i];
                heap.push({dist[j], j});//同一个点可能会被多个点更新距离，多次进heap，所以heap中可能有冗余的点，
            }
        }

    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}