201800624模拟赛T2——回家路上

题目描述

很多学生都抱怨浪费在回家路上的时间太长。这天dongdong刚走出学校大门，就听说某段路在施工(但不知道是哪条路)，有可能导致他回家的时间会变长。

Dongdong给出了一张地图，图中标号为1的点是学校，标号为N的点是他家，以及一些点之间的路和走完每条路需要的时间。现在dongdong做了最坏打算，他想知道在最坏情况下，他回家的最短时间是多少。

输入格式

第一行两个数N和M，表示点的个数，边的个数。（这是无向图）

接下来M行，每行三个数A，B和V，表示点A和点B之间有一条需要走V分钟的路。

输出格式

一行，表示最坏情况下回家需要花费最少的时间。

输入样例

5 7
1 2 8
1 4 10
2 3 9
2 4 10
2 5 1
3 4 7
3 5 10

输出样例

27

数据规模

对于70% 的数据 \(N\le 100\)；

对于100% 的数据 \(N \le 1000, M \le \frac{n^{2}-n}{2}, 1\le A\le B \le N, 1 \le V \le 1000\)。

题解

这题暴力分挺多的，有70分。先求出\(1\to N\)的最短路，然后大力删除最短路上的每一条边，每删一遍都跑一遍最短路，统计一下即可。

值得一提的是，由于本题是稠密图，所以用不加任何优化的dijkstra算法比较好，（总复杂度\(O(n^3)\)，因为最短路径上的边数最多只可能有\(n-1\)条），比对优化的少一只\(\log\)。

下面讲一下正解：

对于这张图，我们先以1为源点跑一遍dijkstra，记录下路径，在以N为起点跑一遍最短路。

对于任意一个结点\(T\)，其最短路一定是这样的：

\(P\)可能与\(1\)点重合。

我们把每个结点的的\(P\)记录下来，我们暂且把它记为\(P_{1}, P_{2}, \cdots, P_{N}\)，这我们可以用类似并查集的数据结构维护，也可以预处理出来：

/**
 * ddd是P数组
 * fa[x]是在1->x的最短路中x的上一个结点是什么
 **/

inline int getfa(int x)
{
	return ddd[x] ? ddd[x] : ddd[x] = getfa(fa[x]);
}

inline void getl(int from, int to)
{
	ljc = 1;
	ddd[from] = 1;
	for(int i = to; i != from; i = fa[i])
		ddd[i] = ljc++;
	for(int i = to; i != from; i = fa[i])
	{
		ddd[i] = ljc - ddd[i] + 1;
		mmap[i][fa[i]] = mmap[fa[i]][i] = inf;//把最短路上的边大力删除，下面会说 
	}
	for(int i = 1; i <= n; ++i)
		ddd[i] = getfa(i);
}

那么对于一条边\(f\to t\)（假设\(f\to t\)不是\(1\to t\)最短路或\(f\to N\)最短路中的一条，因为如果是我们可以忽略不计，应为这样结果是相同的），什么情况下\(1\to N\)的最短路径可能经过改变呢？

答案是当\([P_{f}, P_{t}]\)中的有一条路径被切断时。

如图，如果\(1\to P_{s}\)中的一条被切断了，那显然\(s\to N\)的最短路比\(s\to t \to N\)不劣；如果\(P_{t}\to N\)中的一条被切断了，那显然\(1\to t\)的最短路比\(1\to s \to t\)不劣。

于是，我们可以用线段树维护\(1\to N\)最短路的边如果删去最终的最短路，枚举所有除\(1\to N\)最短路边外的所有边，对于每个\(s\to t\)，都把\([P_{s}, P_{t}]\)的区间与\(1\to s \to t\)取\(\min\)，最终答案为所有边删去所得的最短路的最大值。

代码细节还是挺多的，调了好久（好吧可能是我太菜了）……

#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>

using namespace std;

#define fill(a) memset(a, 0x3f, sizeof(a))
#define clr(a) memset(a, 0, sizeof(a))

