hdu 4674 Trip Advisor（缩点+倍增lca）

花了一天半的时间，才把这道题ac= =

确实是道好题，好久没敲这么长的code了，尤其是最后的判定，各种销魂啊~

题目中给出的条件最值得关注的就是：每个点最多只能在一个环内->原图是由一个个边连通分量以树形连接组成的->做无向图缩点后，得到的是一个树形结构。

题目要求：u->v，必须经过p，且不能重复经过同一个点，即在树上从u到v做一笔画。

开始先想到汉密尔顿迹，不过那是走全部点的。利用已获得的树形结构，通过lca来判断p，这就是一个合理的作法。

注意：由于是任意建树，p不一定是u，v的lca，纠结了好久才想出了一个方法:x=lca(u,v)，然后遍历v->x，u->x两条路径，找p——会超时的，太繁琐了。朋友提出了，找u，v，p中两两的lca：if(lca(u,v)==lca(u,p)&&lca(v,p)==p)就可以判断缩点后的p在u，v路径上。为什么是缩点后的呢？自己想吧，后面判断要用到的。

缩点和倍增lca自己学吧，我也是为了做这道题才学了lca T^T 之前连“爬楼梯”都不会。

这道题的精彩之处就在于最后的判定。

从u==v&&v==p 三点共点->两点共点，再到缩点后三点共点，两点共点要一一讨论。

其中容易忽视的：1、u，p缩点后cu，cp共点，点u在向cv出发的方向的出口上。（若要经过p，u点必然要重复经过）

2、环cp在u->v的路径上，但进出在同一点，并且不是点p。（若要经过p，该出入点必然要重复经过）

其他一些容易犯的错误我都在code中注明。不过这道题的价值也就体现于此，自己做吧。再次膜拜现场出题的大牛。

注：TLE了好久，后来就wa，为了调程序，编了一组七个点的数据，从111->777共344组测试，code中附上了数据以及自己代码中找到的三组错误测试，修正后就ac了。

#pragma comment(linker,"/STACK:1024000000,1024000000")
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN=111111;
const int MAXM=155555;
const int POW=18;

struct Edge{
    int v,next;
    int vis,bridge;
    Edge(){}
    Edge(int _v,int _next):v(_v),next(_next),vis(0){}
}edge[MAXM<<1];

int head[MAXN],tol;
int stk[MAXN],top;
int pre[MAXN],low[MAXN],bccno[MAXN],bcc_cnt,dfs_clock;
vector<int>G[MAXN];
int d[MAXN],p[MAXN][POW];

void init()
{
    tol=0;
    memset(head,-1,sizeof(head));
}

void add(int u,int v)
{
    edge[tol]=Edge(v,head[u]);
    head[u]=tol++;
}

void build(int m)
{
    int u,v;
    init();
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
}

void dfs(int u)
{
    int v;
    pre[u]=low[u]=++dfs_clock;
    stk[top++]=u;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        if(edge[i].vis)
            continue ;
        edge[i].vis=edge[i^1].vis=1;
        v=edge[i].v;

        if(!pre[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }else if(!bccno[v])
            low[u]=min(low[u],pre[v]);
    }

    if(low[u]==pre[u]){
        bcc_cnt++;
        do{
            v=stk[--top];
            bccno[v]=bcc_cnt;
        }while(v!=u);
    }
}

void tarjin(int n)
{
    bcc_cnt=dfs_clock=0;
    memset(pre,0,sizeof(pre));
    memset(bccno,0,sizeof(bccno));

    top=0;
    for(int i=1;i<=n;i++)
        if(!pre[i])
            dfs(i);
}

void rebuild(int n)
{
    for(int i=1;i<=bcc_cnt;i++)     //!!把bcc_cnt写成n = =
        G[i].clear();
    for(int i=1;i<=n;i++)
    {

        for(int j=head[i];j!=-1;j=edge[j].next)
        {
            int v=edge[j].v;
            if(bccno[i]!=bccno[v])
                G[bccno[i]].push_back(v);    //!!桥，这里写v而不是bccno[v],是为了后面judge()判断环的出入口
        }
    }
}

