【洛谷】【lca+结论】P3398 仓鼠找sugar

【题目描述：】

小仓鼠的和他的基（mei）友（zi）sugar住在地下洞穴中，每个节点的编号为1~n。地下洞穴是一个树形结构。这一天小仓鼠打算从从他的卧室（a）到餐厅（b），而他的基友同时要从他的卧室（c）到图书馆（d）。他们都会走最短路径。现在小仓鼠希望知道，有没有可能在某个地方，可以碰到他的基友？

小仓鼠那么弱，还要天天被zzq大爷虐，请你快来救救他吧！

【输入格式：】

第一行两个正整数n和q，表示这棵树节点的个数和询问的个数。

接下来n-1行，每行两个正整数u和v，表示节点u到节点v之间有一条边。

接下来q行，每行四个正整数a、b、c和d，表示节点编号，也就是一次询问，其意义如上。

【输出格式：】

对于每个询问，如果有公共点，输出大写字母“Y”；否则输出“N”。

输入样例#1： 
5 5
2 5
4 2
1 3
1 4
5 1 5 1
2 2 1 4
4 1 3 4
3 1 1 5
3 5 1 4
输出样例#1： 
Y
N
Y
Y
Y

【算法分析：】

对于四个点a, b, c, d，判断a->b, c->d这两条路径是否有重合的点，

容易想到分别求出(a, b), (c, d)的最近公共祖先，只要其中一个点对的lca在另一个点对的最短路径上，则这两条路径相交.

那如何判断lca与路径的位置关系呢？

首先想到树上差分，但每次O(n)维护一个前缀和肯定会超时，弃掉.

我们通过模拟可以得出这样的结论：

　若一个点x在路径s->t上，则：

1. 　　deep[x] ≥ deep[lca(s, t)]
2. 　　lca(x, s) = x 或 lca(x, t) = x

对于结论1.，由于x可以是lca(a, b)和lca(c, d)中的任意一个，所以自然是选择深度大的lca作为x

对于结论2.，选定了x之后只需两个判断即可.

【代码：】

//仓鼠找sugar
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int MAXN = 100000 + 1;
const int K = 17 + 1;

int n, Q;
int deep[MAXN], f[MAXN][K];
int edge_num, head[MAXN];
struct Edge {
    int to, nxt;
}h[MAXN << 1];

inline int read() {
    int x = 0, f = 1; char ch = getchar();
    while(ch<'0' || ch>'9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch>='0' && ch<='9')
        x = (x<<3) + (x<<1) + ch-48, ch = getchar();
    return x * f;
}

inline void Add(int from, int to) {
    h[++edge_num].to = to;
    h[edge_num].nxt = head[from];
    head[from] = edge_num;
}

inline void build(int u) {
    for(int i=head[u]; i!=-1; i=h[i].nxt) {
        if(!deep[h[i].to]) {
            deep[h[i].to] = deep[u] + 1;
            f[h[i].to][0] = u;
            build(h[i].to);
        }
    }
}

inline void fill() {
    for(int j=1; j<K; ++j)
    for(int i=1; i<=n; ++i)
        f[i][j] = f[f[i][j - 1]][j - 1];
}

inline int LCA(int a, int b) {
    if(deep[a] > deep[b]) swap(a, b);
    for(int i=K-1; i>=0; --i)
        if(deep[f[b][i]] >= deep[a]) b = f[b][i];
    if(a == b) return a;
    for(int i=K-1; i>=0; --i)
        if(f[a][i] != f[b][i])
            a = f[a][i], b = f[b][i];
    return f[b][0];
}

int main() {
    memset(head, -1, sizeof(head));
    n = read(), Q = read();
    for(int i=1; i<n; ++i) {
        int x = read(), y = read();
        Add(x, y), Add(y, x);
    }
    deep[1] = 1;
    build(1);
    fill();
    while(Q--) {
        int a = read(), b = read(), c = read(), d = read();
        int lca1 = LCA(a, b), lca2 = LCA(c, d);
        if(deep[lca1] > deep[lca2]) {
            swap(a, c); swap(b, d);
            swap(lca1, lca2);
        }
        if(LCA(lca2, a) == lca2 || LCA(lca2, b) == lca2) puts("Y");
        else puts("N");
    }
}