#define dd c = getchar()
inline void read(int& x)
{
	x = 0;
	int dd;
	for(; !isdigit(c); dd);
	for(; isdigit(c); dd)
		x = (x<<1) + (x<<3) + (c^48);
	return;
}
#undef dd

#define maxn 1050
#define inf 0x3f3f3f3f

int mmap[maxn][maxn];//反正都是n2，就偷懒用了邻接表
int n, m;
int ljc;

struct DIJKSTRA//其实从N开始的dijkstra只要求最短路就可以了，但还是偷懒打了结构体
{
	int dist[maxn];//最短路
	int ddd[maxn];//刚才说的P数组
	int fa[maxn];//fa[x]是在from->x的最短路中x的上一个结点是什么
	bool vis[maxn];

	inline void dijkstra(int from)//由于是稠密图，用不加优化的dijkstra更快
	{
		fill(dist);
		clr(vis);
		dist[from] = 0;
		int noww;
		for(int kk = 1; kk <= n; ++kk)
		{
			noww = 0;
			for(int i = 1; i <= n; ++i)
				if(!vis[i] && (!noww || dist[noww] > dist[i]))
					noww = i;
			vis[noww] = true;
			for(int i = 1; i <= n; ++i)
				if(!vis[i] && mmap[noww][i] + dist[noww] < dist[i])
				{
					dist[i] = mmap[noww][i] + dist[noww];
					fa[i] = noww;
				}
		}
	}

	inline int getfa(int x)
	{
		return ddd[x] ? ddd[x] : ddd[x] = getfa(fa[x]);
	}

	inline void getl(int from, int to)
	{
		ljc = 1;
		ddd[from] = 1;
		for(int i = to; i != from; i = fa[i])
			ddd[i] = ljc++;
		for(int i = to; i != from; i = fa[i])
		{
			ddd[i] = ljc - ddd[i] + 1;
			mmap[i][fa[i]] = mmap[fa[i]][i] = inf;//把最短路上的边大力删除
		}
		for(int i = 1; i <= n; ++i)
			ddd[i] = getfa(i);
	}
} fs, ft;

#define ls(x) (x<<1)
#define rs(x) (x<<1|1)

struct Tree
{
	int node[maxn];

	inline void build()
	{
		fill(node);//并不用建树，直接全赋最大值即可
	}

	inline void update(int l, int r, int k, int L, int R, int tt)
	{
		if(L <= l && r <= R)
		{
			node[k] = min(node[k], tt);
			return;
		}
		int mid = (l+r) >> 1;
		if(mid >= L)
			update(l, mid, ls(k), L, R, tt);
		if(mid < R)
			update(mid+1, r, rs(k), L, R, tt);
	}

	inline int query(int l, int r, int k, int pla)
	{
		if(l == r)
			return node[k];
		int mid = (l+r) >> 1;
		if(pla <= mid)
			return min(node[k], query(l, mid, ls(k), pla));
		else
			return min(node[k], query(mid+1, r, rs(k), pla));
	}
} tr;

int main()
{
	freopen("road.in", "r", stdin);
	freopen("road.out", "w", stdout);
	read(n);
	read(m);
	fill(mmap);
	for(int i = 1, f, t, d; i <= m; ++i)
	{
		read(f), read(t), read(d);
		mmap[f][t] = mmap[t][f] = d;
	}
	fs.dijkstra(1);
	ft.dijkstra(n);
	fs.getl(1, n);
	tr.build();
#define m (min(fs.dist[i] + ft.dist[j], ft.dist[i] + fs.dist[j]) + mmap[i][j])
#define l min(fs.ddd[i], fs.ddd[j]) + 1
#define r max(fs.ddd[i], fs.ddd[j])
	for(int i = 1; i <= n; ++i)
		for(int j = i + 1; j <= n; ++j)
			if(mmap[i][j] < inf)
				tr.update(1, ljc, 1, l, r, m);
#undef m
#undef l
#undef r
	int ans = 0;
	for(int i = 2; i <= ljc; ++i)
		ans = max(ans, tr.query(1, ljc, 1, i));
	printf("%d", ans);
	fclose(stdin);
	fclose(stdout);
	return 0;
}