dijkstra算法

dijkstra

心得：

1.图论算法比较重实践而非证明，我们该着重掌握如何从题目中抽象出点边，而非纠结如何证明
2.dijkstra算法是一种单源最短路算法，适用于边权为正的情况

代码基本思路：

1.将所有点与点间距离赋值为无穷（类似memset（g,0x3f3f3f3f,sizeof g))。
2.用dist[i]表示i节点到源点的距离，初始化为无穷。
3.用一个s储存所有已确定最短路的点。
4.每次寻找未确定点中离源点权值和最小的点t。
5.用t来更新所有节点到源点的距离（比较dist[i]与dist[t] + w(t,i)的大小，取较小值）

一、朴素版dijkstra算法

适用：稠密图（点边数量积相差不大），用邻接矩阵储存

代码实现

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1e3 + 10; //memory 不能开太大 

int g[N][N];
int dist[N];
bool s[N];
int n,m;

int dijkstra()
{
	memset(dist , 0x3f , sizeof dist);//将每个点到源点的距离赋值为无穷大 
	
	dist[1] = 0; //第一位为0； 
	
	for(int i = 0 ; i < n ; i ++){
		int t = -1 ;//记录第n次循环最小的dist所在位置 
		
		for(int j = 1 ; j <= n ; j ++)//寻找t的位置 
			if(!s[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		
		s[t] = true; // 将t所在点加入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];
	
}

int main()
{
	while(scanf("%d %d",&n,&m) && n && m){
		memset(g,0x3f,sizeof g);//将每两个点间距离赋值为无穷大 
		memset(s,0,sizeof s);
		while(m--){
			int x,y,z;
			scanf("%d %d %d",&x,&y,&z);
			g[x][y] = min(z,g[x][y]);
			g[y][x] = min(z,g[y][x]);
		}	
	
	cout<<dijkstra()<<endl;
	}
	
	
	
	return 0;
 } 

二，堆优化版dijkstra算法

适用：稀疏图（点数量积远大于边），用邻接表储存

代码实现：

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

using namespace std;
typedef pair<int, int> PII; //<离起点的距离， 节点编号>

const int N = 150010;
int h[N], e[N], ne[N], idx, w[N];
int dist[N];
bool st[N];
int n, m;

//在a节点之后插入一个b节点，权重为c
void add(int a, int b, int c) {
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}

int dijkstra() {
//    所有距离初始化为无穷大
    memset(dist, 0x3f, sizeof dist);
//    1号节点距离为0
    dist[1] = 0;
//    建立一个小根堆
    priority_queue<PII, vector<PII>, greater<PII>> heap;
//    1号节点插入堆
    heap.push({0, 1});
    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];
//            dist[j] 大于从t过来的距离
            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];

}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    cout << dijkstra() << endl;
    return 0;
}