训练-那就别担心了（两种解法，拓扑排序+记忆化搜索）

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

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

输入格式：

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

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

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

输出格式：

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

题目保证输出数据不超过 109。

输入样例 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

 解法一：记忆化搜索

f[i]:从节点i到节点B路径条数。走到B了要及时返回，此题还要判断一下B是不是唯一终点，具体看下面的代码。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=510,M=N*N;
int h[N],e[M],ne[M],idx;
int f[N];
bool flag=true;
int n,m,A,B;
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int dfs(int u)
{
	if(f[u]!=-1) return f[u];
	if(u==B) return 1;
	bool ff=true;
	int res=0;
	for(int i=h[u];~i;i=ne[i])
	{
		int j=e[i];
		res+=dfs(j);
		ff=false;
	}
	if(ff) flag=false;
	return f[u]=res;
}
int main()
{
	cin>>n>>m;
	memset(h,-1,sizeof h);
	memset(f,-1,sizeof f);
	while(m--)
	{
		int a,b;
		cin>>a>>b;
		add(a,b);
	}
	cin>>A>>B;
	cout<<dfs(A)<<" ";
	if(flag) cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
	return 0;
}

 

拓扑排序+重新建边 

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=510,M=N*N;
int h[N],hs[N],e[M],ne[M],idx;
int d[N],q[N],hh,tt=-1;
int cnt[N];
bool st[N];
int n,m,A,B;
bool flag=true;
void add(int h[],int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u)
{
	if(u==B) return;
	if(st[u]) return;
	
	st[u]=true;
	bool f=true;
	for(int i=h[u];~i;i=ne[i])
	{
		int j=e[i];
		add(hs,u,j);
		d[j]++;
		dfs(j);
		f=false;
	}
	if(f) flag=false;
}
void topsort()
{
	q[++tt]=A;
	while(hh<=tt)
	{
		int t=q[hh++];
		for(int i=hs[t];~i;i=ne[i])
		{
			int j=e[i];
			if(--d[j]==0)
				q[++tt]=j;
		}
	}
}
int main()
{
	memset(h,-1,sizeof h);
	memset(hs,-1,sizeof hs);
	cin>>n>>m;
	while(m--)
	{
		int a,b;
		cin>>a>>b;
		add(h,a,b);
	}
	cin>>A>>B;
	dfs(A);
	topsort();
	cnt[A]=1;
	for(int k=0;k<=tt;k++)
	{
		int u=q[k];
		for(int i=hs[u];~i;i=ne[i])
		{
			int j=e[i];
			cnt[j]+=cnt[u];
		}
	}
	cout<<cnt[B]<<" ";
	if(flag) cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
	return 0;
}