void DFS(int u,int fa)
{
    d[u]=d[fa]+1;
    p[u][0]=fa;
    for(int i=1;i<POW;i++)
        p[u][i]=p[p[u][i-1]][i-1];
    int sz=G[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=bccno[G[u][i]];
        if(v==fa)
            continue;
        DFS(v,u);
    }
}

int lca( int a, int b ){
    if( d[a] > d[b] ) a ^= b, b ^= a, a ^= b;
    if( d[a] < d[b] ){
        int del = d[b] - d[a];
        for( int i = 0; i < POW; i++ ) if(del&(1<<i)) b=p[b][i];
    }
    if( a != b ){
        for( int i = POW-1; i >= 0; i-- )
            if( p[a][i] != p[b][i] )
                 a = p[a][i] , b = p[b][i];
        a = p[a][0], b = p[b][0];
    }
    return a;
}

void LCA(int n)//这里只是处理了一下新图中各个点的深度
{
    d[1]=0;
    DFS(1,1);
}

int Double(int a,int b)//倍增
{
    int del=d[a]-d[b]-1;
    for(int i=0;i<POW;i++)
        if(del&(1<<i))
            a=p[a][i];
    return a;
}

int judge(int u,int v)//返回值是该方向上环的出入口
{
    int sz=G[u].size();
    for(int i=0;i<sz;i++)
        if(bccno[G[u][i]]==bccno[v])
            return G[u][i];
}

void solve()
{
    int k;
    int u,v,w;
    scanf("%d",&k);
    for(int i=1;i<=k;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        int a=bccno[u],b=bccno[v],c=bccno[w];
        if(u==v&&v==w)
            printf("Yes
");
        else if(u==w||v==w)//!!注意：即使考虑了两点uw（或vw）缩点后重合，目标点u（或v）不能作为出口，但u，w共点是可行的
            printf("Yes
");
        else if(u==v)            
            printf("No
");
        else if(bccno[u]==bccno[v]&&bccno[u]==bccno[w])
            printf("Yes
");
        else if(bccno[u]==bccno[v])
            printf("No
");
        else if(bccno[u]==bccno[w]){
            int flog;
            int pp=lca(a,b);//!!注意：当两点缩点后重合，无法直接判定第三点在上方还是下方，需要利用lca
            if(pp==a){
                b=Double(b,c);//由b向c做倍增
                flog=judge(b,u);
            }else
                flog=judge(p[a][0],u);
            if(flog!=u)
                printf("Yes
");
            else
                printf("No
");
        }else if(bccno[v]==bccno[w]){
            int flog;
            int pp=lca(a,b);//!!同上
            if(pp==b){
                a=Double(a,c);//由a向c做倍增
                flog=judge(a,v);
            }else
                flog=judge(p[b][0],v);
            if(flog!=v)
                printf("Yes
");
            else
                printf("No
");
        }else {
            int p1,p2,p3;

            p1=lca(a,b);
            p2=lca(a,c);
            p3=lca(b,c);
            if(p1==p2&&p3==c){//判定点p是否能经过：求出两两lca
                int flog1,flog2;
                b=Double(b,c);
                flog1=judge(b,w);

                if(p1==c){//!!注意：当点p即为lca(u,v)时，p的另一个入口就不能从其父亲查找了，要在另一支路上做倍增
                    a=Double(a,c);
                    flog2=judge(a,w);
                }else
                    flog2=judge(p[c][0],w);

                if(flog1!=w&&flog2!=w&&flog1==flog2)
                    printf("No
");
                else
                    printf("Yes
");
            }
            else if(p1==p3&&p2==c){//这里上下两步其实是重复处理：p3==c表示p点在v支路上;反之在u支路上
                int flog1,flog2;
                a=Double(a,c);
                flog1=judge(a,w);

                if(p1==c){
                    b=Double(b,c);
                    flog2=judge(b,w);
                }else
                    flog2=judge(p[c][0],w);

                if(flog1!=w&&flog2!=w&&flog1==flog2)
                    printf("No
");
                else
                    printf("Yes
");
            }else
                printf("No
");
        }
    }
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        build(m);
        tarjin(n);
        rebuild(n);
        LCA(n);
        solve();
    }
    return 0;
}
/*
7 7
1 2
2 3
2 4
3 4
3 5
4 6
4 7
3
1 2 3
1 6 2
1 2 1
*/