lca

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 30010
#define S 16

using namespace std;
int n,m,num,head[maxn],fa[maxn][S+5],deep[maxn],p1,p2,ans;
struct node{
    int from;
    int to;
    int next;
}e[maxn*2];

void add(int from,int to)
{
    e[++num].from=from;
    e[num].to=to;
    e[num].next=head[from];
    head[from]=num;
}

void swap(int &a,int &b)
{
    int t=a;a=b;b=t;
}

void init()
{
    scanf("%d",&n);
    int x,y;
    for(int i=1;i<=n-1;i++)
      {
          scanf("%d%d",&x,&y);
          add(x,y);add(y,x);
      }
}
void get_fa()
{
    for(int j=1;j<=S;j++)
      for(int i=1;i<=n;i++)
        fa[i][j]=fa[fa[i][j-1]][j-1];
}

void Dfs(int now,int from,int c)//每个点所在层数 
{
    fa[now][0]=from;
    deep[now]=c;
    for(int i=head[now];i;i=e[i].next)
     {
         int v=e[i].to;
         if(v!=from)
           Dfs(v,now,c+1);
     }
}

int get_same(int a,int t)
{
    for(int i=0;i<16;i++)
     if(t&(1<<i)) a=fa[a][i];
    return a;
}

int LCA(int a,int b)
{
    if(deep[a]<deep[b]) swap(a,b);//保证a深度大 
    a=get_same(a,deep[a]-deep[b]);//得到a向上deep[a]-deep[b]层是谁 即a的与b同层的祖先是谁
    if(a==b) return a;//如果汇聚到一个点 就不用往上了
    for(int i=S;i>=0;i--)//从最大值开始循环 一开始 fa[a][i]  fa[b][i]一定是相等的
                       //因为此时位于他们lca之上 然后往下 这里可以覆盖每一层 
    {
        if(fa[a][i]!=fa[b][i])
                {
                    a=fa[a][i];
                    b=fa[b][i];
              }
    }
        return fa[a][0];
}

int main()
{
    init();
    Dfs(1,1,0);
    get_fa();
    scanf("%d%d",&m,&p1);
    for(int i=1;i<=m-1;i++)
      {
          scanf("%d",&p2);
          int anc=LCA(p1,p2);
          ans+=deep[p1]+deep[p2]-2*deep[anc];
          p1=p2;
      }
    printf("%d\n",ans);
    return 0;
}

 

 

// LCA
const int maxn = 100003;
const int maxl = 19;

struct Edge {
    int t;
    Edge *ne;
};

int dep[maxn], up[maxn][maxl];

void DFS(int u) {
    for (int i = 1; i < maxl; ++ i) {
        up[u][i] = up[up[u][i - 1]][i - 1];
    }
    for (Edge* e = head[u]; e; e = e->ne) { // 枚举儿子
        if (!dep[e->t]) {
            dep[e->t] = dep[u] + 1;
            up[e->t][0] = u;
            DFS(e->t);
        }
    }
}

int LCA(int u, int v) {
    if (dep[u] < dep[v]) {
        swap(u, v);
    }
    for (int i = maxl - 1; i >= 0; -- i) {
        if (dep[up[u][i]] >= dep[v]) {
            u = up[u][i];
        }
    }
    if (u == v) {
        return u;
    }
    for (int i = maxl - 1; i >= 0; -- i) {
        if (up[u][i] != up[v][i]) {
            u = up[u][i];
            v = up[v][i];
        }
    }
    return up[u][0];
}

int main() {
    memset(dep, -1, sizeof(dep));
    dep[1] = 0;
    up[1][0] = 0;
    DFS(1);
    while (q --) {
        int u, v;
        cin >> u >> v;
        cout << LCA(u, v) << endl;
    }
}