Gym 100685G

好坑啊。。。。查询竟然有从自身到自身。。。还是年轻啊。。

题意大致是给你一个有向图，然后给你一些查询，问你是否能从x点到y点，题意保证这个图的基图是一个树。

思路：首先因为将任何点作为根都可以，为了方便就让节点1为这棵树的根节点，而后将该树每一个节点的深度（即层数）储存到dep数组里面，还有根到这个点经历过多少个正向边和反向边，分别用1和-1保存在dp数组里，这样如果u能到v，设他们最近公共祖先为w，那么u到w必定全是反向边（相对于根），w到v必定都是正向边，最后只需要将u和v的最近公共祖先求出来判断就行。

我是用的静态LCA，因为一个读题的错误，导致我卡了好几天，题意中明明没说查询的x!=y，而我忽略了这种情况，xjb搞，还是得谢谢学长帮我看出来，自己还是练得不够。

代码：

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 100005;
int f[N];
int dep[N], dp[N], vis[N];
int n;
struct Edge
{
    int v, c;
};
struct Dir
{
    int v, id;
    int c;
};
vector<Edge> edges[N];
vector<Dir> que[N];
vector<Edge> ans;
void dfs(int u, int f, int d)
{
    dep[u] = d;
    for(int i = 0; i < edges[u].size(); ++i)
    {
        Edge& e = edges[u][i];
        if(e.v == f)
            continue;
        dp[e.v] = dp[u] + (e.c == 1 ? 1 : -1);
        dfs(e.v, u, d + 1);
    }
}
int Find(int x)
{
    return x == f[x] ? x : f[x] = Find(f[x]);
}
void LCA(int root, int prev)
{
    for(int i = 0; i < edges[root].size(); ++i)
    {
        int v = edges[root][i].v;
        if(v != prev)
        {
            LCA(v, root);
            int a = Find(root);
            int b = Find(v);
            f[b] = a;
        }
    }
    vis[root] = 1;
    for(int i = 0; i < que[root].size(); ++i)
    {
        Dir &t = que[root][i];
        if(vis[t.v])
        {
            int k = Find(t.v);
            int d1 = dp[root] - dp[k];
            int d2 = dp[t.v] - dp[k];
            int d3 = dep[root] - dep[k];
            int d4 = dep[t.v] - dep[k];
            if(t.c == 1 && d2 == d4 && d1 == -d3 || t.c == 0 && d1 == d3 && d2 == -d4)
            {
                ans.push_back({1, t.id});
            }
            else
            {
                ans.push_back({0, t.id});
            }
        }
    }
}
bool cmp(const Edge &t1, const Edge &t2)
{
    return t1.c < t2.c;
}
int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n - 1; ++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        edges[u].push_back({v, 1});
        edges[v].push_back({u, 0});
    }
    int m;
    scanf("%d", &m);
    for(int i = 0; i < m; ++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        que[u].push_back({v, i, 1});
        que[v].push_back({u, i, 0});
    }
    dp[1] = 0;
    dfs(1, -1, 0);
    for(int i = 1; i <= n; ++i)
        f[i] = i;
    memset(vis, 0, sizeof(vis));
    LCA(1, -1);
    sort(ans.begin(), ans.end(), cmp);
    for(int i = 0; i < ans.size(); ++i)
    {
        if (i && ans[i].c == ans[i - 1].c) continue;
        printf("%s\n", ans[i].v == 1 ? "Yes" : "No");
//        cout << "ans.id == " << ans[i].c << endl;
    }
}