CUMTOJ:algorithm-迷宫游戏（题解）

GGGGG-Dragon

于 2021-10-22 14:54:23 发布

阅读量677

点赞数 2

文章标签：算法

本文链接：https://blog.csdn.net/hxy200201/article/details/120905615

版权

本文介绍了一个使用Dijkstra算法寻找最短路径，并在路径相同情况下利用回溯法寻找最高得分的迷宫游戏问题。通过输入迷宫的房间数量、道路、得分和起点终点信息，程序能够计算出在最短时间内达到终点的最大得分。算法描述中详细解释了代码实现过程，包括存储结构和遍历策略。

摘要由CSDN通过智能技术生成

题目描述

你来到一个迷宫前。该迷宫由若干个房间组成，每个房间都有一个得分，第一次进入这个房间，你就可以得到这个分数。还有若干双向道路连结这些房间，你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间，你首要目标是从起点尽快到达终点，在满足首要目标的前提下，使得你的得分总和尽可能大。现在问题来了，给定房间、道路、分数、起点和终点等全部信息，你能计算在尽快离开迷宫的前提下，你的最大得分是多少么？

输入

第一行4个整数n (<=500), m, start, end。n表示房间的个数，房间编号从0到(n - 1)，m表示道路数,任意两个房间之间最多只有一条道路，start和end表示起点和终点房间的编号。第二行包含n个空格分隔的正整数(不超过600)，表示进入每个房间你的得分。再接下来m行，每行3个空格分隔的整数x, y, z (0<z<=200)表示道路,表示从房间x到房间y(双向)的道路,注意，最多只有一条道路连结两个房间,你需要的时间为z。

输入保证从start到end至少有一条路径。

输出

占一行，分别最短时间和相应的最大得分，中间用空格隔开。

样例输入

样例输出

21 6

算法描述

本题采用Dijkstra算法找到最短通关时间，在遇到通关时间相同的情况下，使用回溯法找到得分较大的路径，每次回溯保留得分较大的路径，最后得到的从起点到终点使用时间最短的路径即为所求。

代码如下

#include<iostream>
using namespace std;
#define maxtime 10000
int main() {
	int n, m, start, end;
	cin >> n >> m >> start >> end;
	int* w = new int[n];//存放得分
	for (int i = 0; i < n; i++)
	{
		int value;
		cin >> value;
		w[i] = value;
	}
	int* q = new int[n];
	for (int i = 0; i < n; i++)
		q[i] = 0;
	int** p = new int*[n];//存放i，j两个房间之间的距离
	for (int i = 0; i < n; i++)
	{
		p[i] = new int[n];
		for (int j = 0; j < n; j++)
		{
			if (i == j)p[i][j] = 0;
			else p[i][j] = maxtime;
		}
	}
	for (int i = 0; i < m; i++)
	{
		int x, y, z;
		cin >> x >> y >> z;
		p[x][y] = z;
		p[y][x] = z;//双向
	}
	int** t = new int* [n];
	bool* judge = new bool[n];
	for (int i = 0; i < n; i++)
		judge[i] = false;
	for (int i = 0; i < n; i++)
	{
		t[i] = new int[2];
		int j;
		t[i][0] = -1;//存放上一个房间编号
		t[i][1] = maxtime;//存放到起点的距离
		if (p[start][i]!=maxtime)
		{
			t[i][0] = start;
			t[i][1] = p[start][i];
		}
	}
	for (int i = 0; i < n - 1; i++)
	{
		int temp = maxtime;
		int u = start;
		for (int j = 0; j < n; j++)
		{
			if (j == start)continue;
			if ((!judge[j]) && t[j][1] < temp)
			{
				u = j;
				temp = t[j][1];
			}
		}
		judge[u] = true;
		for (int j = 0; j < n; j++)
		{
			if (u == j)continue;
			int newtime = t[u][1] + p[u][j];
			if (newtime < t[j][1])
			{
				t[j][1] = newtime;
				t[j][0] = u;
				int max = w[j]+w[u];
				int x = u;
				while (t[x][0] != start)//迭代查找，回溯到起点
				{
					max += w[t[x][0]];
					x = t[x][0];
				}
				max += w[start];
				q[j] = max;
			}
			else if (newtime == t[j][1]&&newtime!=maxtime)
			{
				int max1 = w[j];
				int x = j;
				while (t[x][0] != start)//迭代查找
				{
					max1 += w[t[x][0]];
					x = t[x][0];
				}
				max1 += w[start];
				int max2 = w[j] + w[u];
				int y = u;
				while (t[y][0] != start)
				{
					max2 += w[t[y][0]];
					y = t[y][0];
				}
				max2 += w[start];
				if (max2 > max1)
				{
					t[j][0] = u;
					q[j] = max2;
				}
			}
		}
	}
	cout << t[end][1]<<' '<<q[end];
	return 0;
}