pta L3-025 那就别担心了 (30 分)

下图转自“英式没品笑话百科”的新浪微博 —— 所以无论有没有遇到难题，其实都不用担心。

博主将这种逻辑推演称为“逻辑自洽”，即从某个命题出发的所有推理路径都会将结论引导到同一个最终命题（开玩笑的，千万别以为这是真正的逻辑自洽的定义……）。现给定一个更为复杂的逻辑推理图，本题就请你检查从一个给定命题到另一个命题的推理是否是“逻辑自洽”的，以及存在多少种不同的推理路径。例如上图，从“你遇到难题了吗？”到“那就别担心了”就是一种“逻辑自洽”的推理，一共有 3 条不同的推理路径。

输入格式：
输入首先在一行中给出两个正整数 N（1<N≤500）和 M，分别为命题个数和推理个数。这里我们假设命题从 1 到 N 编号。

接下来 M 行，每行给出一对命题之间的推理关系，即两个命题的编号 S1 S2，表示可以从 S1 推出 S2。题目保证任意两命题之间只存在最多一种推理关系，且任一命题不能循环自证（即从该命题出发推出该命题自己）。

最后一行给出待检验的两个命题的编号 A B。

输出格式：
在一行中首先输出从 A 到 B 有多少种不同的推理路径，然后输出 Yes 如果推理是“逻辑自洽”的，或 No 如果不是。

题目保证输出数据不超过 $10^9$

输入样例 1：
7 8
7 6
7 4
6 5
4 1
5 2
5 3
2 1
3 1
7 1
输出样例 1：
3 Yes
输入样例 2：
7 8
7 6
7 4
6 5
4 1
5 2
5 3
6 1
3 1
7 1
输出样例 2：
3 No

第一种思路肯定是dfs，但是最后一个测试点会超时

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(0);

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAXN = 505;
int s, t, count = 0;

vector<int> v[MAXN];
set<int> ss;

void dfs(int x) {
	if (x == t)
		::count++;
	else {
		if (!v[x].size())
			ss.insert(x);
		else
			for (int i = 0; i < v[x].size(); i++)
				dfs(v[x][i]);
	}
}

int main() {
	IOS;
	int n, m;
	cin >> n >> m;
	while (m--) {
		int x, y;
		cin >> x >> y;
		v[x].push_back(y);
	}
	cin >> s >> t;
	dfs(s);
	cout << ::count << ' ';
	if (!ss.size())
		cout << "Yes";
	else
		cout << "No";
	return 0;
}

第二种思路记忆化搜索（dfs+dp）

起初用 p[x] 存储从 s 到 x 的路径数，用stack内存会超限；反向存图不好判断是否“逻辑自洽”；

于是改用 p[x] 存储从 x 到 t 的路径数，递归调用即可；

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(0);

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAXN = 505;
int p[MAXN];
int s, t;
bool judge = 1;

vector<int> v[MAXN];

int dfs(int x) {
	if (p[x])
		return p[x];
	if (!v[x].size())
		judge = 0;
	for (int i = 0; i < v[x].size(); i++)
		p[x] += dfs(v[x][i]);
	return p[x];
}

int main() {
	IOS;
	int n, m;
	cin >> n >> m;
	while (m--) {
		int x, y;
		cin >> x >> y;
		v[x].push_back(y);
	}
	cin >> s >> t;
	p[t] = 1;
	dfs(s);
	cout << p[s] << ' ' << (judge == 1 ? "Yes" : "No");
	return 0;
}