CF1650G 『Counting Shortcuts』 题解

从洛谷博客那里搬过来的（

---

图论专题本来打算先挑最简单的做，结果做了两个多小时（

题意就是让你找从起点 \(s\) 到终点 \(t\) 的最短路以及次短路个数，本题次短路长度指的是最短路长度 \(+1\)。

考虑 \(\text{DP}\)。

设 \(dp_{u,0/1}\) 为当前到了点 \(u\)，\(0/1\) 是与 \(s\) 到 \(u\) 的最短路长度相差 \(0/1\) 的路径的条数。

手模几组样例容易得出转移方程。先跑一遍 \(\text{Dijkstra}\) 算出 \(s\) 到所有点的最短路 \(dis\)，设当前点为 \(u\)，下一个点为 \(v\)。则有：

• 若 \(dis_v = dis_u\)，则说明 \(v\) 的最短路并非 \(u\) 的最短路 \(+1\)，而是 \(u\) 的最短路和 \(v\) 的最短路差 \(1\)，则可 \(dp_{u, 0} \to dp_{v, 1}\)。

• 若 \(dis_v = dis_u + 1\)，则说明 \(v\) 的最短路是可以由 \(u\) 转移过来的。于是v继承u的所有状态。即：\(dp_{u, 0} \to dp_{v, 0}\text{，}dp_{u, 1} \to dp_{v, 1}\)。

初态是 \(dp_{s, 0} = 1\)，因为题目问的是最短路与次短路个数之和所以末态为 \(dp_{t, 0} + dp_{t, 1}\)。

至此就可以高高兴兴写出一个 \(\text{dfs}\) 代码了。

void dfs(int x) {
	if (x == hd)
		return ;
	vis[x] = true;
	for (re i = head[x] ; i ; i = e[i].nxt) {
		int v = e[i].v;
		if (vis[v] == true)
			continue;
		if (dis[v] == dis[x])
			Plus(dp[v][1], dp[x][0]);
		else if (dis[v] == dis[x] + 1)
			Plus(dp[v][0], dp[x][0]), Plus(dp[v][1], dp[x][1]);
		dfs(v);
	}
	vis[x] = false;
}

然后测一下前三个样例，哇，都过了。以为这题就要切了，测第四个样例结果发现输出 1204。

显然是转移多了。考虑下面一张图：

按照写的 \(\text{dfs}\) 模一下发现点 \(4\) 和点 \(3\) 转移到点 \(5\) 的时候出现了问题：转移顺序。

比如转移顺序：\(2 \to 4 \to 5\)，但是还有 \(2 \to 3 \to 4 \to 5\)，发现在第一遍转移的时候已经转移给了点 \(5\)，但是第二次转移的时候除了把新的值转移给了 \(5\)，还把以前的值又转移了一遍。所以就转移多了。

考虑如何解决。既然你是重复转移了前一次的，那我对于每个点转移过了之后把他的 \(\text{dp}\) 值清空，下一次再来到这个点的时候就不会重复转移上一次的值了。

void dfs(int x) {
	if (x == hd)
		return ;
	vis[x] = true;
	for (re i = head[x] ; i ; i = e[i].nxt) {
		int v = e[i].v;
		if (vis[v] == true)
			continue;
		if (dis[v] == dis[x])
			Plus(dp[v][1], dp[x][0]);
		else if (dis[v] == dis[x] + 1)
			Plus(dp[v][0], dp[x][0]), Plus(dp[v][1], dp[x][1]);
		dfs(v);
	}
	dp[x][0] = dp[x][1] = 0;// 多加了这一句
	vis[x] = false;
}

交上去会发现 TLE on test #3，我不太清楚 \(\text{dfs}\) 常数大还是咋地，卡了半天常也过不去（

\(\text{Update}\)：加个记搜大概能过，\(\text{dfs}\) 慢是因为有重复的转移，旁边的大佬说造个完全图可以卡到指数级别（。

考虑换一种解决方法。发现重复转移的实质就是拿还没转移完毕的去更新其他的了，于是考虑如何让他转移完毕再去更新。

