luogu_1690（贪婪的copy)

这是一道非常好的最短路 + 深搜练习题

题面：qwq​​​​​​​

Copy从卢牛那里听说在一片叫yz的神的领域埋藏着不少宝藏，于是Copy来到了这个被划分为个区域的神地。卢牛告诉了Copy这里共有个宝藏，分别放在第Pi个(1<=Pi<=N)区域。Copy还得知了每个区域之间的距离。现在Copy从1号区域出发，要获得所有的宝藏并到n号区域离开。Copy很懒，只好来找你为他寻找一条合适的线路，使得他走过的距离最短。

注意：题目中有一句话

注意的i to j距离并不一定等于j to i的距离。

也就是说在读入的时候重边处理需要斟酌

也可以说这是一个权值不等的双向图

拿到题面之后，可以分析到：

1.我们需要知道每个点到宝藏点的距离

2.这里有多种走完宝藏点的可能，我们需要一一遍历

那么同时满足这两个条件的算法是什么呢：

1. floyd

2.深度优先搜索

首先我们需要将floyd的板子熟记于心：

void floyd(int n) {
	for (int k = 1; k <= n; k++) { //首先枚举中转点k
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (dis[i][k] != 0 && dis[k][j] != 0) {
					dis[i][j] = Min(dis[i][j], dis[i][k] + dis[k][j]);
				}
			}
		}
	}
} 

利用动态规划的思想， 我们将各个点间的最短距离求了出来

接着我们要进行深搜

在此之前， 我们要处理参数，和读入问题

题中有这样一句话：

接下来一个N*N的矩阵，第i+1行第j列的数字表示区域i,j之间的距离

那么我们可以这样读入：

memset(dis, INF, sizeof(dis)); //初始化无穷大，方便动态规划
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			long long w;
			cin >> w;
			dis[i][j] = Min(dis[i][j], w); //处理重边 
		}
	}

不懂的小伙伴可以将读入下标与题目对比一下

现在我们知道有p个宝藏点，那么我们可以用a数组将点存起来

接着是参数问题

深搜过程中， 我们需要传入三个参数

同时我们用ans记录最优答案

1.当前所在的点位

2.剩余需要遍历的宝藏点

3.总共所走的路程（优化ans所用）

接着为了避免重复遍历，我们用flag数组进行标记

我们可以得到以下代码

void dfs(int now, int m, long long sum) {
	if (m == 0) { //当遍历完全部宝藏点之后
		ans = min(sum + dis[now][n], ans); //优化
		return; //回溯
	}
	for (int i = 1; i <= p; i++) { //枚举总共p个宝藏点
		if (!flag[i]) { //如果没有被访问
			flag[i] = 1; //标记
			dfs(a[i], m - 1, sum + dis[now][a[i]]);
            //（到达下一个宝藏点， 还剩m-1个宝藏点， 总路程sum加上当前点到宝藏点距离）
			flag[i] = 0; //回溯重新标记未被访问
		}
	}
}

最后我们就可以输出最优答案ans了

完整代码

#include <bits/stdc++.h> //luogu 1690 by zqy 
#define maxn 105
#define INF 0x3f3f3f3f
using namespace std;
long long dis[maxn][maxn], n;
long long a[maxn], ans = INF;
bool flag[15];
int p;

int Min(long long x, long long y) {return x < y ? x : y;}
void floyd(int n) {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (dis[i][k] != 0 && dis[k][j] != 0) {
					dis[i][j] = Min(dis[i][j], dis[i][k] + dis[k][j]);
				}
			}
		}
	}
} 
void dfs(int now, int m, long long sum) {
	if (m == 0) {
		ans = min(sum + dis[now][n], ans);
		return;
	}
	for (int i = 1; i <= p; i++) {
		if (!flag[i]) {
			flag[i] = 1;
			dfs(a[i], m - 1, sum + dis[now][a[i]]);
			flag[i] = 0;
		}
	}
}
int main() {
	cin >> n;
	memset(dis, INF, sizeof(dis));
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			long long w;
			cin >> w;
			dis[i][j] = Min(dis[i][j], w); //处理重边 
		}
	}
	cin >> p;
	for (int i = 1; i <= p; i++) {
		cin >> a[i];
	}
	floyd(n);
	dfs(1, p, 0);
	cout << ans << endl;
	return 0;
} 

撒花

蒟蒻很弱，请大佬多多包容