PAT| 1030 Travel Plan (迪杰斯特拉算法详解)

Dijkstra算法解决的是单源最短路径问题，在给定图和起点的情况下计算到各个结点的最短路径。

基于邻接矩阵的迪杰斯特拉算法实现

#include<bits/stdc++.h>
using namespace std;

const int MAXV = 1000;//最大的顶数
const int INF = 1000000000;//一个很大的数

int n, G[MAXV][MAXV];//n为顶点数，MAXV表示的是最大的结点数
int d[MAXV];//起点到其他各点的最短路径长度
int pre[MAXV];//记录每一个最短路径的前驱下标
bool visit[MAXV] = { false };//表示本结点是否被访问

//首先应该明确的是我们使用迪杰斯特拉算法计算的已知起点的情况下原点到其他点的最小距离    使用d[MAX]表示
void Dijkstra(int s) {//唯一的参数表示s

	//TODO1: 初始化迪杰斯特拉算法所需要的几个数组：   1.d  2. pre  

	fill(d, d + MAXV, INF);//将起点到各点的长度初始化为INF
	for (int i = 0; i < n; i++) {//初始化的时候所有的前驱都指向自己
		pre[i] = i;
	}


	//TODO2:  开始迪杰斯特拉算法的遍历，开始的时候初始化条件是源点到自身的距离为0

	d[s] = 0;//到自身的距离为0
	for (int i = 0; i < n; i++) {//遍历每一个结点
		int u = -1, MIN = INF;
		for (int j = 0; j < n; j++) {//找到当前状态下的最短距离，使用u记录下标
			if (visit[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if (u == -1) {//未找到此时的最短路径，剩下的结点和起点都是不连通的
			return;
		}
		visit[u] = true;//表示本节点已经被访问到
		for (int v = 0; v < n; v++) {//找到了本次需要迭代的对象   u和v可能是相同的
			//如果v没有访问 并且 u和v之间可达 并且 本次可以通过迭代减小两个点之间的距离
			if (visit[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]) {
				d[v] = d[u] + G[u][v];//更新d[v]
				pre[v] = u;
			}
		}
	}
}
int main() {
	return 0;
}

例题 1030 Travel Plan

题目大意

旅行者的地图给出了高速公路沿线城市之间的距离，以及每条高速公路的成本。现在您应该编写一个程序来帮助旅行者决定他/她的出发城市和目的地之间的最短路径。如果这样的最短路径不是唯一的，则应该输出成本最低的路径，该路径保证唯一。

代码

#include<bits/stdc++.h>
using namespace std;

const int INF = 1000000000;
const int MAXV = 510;

int n, m, s, d;


int minCost = INT_MAX;

int G[MAXV][MAXV];
int cost[MAXV][MAXV];
int dis[MAXV];//两点之间的距离
vector<int> pre[MAXV];//表示前驱
bool visit[MAXV] = { false };//表示是否已经访问过

vector<int> temPath, path;

void Dijkstra(int s) {//s表示源端
	//初始化
	fill(dis, dis + MAXV, INF);//开始的时候每一个点都是不可达到的
	
	dis[s] = 0;

	for (int i = 0; i < n; i++) {
		int u = -1;//表示最短路径的一个点
		int MIN = INF;
		for (int j = 0; j < n; j++) {
			if (visit[j] == false && dis[j] < MIN) {
				u = j;
				MIN = dis[j];
			}
		}
		if (u == -1) {
			//没有在本连通块中找到最小的最短路径
			return;
		}
		else {
			visit[u] = true;
			for (int v = 0; v < n; v++) {
				if (visit[v] == false && G[u][v] != INF) {//没有访问过，可达
					if (dis[u] + G[u][v] < dis[v]) {//可以更新
						dis[v] = dis[u] + G[u][v];
						pre[v].clear();
						pre[v].push_back(u);
					}
					else if (dis[u] + G[u][v] == dis[v]) {
						pre[v].push_back(u);
					}
				}
			}
		}
	}
}


void DFS(int v) {
	if (v == s) {
		temPath.push_back(v);
		int temCost = 0;
		for (int i = temPath.size() - 1; i > 0; i--) {//倒着访问 计算路径上的总边权
			int id = temPath[i];
			int idNext = temPath[i - 1];
			temCost += cost[id][idNext];
		}
		if (minCost > temCost) {
			minCost = temCost;
			path = temPath;
		}
		temPath.pop_back();
		return;
	}
	temPath.push_back(v);
	for (int i = 0; i < pre[v].size(); i++) {
		DFS(pre[v][i]);
	}
	temPath.pop_back();
}

int main() {
	cin >> n >> m >> s >> d;
	int c1, c2, di, cos;
	//初始化图
	fill(G[0], G[0] + MAXV * MAXV, INF);
	fill(cost[0], cost[0] + MAXV * MAXV, INF);
	for (int i = 0; i < m; i++) {
		cin >> c1 >> c2 >> di >> cos;
		G[c1][c2] = G[c2][c1] = di;
		cost[c1][c2] = cost[c2][c1] = cos;
	}

	Dijkstra(s);//使用迪杰斯特拉算法计算源点的最短距离

	DFS(d);

	for (int i = path.size() - 1; i >= 0; i--) {
		cout << path[i] << ' ';
	}


	cout << dis[d] << ' ' << minCost << endl;


	return 0;
}