天天写算法之离线Tarjan算法Closest Common Ancestors

题目地址： 点击打开链接

这些延伸的题目都是我在做hdu的时候由于原题比较难，所以才会找更加基础的来做。

对于ACM小白来说，基本上是每隔4道题就必然有一个新的题型。今天就是离线Tarjan算法。emmm

LCA我还没完全写对。

这有一个教程。 点击打开链接

我要对这个教程里没有阐述的东西进行一下深剖。

比如       5

    4       3        2 

1    6

这个地方是4 3 2 是5的儿子，1 6 是4的儿子

这里用到了并查集，首先我们起初的时候要把所有的pre【i】=i，就是所有节点的祖先节点都是本身。这一点很重要，不单单是并查集的应用那么简单。

上代码：

void dfs(int u)
{
   for（int i = 1; i <= n; i++)
   {
      if(visit[i]&&ask[u][i])
      {
        LCA[u][i] = Find(i);
      }
   }
   visit[u] = true;
   for(int i = 0; i < g[u].size(); i++)
   {
     int son = g[u][i];
     dfs(son);
     father[son] = u;
   }
}

visit表示是否被访问了。ask表示询问的节点结果，比如我问你1和6的最近祖先是什么。

g是一个vector的数组，存储的是g[i]存储的是i这个节点所有的儿子。

首先再赋值的时候也就是ask的时候我们要ask[i][u]和ask[u][i]都要标记上，因为假如你第一遍走到ask[i][u]发现i没有访问过，那么问题就来了，这个ask就再也不会被访问了，所以需要另一个等到访问到i的时候就会发现u被访问了，就能输出结果了。

另一个点，就是在执行  dfs(son)之后，才会把这些孩子的父亲设置为离他最近的父亲，要知道在这之前他们所有节点的父亲都是他自己。

比如问我1 6 的祖先，此时已经找到了6，这个时候1已经访问过了，访问过了代表什么呢，代表他的father被设置成了4，此时还没访问完4的所有儿子，说明还没有dfs（4）还没有完成，那么father（4）也就还是等于4.所以能输出正确结果，他是依靠这个特性保持最近父节点的。

加入我们再找1 3 的dfs（4）已经回来了，说明了什么？说明father（4）已经被设置成了5，此时find（4）就等于了5.

代码来一波：

#include<stdio.h>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 1000;
int ask[maxn][maxn];//保存询问
int ans[maxn];//保存祖先i出现过的次数
int n,m;
vector<int> g[maxn];//保存儿子
int root;//树的根
bool visit[maxn];
bool isroot[maxn];
int father[maxn];
int Find(int x)
{
    if(father[x] == x) return x;
    else return father[x] = Find(father[x]);
}
void init()
{
    memset(ans,0,sizeof(ans));
    memset(visit,false,sizeof(visit));
    memset(isroot,true,sizeof(isroot));
    memset(ask,0,sizeof(ask));
    for(int i = 1; i <= n; i++)
    {
        g[i].clear();
        father[i] = i;
    }

}
void LCA(int root)
{
    for(int i = 1; i <= n; i++)
    {
        if(visit[i]&&ask[root][i])
        {
            ans[Find(i)] += ask[root][i];
        }
    }
    visit[root] = true;
    for(int i = 0; i < g[root].size(); i++)
    {
        int term = g[root][i];
        LCA(term);
        father[term] = root;
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        int f,s,num;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d:(%d)",&f,&num);
            for(int j = 1; j <= num; j++)
            {
                scanf(" %d",&s);
                isroot[s] = false;
                g[f].push_back(s);
            }
        }
        for(int i = 1; i <= n; i++)
        {
            if(isroot[i])
            {
                root = i;
                break;
            }
        }
        scanf("%d",&m);
        int u,v;
        for(int i = 1; i <= m; i++)
        {
            scanf(" (%d %d)",&u,&v);
            ask[u][v]++;
            ask[v][u]++;
        }
        LCA(root);
        for(int i = 1; i <= n; i++)
        {
            if(ans[i])
            {
                printf("%d:%d\n",i,ans[i]);
            }
        }
    }
    return 0;
}