洛谷：P3953 [NOIP2017 提高组] 逛公园（图上dp、记忆化搜索）

逛公园

题意：

• 类似最短路计数，但是计的是不超过最短路长度 + K 的路线个数。

思路：

• 可以发现 K 很小，往 dp 方向思考。

• 定义 $dis{t}_{1u}$ 为 1 到 u 的最短路长度

• 定义 $f[i][j]$ 为 长度不超过 $dis{t}_{1i}+j$ 的路径个数

• 对于任意一条边的两点：

• 根据三角不等式，肯定有 $dis{t}_{1u}+w>=dis{t}_{1v}$
  

• 因此对于任意 $f[v][j]$，有 $j-(dis{t}_{1u}+w-dis{t}_{1v})==k$。

这样我们就可以开始愉快的 记忆化搜索 了。

但还要一个问题，什么时候有无穷多条合法路径？

• 当存在 0 环的时候，就可以通过无限走环，让路径数无限。
• 判断这种情况可以通过传统 dfs 标记做到，当我们走到了之前标记过的一个点，证明存在环。

$Code:$

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul (u << 1)
#define ur (u << 1 | 1)
#define forr(a,b,c) for(int a=b;a<=c;a++)
#define rfor(a,b,c) for(int a=b;a>=c;a--)
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 100010, M = 400010, MM = N;
int INF = 0x3f3f3f3f, mod = 998244353;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
int h[N], rh[N], e[M], ne[M], w[M], idx;
int dist[N], dp[N][51];
bool st[N], stt[N][51];

inline void add(int* h, int a, int b, int x) {
	e[idx] = b, ne[idx] = h[a], w[idx] = x, h[a] = idx++;
}

void dj(int x) {
	dist[x] = 0;
	priority_queue<PII, vector<PII>, greater<PII>> q;
	q.push({ 0,x });

	while (q.size())
	{
		int ver = q.top().second;
		q.pop();

		if (st[ver])continue;
		st[ver] = true;

		for (int i = h[ver]; ~i; i = ne[i]) {
			int j = e[i];
			if (dist[j] > dist[ver] + w[i]) {

				q.push({ dist[j],j });
			}
		}
	}
}

int dfs(int x, int d) {
	if (d < 0 || d > k)return 0;//不合法的 k 情况排除
	if (stt[x][d]) { //若该点被标记过，此时存在 0 环
		stt[x][d] = false;
		return -1;
	}
	if (dp[x][d] != -1)return dp[x][d];//记忆化返回

	stt[x][d] = true;
	int res = 0;
	for (int i = rh[x]; ~i; i = ne[i]) {
		int j = e[i];
		int val = dfs(j, d + dist[x] - dist[j] - w[i]);//转移
		if (val == -1) {
			stt[x][d] = false;
			return -1;
		}
		res = (res + val) % mod;
	}
	stt[x][d] = false;

	if (x == 1 && d == 0)res++;//边界情况
	dp[x][d] = res;//记忆化
	return res;
}

void solve() {
	cin >> n >> m >> k >> mod;
	idx = 0;
	forr(i, 1, n) {
		h[i] = rh[i] = -1;
		dist[i] = INF;
		st[i] = false;
		forr(j, 0, 50)dp[i][j] = -1;
	}

	forr(i, 1, m) {
		int a, b, x;
		cin >> a >> b >> x;
		add(h, a, b, x), add(rh, b, a, x);
	}
	dj(1);//预处理 1 到 各个点 的距离

	int ans = 0;
	forr(i, 0, k) { //枚举 f[n][i]，要从小到大
		int t = dfs(n, i);
		if (t == -1) {
			cout << -1 << '\n';//一旦有 0 环
			return;
		}
		ans = (ans + t) % mod;//累计方案
	}
	cout << ans << '\n';
}

int main() {
	cinios;

	cin >> T;
	while (T--)solve();

	return 0;
}
/*
*/