P3884 [JLOI2009]二叉树问题

一这道题也很简单，核心是寻找两个点的最大深度公共祖先节点（也就是说距离两个点的最近的公共父节点）

想要求公共父节点就要用到一个算法：Tarjan离线算法

Tarjan是一人的人名，叫塔尔杨，是美国的计算机科学家~至今任活着

这个算法思路很简单，大致概括为这几句话

1.任选一个点为根节点，从根节点开始。
2.遍历该点u所有子节点v，并标记这些子节点v已被访问过。
3.若是v还有子节点，返回2，否则下一步。
4.合并v到u上。
5.寻找与当前点u有询问关系的点v。
6.若是v已经被访问过了，则可以确认u和v的最近公共祖先为v被合并到的父亲节点a。

Procedure dfs（u）；
    begin
        设置u号节点的祖先为u
        若u的左子树不为空，dfs（u - 左子树）；
        若u的右子树不为空，dfs（u - 右子树）；
        访问每一条与u相关的询问u、v
            -若v已经被访问过，则输出v当前的祖先t（t即u,v的LCA）
        标记u为已经访问，将所有u的孩子包括u本身的祖先改为u的父亲
    end

用一句话来概括就是：如果当前有孩子节点，就进行递归的调用，用后序遍历那样去遍历左右孩子，直到那个节点没有左右孩子，假设那个节点为i,然后将其标记flag[i]=false，那么我们就用并查集的思想：a[i]=parent, 也就是设置i的父亲节点为parent，然后再去寻找有没有和这个点i有关联的节点，如果有，假设那个节点是j，那么我们就判断一下flag[j]是否被访问，如果被访问，那么这两个节点的最近祖先结点就是find(j)，这个函数是并查集中寻找根节点的函数，找到以后就可以直接返回这个根节点了~

不理解的可以看看这个dalao的博客，很详细~

下面是AC代码

#include <iostream>
#include <cstring>
#include <queue>
#include <map>
#include <algorithm>
#define  Max 10000
using namespace std;
struct Node
{
    int left;
    int right;
    int par;//存储父亲节点
};
map<int ,Node> t;
bool flag[Max];
bool vis[Max];
int a[Max];
int res=0;//最终的结果
int root=0;//记录共同的根节点
void dfs(int n,int level,int y1,int y2);
int get_depth(int n);//深度
int get_width(int n);//宽度
void get_seemroot(int n,int y1,int y2) ;//寻找y1 y2的最近父亲节点
int find_par(int t1);//寻找父亲节点
    int main()
    {
        int n,x1,x2;
        cin>>n;
        memset(flag, false, sizeof(flag));
        memset(vis, false, sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            a[i]=i;//初始为每一个节点为自己的父亲节点
        }
        t[1].par=1;
        for(int i=1;i<=n-1;i++)
        {
            cin>>x1>>x2; //x1--->x2
            t[x2].par=x1;// x2的父亲节点设置为x1
            if(!flag[x1])
            {
                t[x1].left=x2;

                flag[x1]=true;
            }
            else if(flag[x1])
            {
                t[x1].right=x2;

            }
        }
        int y1,y2;
        cin>>y1>>y2;
        get_seemroot(1,y1,y2);//寻找y1 y2的最近父节点
        dfs(root,0,y1,y2);
        cout<<get_depth(1)<<endl;
        cout<<get_width(1)<<endl;
        cout<<res<<endl;
        return 0;
    }

    void dfs(int n,int level,int y1,int y2)//求节点之间的距离
    {
        if(n==0)
        {
            return ;
        }
        if(n==y1||n==y2)
        {
            if(y1==y2)
            {
                res+=level*2+level;
                return ;
            }
           else if(n==y1)
            {
                res+=level*2;
            }
            else
            {
                res+=level;
            }
        }
        dfs(t[n].left,level+1,y1,y2);
        dfs(t[n].right,level+1,y1,y2);
    }

    int get_depth(int n)
    {
        if(n==0)
        {
            return 0;
        }
        int left=get_depth(t[n].left);
        int right=get_depth(t[n].right);
        return max(left,right)+1;
    }

    int get_width(int n)
    {
        queue<int > que;
        que.push(n);
        int MAX=1;//宽度最小为1
        int num=que.size();
        while(num)
        {
            while(num--)
            {
                int f=que.front();
                que.pop();
                if(t[f].left!=0)
                {
                    que.push(t[f].left);
                }
                if(t[f].right!=0)
                {
                    que.push(t[f].right);
                }
            }
            num=que.size();
            MAX=max(MAX,num);
        }
        return MAX;
    }


    //寻找公共节点
    void get_seemroot(int n,int y1,int y2) //寻找y1 y2的最近父亲节点
    {
        if(n==0)
        {
            return ;
        }
        get_seemroot(t[n].left,y1,y2);
        get_seemroot(t[n].right,y1,y2);
        //没有可以访问的根节点了
        vis[n]=true;//标记已访问
        a[n]=t[n].par;//指向其父亲节点
        if(y1==n&&vis[y2]||y2==n&&vis[y1])//寻找和n有关系的节点
        {
            if(y1==n&&vis[y2])
            {
                root=find_par(y2);
            } else
            {
                root=find_par(y1);
            }
            return ;
        }
    }


    int find_par(int t1)// 并查集返回其根节点
    {
        while(t1!=a[t1])
        {
            t1=a[t1];
        }
        return t1;
    }