1111. Online Map (30)解题报告

求时间最短路径时，如果时间相同，则选择通过交叉路口最少的路线。仔细审题，否则会容易出错。

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
using namespace std;

struct node {
	int len, time;
	int v1, v2;
};

void Dijkstra1(vector<node> arr[], int n, vector<int> path[]);
void Dijkstra2(vector<node> arr[], int n, vector<int> path[]);
void DFS1(vector<node> arr[], vector<int> path[], int index);
void DFS2(vector<node> arr[], vector<int> path[], int index);
const int MAX = 100000000;
stack<int> road;
int time = MAX, len = MAX, source, destination;
int main(void)
{
	int i, n, m, v1, v2, one_way, t, l, t2, d1;
	node tmp;
	vector<node> *arr;
	vector<int> *path;
	stack<int> path1, path2;

	scanf("%d %d", &n, &m);
	arr = new vector<node>[n];
	path = new vector<int>[n];
	for (i = 0; i < m; i++) {
		scanf("%d %d %d %d %d", &v1, &v2, &one_way, &l, &t);
		tmp.len = l;
		tmp.time = t;
		tmp.v2 = v2;
		tmp.v1 = v1;
		arr[v1].push_back(tmp);
		if(!one_way) {
			tmp.v2 = v1;
			tmp.v1 = v2;
			arr[v2].push_back(tmp);
		}
	}
	scanf("%d %d", &source, &destination);

	Dijkstra1(arr, n, path);
	DFS1(arr, path, destination);
	d1 = len;
	path1 = road;
	for (i = 0; i < n; i++) {
		path[i].clear();
	}
	time = MAX;
	while (!road.empty()) {
		road.pop();
	}
	Dijkstra2(arr, n, path);
	DFS2(arr, path, destination);
	t2 = time;
	path2 = road;
	if (path1 == path2) {
		printf("Distance = %d; Time = %d: %d", d1, t2, path2.top());
		path2.pop();
		while (!path2.empty()) {
			printf(" -> %d", path2.top());
			path2.pop();
		}
		putchar('\n');
	}
	else {
		printf("Distance = %d: %d", d1, path1.top());
		path1.pop();
		while (!path1.empty()) {
			printf(" -> %d", path1.top());
			path1.pop();
		}
		putchar('\n');
		printf("Time = %d: %d", t2, path2.top());
		path2.pop();
		while (!path2.empty()) {
			printf(" -> %d", path2.top());
			path2.pop();
		}
		putchar('\n');
	}
	return 0;
}

void Dijkstra1(vector<node> arr[], int n, vector<int> path[]) 
{
	int i, j, *dist = new int[n];
	bool *visit = (bool *)calloc(n, sizeof(bool));

	for (i = 0; i < n; i++) {
		dist[i] = MAX;
	}
	dist[source] = 0;
	int min, index;
	for (i = 0; i < n; i++) {
		min = MAX;
		index = -1;
		for (j = 0; j < n; j++) {
			if (!visit[j] && dist[j] < min) {
				min = dist[j];
				index = j;
			}
		}
		if (index == -1) {
			return;
		}
		visit[index] = true;
		for (j = 0; j < arr[index].size(); j++) {
			if (dist[index] + arr[index][j].len < dist[arr[index][j].v2]) {
				dist[arr[index][j].v2] = dist[index] + arr[index][j].len;
				path[arr[index][j].v2].clear();
				path[arr[index][j].v2].push_back(index);
			}
			else if (dist[index] + arr[index][j].len == dist[arr[index][j].v2]) {
				path[arr[index][j].v2].push_back(index);
			}
		}
	}
	len = dist[destination];
	return;
}
void Dijkstra2(vector<node> arr[], int n, vector<int> path[])
{
	int i, j, *t = new int[n];
	bool *visit = (bool *)calloc(n, sizeof(bool));

	for (i = 0; i < n; i++) {
		t[i] = MAX;
	}
	t[source] = 0;
	int min, index;
	for (i = 0; i < n; i++) {
		min = MAX;
		index = -1;
		for (j = 0; j < n; j++) {
			if (!visit[j] && t[j] < min) {
				min = t[j];
				index = j;
			}
		}
		if (index == -1) {
			return;
		}
		visit[index] = true;
		for (j = 0; j < arr[index].size(); j++) {
			if (t[index] + arr[index][j].time < t[arr[index][j].v2]) {
				t[arr[index][j].v2] = t[index] + arr[index][j].time;
				path[arr[index][j].v2].clear();
				path[arr[index][j].v2].push_back(index);
			}
			else if (t[index] + arr[index][j].time == t[arr[index][j].v2]) {
				path[arr[index][j].v2].push_back(index);
			}
		}
	}
	time = t[destination];
	return;
}
void DFS1(vector<node> arr[],  vector<int> path[], int index) 
{
	static stack<int> s;
	static int t = 0;
	if (index == source) {
		s.push(index);
		if (t < time) {
			time = t;
			road = s;
		}
		s.pop();
	}
	else {
		int i, j;
		s.push(index);
		for (i = 0; i < path[index].size(); i++) {
			for (j = 0; j < arr[path[index][i]].size(); j++) {
				if (arr[path[index][i]][j].v2 == index) {
					t += arr[path[index][i]][j].time;
					break;
				}
			}
			DFS1(arr, path, path[index][i]);
			t -= arr[path[index][i]][j].time;
		}
		s.pop();
	}
}
void DFS2(vector<node> arr[], vector<int> path[], int index)
{
	static stack<int> s;
	if (index == source) {
		s.push(index);
		if (road.size() == 0) {
			road = s;
		}
		else if (s.size() < road.size()) {
			road = s;
		}
		s.pop();
	}
	else {
		int i, j;
		s.push(index);
		for (i = 0; i < path[index].size(); i++) {
			DFS2(arr, path, path[index][i]);
		}
		s.pop();
	}
}