注意到点 \(u\) 所有的转移都是对于 \(dis_v = dis_u\) 或 \(dis_v = dis_u + 1\) 的 \(v\) 去转移，这启示我们按照 \(dis\) 对原图进行分层。对于每个点 \(u\) 先对于同层也就是 \(dis_v = dis_u\) 的点 \(v\) 进行转移，全部转移完毕后再去转移 \(dis_v = dis_u + 1\) 的点 \(v\) 即可。

\(\text{DP}\) 转移时间复杂度是 \(\mathcal O(n)\) 的，最短路时间复杂度是 \(\mathcal O(n \log n)\) 的，于是总时间复杂度为 \(\mathcal O(n \log n)\)。

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#define GMY (520 & 1314)
#define char_phi int
#define re register int
#define FBI_OPENTHEDOOR(x, y) freopen(#x ".in", "r", stdin), freopen(#y ".out", "w", stdout)
#define N 2000005
#define M 2000005
#define P 1000000007
using namespace std;
inline void Fastio_setup() { ios :: sync_with_stdio(false); cin.tie(NULL), cout.tie(NULL); }
inline int MAX(int x, int y) { return ((x > y) ? (x) : (y)); }
inline int MIN(int x, int y) { return ((x < y) ? (x) : (y)); }
 
int n, m, star_cnt, yd, hd;
char vis[N];
int head[N], q[M<<3], dis[N];
int dp[N][2];
 
struct star { int v, nxt; };
struct Node {
	int x, d;
	
	friend bool operator < (Node A, Node B) { return A.d > B.d; }
};
 
struct star e[M<<1];
 
priority_queue<Node> heap;
vector<int> vec[N];
 
inline void star_add(int u, int v) { e[++ star_cnt].v=v, e[star_cnt].nxt=head[u], head[u]=star_cnt; }
inline void Clean() {
	star_cnt = 0; vec[0].clear();
	for (re i = 1 ; i <= n ; ++ i) {
		head[i] = dp[i][0] = dp[i][1] = 0;
		vec[i].clear();
	}
}
 
inline void Dijkstra() {
	int x = yd; for (re i = 1 ; i <= n ; ++ i) dis[i] = 0x3f3f3f3f, vis[i] = false;
	heap.push( (Node) {x, 0} ); dis[x] = 0;
	while (heap.empty() == false) {
		x = heap.top().x; heap.pop();
		if (vis[x] == true)
			continue;
		vis[x] = true;
		for (re i = head[x] ; i ; i = e[i].nxt) {
			int v = e[i].v;
			if (dis[v] > dis[x] + 1) {
				dis[v] = dis[x] + 1;
				if (vis[v] == false)
					heap.push( (Node) { v, dis[v] } );
			}
		}
	}
}
inline void Plus(int& who, int val) { who += val; if (who >= P) who -= P; }
 
inline void Search() {// 先更新0再更新1
	for (re i = 1 ; i <= n ; ++ i) {
		vis[i] = false;
		vec[dis[i]].emplace_back(i);
	}
	
	dp[yd][0] = 1;
	for (re dep = 0 ; dep <= n ; ++ dep) {
		for (auto x : vec[dep])
			for (re i = head[x] ; i ; i = e[i].nxt) {// 先转移同层的
				int v = e[i].v;
				if (dis[v] == dep)
					Plus(dp[v][1], dp[x][0]);
			}
		for (auto x : vec[dep])
			for (re i = head[x] ; i ; i = e[i].nxt) {// 再转移其他层的
				int v = e[i].v;
				if (dis[v] == dep + 1)
					Plus(dp[v][0], dp[x][0]), Plus(dp[v][1], dp[x][1]);
			}
	}
}


inline void work() {
	Clean();
	cin >> n >> m; cin >> yd >> hd;
	for (re i = 1, uu, vv ; i <= m ; ++ i)
		{cin >> uu >> vv; star_add(uu, vv), star_add(vv, uu);}
	
	Dijkstra();
	Search();// 也许算是bfs罢
	
	cout << (dp[hd][0] + dp[hd][1]) % P << '\n';
}
 
#undef int
// #define IXINGMY
char_phi main() {
	#ifdef IXINGMY
		FBI_OPENTHEDOOR(a, a);
	#endif
	Fastio_setup();
	int T; cin >> T;
	while (T --)
		work();
	return GMY;
}

\(\text{Hint}\)：参考了 \(\text{Jerry-Black}\) 大佬的思路。