【算法练习】最短路径

Dijkstra算法

输入一个3*3的矩阵，输出结果为2

#include<bits/stdc++.h> 
using std::cout;
using std::cin;
using std::endl;

const int N = 10001;
const int M = 10001;

int a[N],size; //当前图中的边数 ，首先初始化为0
int n, m;
int dis[N];  //当前最短路长 
bool vis[N];  //是否被标记，最好使用布尔类型 

struct edge {
	int v, w, next; //next：这条边的下一条边 
	edge() {}
	edge(int _v, int _w, int _next) { //构造函数 
		v = _v;
		w = _w;
		next = _next;
	}
}e[M * 2]; //编号 

void init()
{
	memset(a, -1, sizeof(a)); //刚开始，默认-1，表示没有任何一条边从这个点连出 
	size = 0;
}

void insert(int u, int v, int w) // 插入一条边 
{
	e[size] = edge(v, w, a[u]); //边连向的顶点编号，边权，u连出的第一条边 
	a[u] = size++; //修改u连出的第一条边的编号 
}

void insert2(int u, int v, int w) //插入一条无向边 
{
	insert(u, v, w);
	insert(v, u, w);
}



void dijkstra(int u)
{
	memset(vis, false, sizeof(vis)); //memset 高效赋值 
	memset(dis, 0x3f, sizeof(dis)); //0x:十六进制数   3f:实际的0011 1111   
	dis[u] = 0;
	for (int i = 0; i < n; i++) {
		int mind = 1000000, minj = -1; //当前没标记过的点 的距离，编号 

		for (int j = 1; j <= n; j++) { //顶点编号从1开始 
			if (!vis[j] && dis[j] < mind) { // 判断j 是否被标记 
				minj = j;
				mind = dis[j];
			}
		}

		if (minj == -1) {  // 没有找到一个没被标记过的点（不是连通图） 
			return;
		}

		vis[minj] = true; //访问 minj
						//~j：j≠-1
		for (int j = a[minj]; ~j; j = e[j].next) {  
			int v = e[j].v;
			int w = e[j].w;
			if (!vis[j] && dis[minj] + w < dis[v]) {
				dis[v] = dis[minj] + w; //更新：到v的路径长 
			}
		}
	}

	int cnt = 0; //被标记点的个数 
	for (int i = 1; i <= n; i++) {
		cnt += vis[i];  // vis里要么是1，要么是0 
	}
}

int main()
{
	init(); //初始化 边数组全为-1（表示无连接） size（图中边数）为0
	int u, v, w; //u:头点， v:尾点， w：边权
	cout << "" << endl;
	cin >> n >> m;
	while (m--) {
		cin >> u >> v >> w;
		insert2(u, v, w);
	}
	dijkstra(1); //设定：编号为1的点为起点 
	cout << dis[n] << endl;
}

运行结果

运行时出现了一些小问题，vs报错：size不明确。通过查询得知：其实不提倡using namespace std; 的写法，于是改成了

using std::cout;
using std::cin;
using std::endl;

SPFA算法

当给定边权值为负数时，无法使用Dijkstra算法了。且在稀疏图情况下，SPFA算法更快。但是，当图中有负环（环形回路，且有一边为负数）
时，不能使用SPFA
数据结构：
1、dis[i]：从原点到顶点i的最短路
2、队列：即将进行拓展的顶点列表