acwing算法基础之搜索与图论--堆优化版dijkstra算法

YMWM_

已于 2024-09-14 23:25:04 修改

阅读量254

点赞数

分类专栏： Acwing C++学习文章标签：算法图论

于 2023-11-11 14:17:18 首次发布

本文链接：https://blog.csdn.net/YMWM_/article/details/134347195

版权

C++学习同时被 2 个专栏收录

207 篇文章 19 订阅

订阅专栏

Acwing

123 篇文章 1 订阅

订阅专栏

1 基础知识

堆优化版dijkstra算法的关键步骤：

初始化距离数组为正无穷，然后d[1] = 0。
定义集合S，表示当前已经确定到1号结点的最短距离的结点们。
定义小根堆，插入1号结点和d[1]。
如果小根堆不为空：弹出堆顶，记作t_node结点和t_dist。如果结点t_node在集合S中，则continue；否则将它加入到集合S中，并进行后续操作。看看结点t_node能走到哪儿（比如它能走到结点x），如果dist[x] > t_dist + edge[t_node][x]，则用它去更新dist[x]，并将结点x和距离dist[x]插入到堆中。
继续进行操作4，直至小根堆为空。
dist[n]，即为1号结点到n号结点的最短距离。

堆优化版dijkstra算法的时间复杂度为O(mlogn)。

2 模板

y总的模板，但这个加边函数不太习惯，暂时不考虑使用它

typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

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

3 工程化

y总dijkstra()算法模板

注意的是：需要一个st数组，用来记录这个结点a的最短路是否已经被确定，也即dist[a]是否已经被计算出来了！

题目1：求1号结点到n号结点的最短距离。

#include <iostream>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

const int N = 1e5 + 10;

typedef pair<int, int> PII;

int n, m;
vector<vector<PII>> g; //first表示结点，second表示边的权重
int dist[N];
bool st[N];

int dijkstra() {
    //初始化距离数组
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    priority_queue<PII, vector<PII>, greater<PII>> h;
    h.push(make_pair(0,1));//first表示到1号结点的距离，second表示结点
    
    while (!h.empty()) {
        //确定当前结点中，不在集合S且距离结点1最近的结点。记作curr_node。
        auto [da, a] = h.top();
        h.pop();
        if (st[a]) continue; //如果a到起点的最短路径已经被求解出来了（即dist[a]已经被计算出来了），则跳过
        
        st[a] = true; //将它加入到集合中
        
        for (auto [b, w] : g[a]) {
            if (dist[b] > da + w) {
                dist[b] = da + w;
                h.push(make_pair(dist[b], b));
            }
        }
    }
    
    if (dist[n] == 0x3f3f3f3f) return -1;
    else return dist[n];
}

int main() {
    cin >> n >> m;
    
    g.resize(n + 10);
    
    int a, b, c;
    while (m--) {
        cin >> a >> b >> c;
        g[a].emplace_back(make_pair(b,c));
    }
    
    cout << dijkstra() << endl;
    
    return 0;
}

灵神dijkstra()算法模板，但为啥在本地调不通呢？？？

//C++版本
typedef pair<int,int> PII;
vector<vector<PII>> g(n + 10); //n为结点数
//first表示b,second表示w
for (int i = 0; i < edges.size(); ++i) {
	auto& e = edges[i];
	int a = e[0], b = e[1], w = e[2];
	g[a].empalce_back(b, w);
	g[b].emplace_back(a, w);
}

//求从0号结点到所有结点的最短路
vector<int> dis(n, 0x3f3f3f3f);
dis[0] = 0;
priority_queue<PII, vector<PII>, greater<PII>> pq; //小根堆
pq.emplace(0,0);
while (!pq.empty()) {
	auto [dx, x] = pq.top();
	pq.pop();
	if (dx > dis[x]) continue;
	for (auto [y, w] : g[x]) {
		int new_dis = dx + w;
		if (new_dis < dis[y]) {
			dis[y] = new_dis;
			pq.emplace(new_dis, y);
		}
	}
}

//最终dis就是最短路

如下python3版本已验证OK，

#python3版本
g = [[] for _ in range(n)] #n是结点数
for [x, y, w] in edges:
	g[x].append([y, w])
	g[y].append([x, w])
dis = [inf] * n
dis[0] = 0
h = [(0, 0)]
while h:
	dx, x = heappop(h)
	if dx > dis[x]:
		continue
	for y, w in g[x]:
		new_dis = dx + w
		if new_dis < dis[y]:
			dis[y] = new_dis
			heappush(h, (new_dis, y))

#最终dis就是最短路

4 训练

题目1：1129热浪

C++代码如下，

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

const int N = 2510;
int n, m;
vector<vector<pair<int,int>>> g; //first表示next_node，second表示w
int dist[N];
bool st[N];
int snode, enode;

void dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[snode] = 0;
    
    priority_queue<pair<int, int>, vector<pair<int,int>>, greater<pair<int,int>>> h;
    h.push(make_pair(0, snode));
    
    while (!h.empty()) {
        //确定当前结点中，不在集合s且距离结点snode最近的结点。记作cnode
        auto t = h.top();
        h.pop();
        int cdist = t.first, cnode = t.second;
        if (st[cnode]) continue; //如果cnode已经被确定是最小路径上的结点了，则跳过
        
        st[cnode] = true; //将它加入到集合中
        for (auto [next_node, w] : g[cnode]) {
            if (dist[next_node] > cdist + w) {
                dist[next_node] = cdist + w;
                h.push(make_pair(dist[next_node], next_node));
            }
        }
    }
    
    return;
}

int main() {
    cin >> n >> m >> snode >> enode;
    g.resize(n + 10);
    
    for (int i = 1; i <= m; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a].emplace_back(b, c);
        g[b].emplace_back(a, c);
    }
    
    //求snode到enode的最短距离
    dijkstra();
    
    cout << dist[enode] << endl;
    
    return 0;
}

题目2：100276最短路径中的边

C++代码如下，

class Solution {
public:
    vector<bool> findAnswer(int n, vector<vector<int>>& edges) {
        vector<vector<tuple<int, int, int>>> g(n);
        for (int i = 0; i < edges.size(); i++) {
            auto& e = edges[i];
            int x = e[0], y = e[1], w = e[2];
            g[x].emplace_back(y, w, i);
            g[y].emplace_back(x, w, i);
        }

        vector<long long> dis(n, LLONG_MAX);
        dis[0] = 0;
        priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> pq;
        pq.emplace(0, 0);
        while (!pq.empty()) {
            auto [dx, x] = pq.top();
            pq.pop();
            if (dx > dis[x]) {
                continue;
            }
            for (auto [y, w, _] : g[x]) {
                int new_dis = dx + w;
                if (new_dis < dis[y]) {
                    dis[y] = new_dis;
                    pq.emplace(new_dis, y);
                }
            }
        }

        vector<bool> ans(edges.size());
        // 图不连通
        if (dis[n - 1] == LLONG_MAX) {
            return ans;
        }

        // 从终点出发 DFS
        vector<int> vis(n);
        function<void(int)> dfs = [&](int y) {
            vis[y] = true;
            for (auto [x, w, i] : g[y]) {
                if (dis[x] + w != dis[y]) {
                    continue;
                }
                ans[i] = true;
                if (!vis[x]) {
                    dfs(x);
                }
            }
        };
        dfs(n - 1);
        return ans;
    }
};