[USACO19DEC]Milk Visits S（LCA）

题目链接

Farmer John 计划建造 N 个农场，用 N-1 条道路连接，构成一棵树（也就是说，所有农场之间都互相可以到达，并且没有环）。每个农场有一头奶牛，品种为更赛牛或荷斯坦牛之一。

Farmer John 的 M 个朋友经常前来拜访他。在朋友 i 拜访之时，Farmer John 会与他的朋友沿着从农场 Ai​ 到农场 Bi​ 之间的唯一路径行走（可能有 Ai​=Bi​）。除此之外，他们还可以品尝他们经过的路径上任意一头奶牛的牛奶。由于 Farmer John 的朋友们大多数也是农场主，他们对牛奶有着极强的偏好。他的有些朋友只喝更赛牛的牛奶，其余的只喝荷斯坦牛的牛奶。任何 Farmer John 的朋友只有在他们访问时能喝到他们偏好的牛奶才会高兴。

请求出每个朋友在拜访过后是否会高兴。

题意：回答a-b的路径上是否有点权为H或者G的点。

思路：LCA数组开到三维，最后一维为0记录跳的节点，为1时记录跳的路径上是否有H点，为2是记录跳的路径上是否有为G的点，但是对数组的转移有所不同，在初始赋值的时候：

fa[v][0][0]=t;

fa[v][0][1]=((p[v]=='H')|(p[t]=='H'));

fa[v][0][2]=((p[v]=='G')|(p[t]=='G'));

需要判断父节点和自身是否为H或者G，然后转移的时候：

fa[v][k][0]=fa[fa[v][k-1][0]][k-1][0];

fa[v][k][1]=fa[v][k-1][1]|fa[fa[v][k-1][0]][k-1][1];

 fa[v][k][2]=fa[v][k-1][2]|fa[fa[v][k-1][0]][k-1][2];

LCA跳的时候特判两个情况，即为a和b本身相同，或者a和b的父节点相同。

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct node{
    int x,to;
};
node e[maxn<<1];
char p[maxn];
int h[maxn];
int idx=0;
void add(int a,int b){
    e[idx].x=b,e[idx].to=h[a],h[a]=idx++;
}
int depth[100010],fa[100010][21][3];
void bfs(int root){
    memset(depth,0x3f,sizeof depth);
    depth[0]=0,depth[root]=1;
    queue<int>q;
    q.push(root);
    while(!q.empty()){
        int t=q.front();
        q.pop();
        for(int i=h[t];i!=-1;i=e[i].to){
            int v=e[i].x;
            if(depth[v]>depth[t]+1){
                depth[v]=depth[t]+1;
                q.push(v);
                fa[v][0][0]=t;
                fa[v][0][1]=((p[v]=='H')|(p[t]=='H'));
                fa[v][0][2]=((p[v]=='G')|(p[t]=='G'));
                for(int k=1;k<=20;k++){
                    fa[v][k][0]=fa[fa[v][k-1][0]][k-1][0];
                    fa[v][k][1]=fa[v][k-1][1]|fa[fa[v][k-1][0]][k-1][1];
                    fa[v][k][2]=fa[v][k-1][2]|fa[fa[v][k-1][0]][k-1][2];
                }
            }
        }
    }
}
int LCA(int a,int b,int w){
    if(depth[a]<depth[b])swap(a,b);
    for(int k=20;k>=0;k--){
        if(depth[fa[a][k][0]]>=depth[b]){
            if(fa[a][k][w])return 1;
            a=fa[a][k][0];
        }
    }
    if(a==b){//本身即为一个点不会进入第一个循环
        char c;
        if(w==1){
            c='H';
        }
        else c='G';
        if(p[a]==c)return true;
        else return false;
    }
    for(int k=20;k>=0;k--){
        if(fa[a][k][0]!=fa[b][k][0]){
            if(fa[a][k][w])return true;
            if(fa[b][k][w])return true;
            a=fa[a][k][0];
            b=fa[b][k][0];
        }
    }
    if(fa[a][0][w]||fa[b][0][w])return true;//本身父亲为一个点不会进入前两个循环
    else return false;
}
int main(){
    int n,m;
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    int x,y;
    getchar();
    for(int i=1;i<=n;i++){
        scanf("%c",&p[i]);
    }
    for(int i=1;i<n;i++){  
        scanf("%d%d",&x,&y);
        add(x,y),add(y,x);
    }
    bfs(1);
    char c[10];
    int a,b,w;
    for(int i=1;i<=m;i++)
	{
		scanf("%d%d%s",&a,&b,&c);
		if(c[0]=='H') w=1;
		else w=2;
		cout<<LCA(a,b,w);//跳
	}
}

还有一个并查集的做法，按照路径读入的时候，判断两个点的颜色是否相同，如果两个点的颜色相同则放到一个集合中，如果两个点在一个集合中，说明两点之间所有点的颜色都相同，如果该颜色不是要的颜色，则输出0，否则两点不在一个集合中或者在一个集合中且颜色与要的颜色相同都是答案。

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
int n,m;
char p[maxn];
int fa[maxn];
int find(int x){
    if(fa[x]==x)return x;
    else return fa[x]=find(fa[x]);
}
int main(){
    scanf("%d%d",&n,&m);
    scanf("%s",p+1);
    int a,b;
    for(int i=1;i<=n;i++){
        fa[i]=i;
    }
    for(int i=1;i<n;i++){
        scanf("%d%d",&a,&b);
        if(p[a]==p[b]){
            int x=find(a);
            int y=find(b);
            fa[x]=y;
        }
    }
    char ch[10];
    for(int i=1;i<=m;i++){
        scanf("%d%d%s",&a,&b,ch);
        if(find(a)==find(b)&&p[a]!=ch[0]){
            printf("0");
        }
        else printf("1");
    }
}