2022/2/13总结

（不知道为什么昨天没发出来，再发一次）

今天不在摸鱼！但是我的脑子好像在摸鱼！今天一下子出了很多“愚蠢”的错误，比如: 

void(int st, int ed)

我甚至检查了半天没看出这个语法哪里错了！！！

我靠，明天一定不会了，今天一定是没睡醒。

---

这道题目不难，思路清晰，因为n <= 200数据范围小，只要把路径一个一个更新一遍就完事了，有点像dp，又有点像最短路。这道题看了下，用Floyd算法也能做，不过这里还是用dp比较清晰。

思路就是: 在输入完毕后，我们得到了一条上到下的单向路径，求1 ~ n的最短路径。可以从1号出租点开始遍历，套两层循环，记录f[j]的最小路径，其状态转移公式为: f[j] = min(f[j], f[i] + r[i][j])，即从i号~j号最短路径或本身已经有更优路径到达了。最后输出f[n]即可，下面上代码。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()
{
	ios::sync_with_stdio(false);
	int n;
	cin >> n;
	ll r[n][n + 1];
	int st[n + 1] = {0};
	r[1][1] = 0;
	ll fn[n + 1] = {0};
	for(int i = 1;i <= n;i ++)
	{
		fn[i] = 1000001;
	}
	fn[1] = 0;
	for(int i = 1;i <= n - 1;i ++)
	{
		for(int j = i + 1;j <= n;j ++)
		{
			cin >> r[i][j];	
//			printf("r[%d][%d] = %lld\n", i, j, r[i][j]);
		}
	}
	for(int i = 1;i <= n - 1;i ++)
	{
		for(int j = i + 1;j <= n && !st[j];j ++)
		{
			fn[j] = min(fn[j], r[i][j] + fn[i]);
			st[i] = 1;
//			cout << "f[" << j << "] = " << fn[j] << endl;
		}
	}
	cout << fn[n];
	return 0;
}

---

这道题很明显，不能用dp（废话）。刚开始想到的是用dijkstra，套上循环不停地求单源最短路径然后加起来就完事了。但是发现好像太麻烦了，因为套上循环不就等于求多源最短路径嘛，用Floyd算法其实是最好的（而且这道题范围不大）。思维简单，时间复杂度其实两者都差不多。Floyd是求两两点之间最短路径的算法最好的了。

思路就是... ..用Floyd，其他好像也没啥思路的。下面上代码。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

ll r[101][101];
int endp[10001];
ll sum; //记录总威胁度
int N, M;

void Floyd() //Floyd算法
{
	for(int k = 1;k <= N;k ++)
		for(int i = 1;i <= N;i ++)
			for(int j = 1;j <= N;j ++)
			{
				r[i][j] = min(r[i][j], r[i][k] + r[k][j]);
			}
}

int main()
{
	ios::sync_with_stdio(false);
	cin >> N >> M;	
	for(int i = 1;i <= M;i ++)
	{
		cin >> endp[i]; //记录终点站
	}
	for(int i = 1;i <= N;i ++)
	{
		for(int j = 1;j <= N;j ++)
		{
			cin >> r[i][j]; //记录危险度
		}
	}
	Floyd();
	for(int i = 1;i <= M - 1;i ++)
	{
		sum += r[endp[i]][endp[i + 1]]; //记录总威胁度
	}
	cout << sum;
	return 0;
}

---

 这道题刚开始觉得有点复杂，问题就在于：我怎么确定双向联通？

我立刻就想到了一个东西：并查集，但是把它用在这里感觉有点奇怪（虽然一定能用），我就在想其他的什么办法。它的连通只是1或0，也就是通或不通，跟最短路无关，反正越看越像并查集的题目。但是后来仔细一想，好像跟最短路有那么点关系，不过它还是更适合flood-fill来做，通过BFS广搜确认每个城市是否可以到达。一看数据结构，哦豁，范围挺小的，可以枚举。于是乎，flood-fill它来了。

具体思路就是: 我“假设”把这座桥给掀了，然后再看看从两边任意一个城市出发是否能到达其他所有城市，这个可以用一个vis状态数组来标记是否可以到达。至于路径则用r[i][j]地图数组来记录，确认可以到达的位置。下面上代码。

#include <bits/stdc++.h>

using namespace std;

int n, m;
int r[151][151];
bool vis[151];

void init()
{
	for(int i = 1;i <= n;i ++)
	{
		vis[i] = 0;
	}
}

int main()
{
	ios::sync_with_stdio(false);
	cin >> n >> m;
	queue<int> que;
	for(int i = 1;i <= m;i ++)
	{
		int a, b;
		cin >> a >> b;
		if(a > b) swap(a, b); //防止数据重复
		r[a][b] = 1; //标记a到b可以走
	}
	for(int i = 1;i <= n;i ++) //遍历地图
	{
		for(int j = i;j <= n;j ++)
		{
			if(i == j || (!r[i][j] && !r[j][i])) continue; //确认不是自己到达自己，而且两边有桥连接
			init();
			r[i][j] = 0; //先把这座桥掀了（假设）
			vis[i] = 1;
			que.push(i);
			while(!que.empty()) //BFS
			{
				int pos = que.front();
				for(int k = 1;k <= n;k ++) //遍历从这个城市到其他城市
				{
					if(pos == k || vis[k] || (!r[pos][k] && !r[k][pos])) continue; //确认不是自己到达自己，且未访问，且有路
					vis[k] = 1; //标记可以到达
					que.push(k);
				}
				que.pop();
			}
			for(int k = 1;k <= n;k ++) //遍历确认是否到达
			{
				if(!vis[k]) //如果有个城市不能到达则输出
				{
					cout << i << " " << j << endl;
					break;
				}
			}
			r[i][j] = 1; //把这座桥再建回去（回溯）
		}
	}
	return 0;
}

---

今天差不多到这里了。明天还有3道题，一口气做完！顺便把dijkstra和堆优化dijkstra学习一下（Floyed和优先队列就比较简单了）。