L2-016 愿天下有情人都是失散多年的兄妹 (25 分)

呵呵。大家都知道五服以内不得通婚，即两个人最近的共同祖先如果在五代以内（即本人、父母、祖父母、曾祖父母、高祖父母）则不可通婚。本题就请你帮助一对有情人判断一下，他们究竟是否可以成婚？

输入格式：

输入第一行给出一个正整数N（2 ≤ N ≤104），随后N行，每行按以下格式给出一个人的信息：

本人ID 性别 父亲ID 母亲ID

其中ID是5位数字，每人不同；性别M代表男性、F代表女性。如果某人的父亲或母亲已经不可考，则相应的ID位置上标记为-1。

接下来给出一个正整数K，随后K行，每行给出一对有情人的ID，其间以空格分隔。

注意：题目保证两个人是同辈，每人只有一个性别，并且血缘关系网中没有乱伦或隔辈成婚的情况。

输出格式：

对每一对有情人，判断他们的关系是否可以通婚：如果两人是同性，输出Never Mind；如果是异性并且关系出了五服，输出Yes；如果异性关系未出五服，输出No。

输入样例：

24
00001 M 01111 -1
00002 F 02222 03333
00003 M 02222 03333
00004 F 04444 03333
00005 M 04444 05555
00006 F 04444 05555
00007 F 06666 07777
00008 M 06666 07777
00009 M 00001 00002
00010 M 00003 00006
00011 F 00005 00007
00012 F 00008 08888
00013 F 00009 00011
00014 M 00010 09999
00015 M 00010 09999
00016 M 10000 00012
00017 F -1 00012
00018 F 11000 00013
00019 F 11100 00018
00020 F 00015 11110
00021 M 11100 00020
00022 M 00016 -1
00023 M 10012 00017
00024 M 00022 10013
9
00021 00024
00019 00024
00011 00012
00022 00018
00001 00004
00013 00016
00017 00015
00019 00021
00010 00011

输出样例：

Never Mind
Yes
Never Mind
No
Yes
No
Yes
No
No

---

看到了大佬使用双端bfs的解法，很妙，也有用dfs的

双端bfs的注意事项，连边的时候，子节点向双亲节点连单向边，不要回连。

/*
A: 10min
B: 20min
C: 30min
D: 40min
*/ 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <vector>
#include <sstream>
#define pb push_back 
#define all(x) (x).begin(),(x).end()
#define mem(f, x) memset(f,x,sizeof(f)) 
#define fo(i,a,n) for(int i=(a);i<=(n);++i)
#define fo_(i,a,n) for(int i=(a);i<(n);++i)
#define debug(x) cout<<#x<<":"<<x<<endl;
#define endl '\n'
using namespace std;
//#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

template<typename T>
ostream& operator<<(ostream& os,const vector<T>&v){for(int i=0,j=0;i<v.size();i++,j++)if(j>=5){j=0;puts("");}else os<<v[i]<<" ";return os;}
template<typename T>
ostream& operator<<(ostream& os,const set<T>&v){for(auto c:v)os<<c<<" ";return os;}
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const map<T1,T2>&v){for(auto c:v)os<<c.first<<" "<<c.second<<endl;return os;}
template<typename T>inline void rd(T &a) {
    char c = getchar(); T x = 0, f = 1; while (!isdigit(c)) {if (c == '-')f = -1; c = getchar();}
    while (isdigit(c)) {x = (x << 1) + (x << 3) + c - '0'; c = getchar();} a = f * x;
}

typedef pair<int,int>PII;
typedef pair<long,long>PLL;

typedef long long ll;
typedef unsigned long long ull; 
const int N=1e5+10,M=2e6+10;
/*
20点31分
看到了dfs，bfs的写法，感觉非常的厉害，我只能想到带到祖宗节点的并查集
想不到也可以bfs，dfs
*/
int n,h[N],e[M],ne[M],idx;
void add(int a, int b)  // 添加一条边a->b
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
char sex[N];
int dist[N];
// bool st[N];
bool bfs(int S,int T){
    queue<int>que;
    memset(dist,0,sizeof dist);
    que.push(S);
    que.push(T);
    dist[S]=dist[T]=1;
    /*
    bfs 不是 spfa
    */
    while(que.size()){
        auto t = que.front();
        que.pop();
        
        if(dist[t] == 5)return 1;
        
        for(int i=h[t];~i;i=ne[i]){
            int j=e[i];
            if(dist[j])return false;
            dist[j]=dist[t]+1;
            que.push(j);
        }
    }
    return true;
}

void solve(){
    memset(h,-1,sizeof h);
    cin>>n;
    for(int i=1;i<=n;i++){
        int id,fa,ma;
        cin>>id>>sex[id]>>fa>>ma;
        
        if(fa!=-1){
            sex[fa]='M';
            add(id,fa);//不能从父节点向下走，否则bfs里边，边循环的时候就会出问题。
            // add(fa,id);
        }
        if(ma!=-1){
            sex[ma]='F';
            add(id,ma);
            // add(ma,id);
        }
    }    
    int k;cin>>k;
    while(k--){
        int a,b;cin>>a>>b;
        if(sex[a]==sex[b]){
            puts("Never Mind");
        }
        else{
            if(bfs(a,b)){
                puts("Yes");
            }
            else{
                puts("No");
            }
        }
    }
}

int main(){
	solve();
	return 0;
}