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

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

这是上个月天梯赛的一道题，当时比赛的时候觉得正好有个见过的模型，就照着写了一个类似宽搜的东西 但是挂掉了，好像当时只得了11分，现在重新写还是一样的算法 是19分，改了一个记忆化搜索的方式能AC

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#define Maxn 505
/*
 * 基于宽度优先搜索是不能实现绝对层级展开的
 * 故存在一定的错误性
 * */

using namespace std;
int head[Maxn];
struct Edge{
    int v,nxet,u;
}e[Maxn * Maxn];
int tot,flag = 1,num[Maxn];
bool exist[Maxn];
inline void Add_Edge(int u,int v) {
    e[++tot].u = u,e[tot].v = v,e[tot].nxet = head[u]; head[u] = tot;
}

int DFS(int x) {
    if(num[x]) return num[x];
    int res = 0;
    for(int i=head[x]; i; i=e[i].nxet) {
        int v = e[i].v;
        if(!num[v]) DFS(v);
        res += num[v];
    }
    if(res == 0) flag = false;
    return num[x] = res;
}

void BFS(int start,int end) {
    queue<int> q;
    memset(exist,0,sizeof(exist));
    q.push(start); exist[start] = 1;
    while(!q.empty()) {
        int u = q.front(); q.pop(); exist[u] = 0;
        if(head[u] == 0 && u != end) flag = 0;
        for(int i=head[u]; i; i=e[i].nxet) {
            int v = e[i].v;
            num[v] += num[u];
            if(!exist[v]) q.push(v),exist[v] = 1;
        }
    }
}

int main(int argc,char* argv[]) {
    int n,m; scanf("%d %d",&n,&m);
    for(int u,v,i=1; i<=m; i++) {
        scanf("%d %d",&u,&v);
        Add_Edge(u,v);
    }
    int A,B;
    scanf("%d %d",&A,&B);
    num[A] = 1;//  记忆化搜索
    BFS(A,B);
    cout << num[B] << ' ';
    if(flag) cout << "Yes";
    else cout << "No";
    return 0;
}

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#define Maxn 505
/*
 * 基于宽度优先搜索是不能实现绝对层级展开的
 * 故存在一定的错误性
 * */

using namespace std;
int head[Maxn];
struct Edge{
    int v,nxet,u;
}e[Maxn * Maxn];
int tot,flag = 1,num[Maxn];
bool exist[Maxn];
inline void Add_Edge(int u,int v) {
    e[++tot].u = u,e[tot].v = v,e[tot].nxet = head[u]; head[u] = tot;
}

int DFS(int x) {
    if(num[x]) return num[x];
    int res = 0;
    for(int i=head[x]; i; i=e[i].nxet) {
        int v = e[i].v;
        if(!num[v]) DFS(v);
        res += num[v];
    }
    if(res == 0) flag = false;
    return num[x] = res;
}

int main(int argc,char* argv[]) {
    int n,m; scanf("%d %d",&n,&m);
    for(int u,v,i=1; i<=m; i++) {
        scanf("%d %d",&u,&v);
        Add_Edge(u,v);
    }
    int A,B;
    scanf("%d %d",&A,&B);
    num[B] = 1;//  记忆化搜索的方式记得把num[B]设成1
    DFS(A);
    cout << num[B] << ' ';
    if(flag) cout << "Yes";
    else cout << "No";
    return 0;
}