[数据结构]有向图+Dijkstra算法的心得

前言：虽然我数据结构没听懂，但我咨询了一下我的超有耐心！的学长，并认真阅读了他的代码，怕我自己忘了所以。

需求：我只知道迪杰斯特拉算法是贪心算法，但我不太清楚，而且我想要尽量简单地实现它。

实现准备：
至少得有一个邻接矩阵cost[][]，不然咋写，
然后至少得有一个存最短路径的数组d[]，不过分吧。
我们的算法不同在于是再来一个bool类型的数组used[],记录是否被用过。

#include <iostream>
#include<stdlib.h>
#include <cstdio>
#include<Windows.h>
using namespace std;
const int MAX_V = 1010;//随便什么值，大一点就行
const int MAX_E = 5050;//随便什么，大一点就行
const int INF = 0x3f3f3f3f;//一个超级大的但又没越界的int数字
int V, E;//v为点的个数，E为边的个数
int cost[MAX_V][MAX_V]; //邻接矩阵（有向图）
int d[MAX_V]; //标记到s的最短距离
bool used[MAX_V]; //标记已经确定d的顶点，false表示没有用过

Dijkstra算法实现步骤：

1. 要传一个s表示初始点的位置。初始化used[MAX_V]让每一个值都是false，表示都没有用过。初始化d[MAX_V]让每一个值都是无穷大

	fill(d, d + V, INF); //首先d都初始化为无穷大
	fill(used, used + V, false); //没有被使用过的

2. 首先自己对自己距离为0

	d[s] = 0;

3. 然后来一个超大的死循环~~包括了下面两个小循环比如

	while(true)

5. 然后写一个小循环，找到没使用过的d数组中的最小值的位置v。循环结束后如果发现所有的值都已被使用，那么我们爆破这个超大的循环。

	//我们要找到d数组中最小的那个点
		int v = -1;
		for (int u = 0; u < V; u++) {
			//如果d[u]未被使用且小于d[v]，则标记小的那个点的标号
			if (used[u] == false && (v == -1 || d[v] > d[u])) {
				v = u;
			}
		}
		//如果上一个循环下来v一直没有被改变，则全都被使用过了，那么结束大循环
		if (v == -1)break;

5. 将找到的位置在uesd数组中used[v]的值记为true，表示已经用过。

	used[v] = true;

6. 写第二个小循环，对每一个d[i]的值，都和（之前找到的最小值d[v]+v到每一个i的有向权值（cost[v][i]））比较大小，然后把小的值放入d[i]中作为更新结果

	for (int i = 0; i < V; i++){
		if (used[i] == false) {
			//min对d[i]进行更新
			//如果i到s的距离<前驱到s的距离+前驱到i的距离就更新
			d[i] = min(d[i], d[v] + cost[v][i]);
		}
	}

总体实现步骤：

1. 先给邻接矩阵全部赋值成无穷大，再依次给邻接矩阵的有效位置赋有效值，嫌麻烦可以给他一个文件输入，避免每次都要手打。
2. Dijkstra算法（输入一个节点的编号s）
3. 输出 d[MAX_V]（到s的最短距离），可以自己定义一个函数。

全部代码：

#include <iostream>
#include<stdlib.h>
#include <cstdio>
#include<Windows.h>
using namespace std;
const int MAX_V = 1010;
const int MAX_E = 5050;
const int INF = 0x3f3f3f3f;//一个超级大的但又没越界的int
int V, E;//v为点的个数，E为边的个数
int cost[MAX_V][MAX_V]; //邻接矩阵（有向图）
int d[MAX_V]; //标记到s的最短距离
bool used[MAX_V]; //标记已经确定d的顶点

int u[MAX_V];//还没排好
int ss[MAX_V];//已经排好
/*
void dijkstra(int s) {
	fill(d, d + V, INF); //首先d都初始化为无穷大
	fill(used, used + V, false); //没有被使用过的
	d[s] = 0;
	while (true) {
		int v = -1; //用v来找下一个需要标记的点
		for (int u = 0; u < V; u++) {
			if (!used[u] && (v == -1 || d[u] < d[v]))
				v = u;
		}
		if (v == -1) { break; }
		//到这里v就是要更新的点了
		used[v] = true;
		for (int u = 0; u < V; u++) {
			if (!used[u]) d[u] = d[u] > d[v] + cost[v][u] ? d[v] + cost[v][u] : d[u];
		}
	}
}
*/
void dijkstra(int s) {
	fill(d, d + V, INF); //首先d都初始化为无穷大
	fill(used, used + V, false); //没有被使用过的
	d[s] = 0;
	while (true){
		//我们要找到d数组中最小的那个点
		int v = -1;
		for (int u = 0; u < V; u++) {
			//如果d[u]未被使用且小于d[v]，则标记小的那个点的标号
			if (used[u] == false && (v == -1 || d[v] > d[u])) {
				v = u;
			}
		}
		//如果上一个循环下来v一直没有被改变，则全都被使用过了，那么结束循环
		if (v == -1)break;
		//更新d[]数组
		used[v] = true;
		for (int i = 0; i < V; i++){
			if (used[i] == false) {
				//min对d[i]进行更新，如果i到s的距离<前驱到s的距离+前驱到i的距离就更新
				d[i] = min(d[i], d[v] + cost[v][i]);
			}
		}
	}
}
void printd(int V) {
	for (int u = 0; u < V; u++) {
		printf("d[%d] = %d\n", u, d[u]);
	}
}
int main() {
	freopen("1.txt", "r", stdin);
	scanf("%d%d", &V, &E);
	int st, ed, val;
	for (int i = 0; i < V; i++) {
		for (int j = 0; j < V; j++) {
			cost[i][j] = INF;
		}
	}
	for (int i = 0; i < E; i++) {
		scanf("%d%d%d", &st, &ed, &val);
		cost[st][ed] = val;
	}
	dijkstra(0);
	//cout << endl;
	printd(V);
	Sleep(10000000);
	return 0;
}
//复杂度为O(V^2)*/