POJ 1986 DIstance Query LCA水题

给出一棵树，对于每一个询问，给出2个节点，输出2个节点的距离。

输入中有字母，那个是没有用的，不用管。

思路：

0.选择编号为1的节点作为树的root

（注意：有些题的边是单向的，这时候我们要根据节点的入度来确定root，

　　　　双向的话一般可以随意选择一个节点作为root）

1.dfs1，求出dep和pa[i][0]

2.初始化数组pa

3.节点（u，v）的权值为w

　把本来是边的权值w赋给u，v中dep较大的节点，

　cost[i]表示节点i的权值为cost[i]

　先初始化：cost[root]=0

4.dfs2,求每一个节点到root的距离dis[i]

5.查询：dis(u,v)=dis[u]+dis[v]-2*dis[lca(u,v)];

 #include<cstdio>
 #include<cstring>

 using namespace std;

 const int maxn=+;
 const int inf=0x3f3f3f3f;

 inline int swap(int &x,int &y)
 {
     x^=y;
     y^=x;
     x^=y;
 }

 struct Edge
 {
     int to,next;
 };
 Edge edge[maxn<<];
 int head[maxn];
 int tot=;
 int cost[maxn];
 int dis[maxn];
 int pa[maxn][];
 int dep[maxn];
 int e[maxn][];

 void init()
 {
     memset(head,-,sizeof head);
     tot=;
     memset(dep,,sizeof dep);
     memset(pa,-,sizeof pa);
 }

 void addedge(int u,int v)
 {
     edge[tot].to=v;
     edge[tot].next=head[u];
     head[u]=tot++;
 }

 void dfs1(int u)
 {
     for(int i=head[u];~i;i=edge[i].next)
     {
         int v=edge[i].to;
         if(!dep[v])
         {
             dep[v]=dep[u]+;
             pa[v][]=u;
             dfs1(v);
         }
     }
 }

 void init_pa(int n)
 {
     for(int j=;(<<j)<=n;j++)
     {
         for(int i=;i<=n;i++)
         {
             if(pa[i][j-]!=-)
                 pa[i][j]=pa[pa[i][j-]][j-];
         }
     }
 }

 void dfs2(int u,int pre)
 {
     for(int i=head[u];~i;i=edge[i].next)
     {
         int v=edge[i].to;
         if(v==pre)
             continue;
         dis[v]=dis[u]+cost[v];
         dfs2(v,u);
     }
 }

 int query(int a,int b,int n)
 {
     int init_a=a;
     int init_b=b;
     if(dep[a]<dep[b])
         swap(a,b);
     int cnt;
     for(cnt=;dep[a]-(<<cnt)>=;cnt++)
         ;
     cnt--;
     for(int j=cnt;j>=;j--)
     {
         if(dep[a]-(<<j)>=dep[b])
             a=pa[a][j];
     }
     if(a==b)
         return dis[init_a]+dis[init_b]-*dis[a];
     for(int i=cnt;i>=;i--)
     {
         if(pa[a][i]!=-&&pa[a][i]!=pa[b][i])
         {
             a=pa[a][i];
             b=pa[b][i];
         }
     }
     return dis[init_a]+dis[init_b]-*dis[pa[a][]];
 }

 void solve(int n)
 {
     dep[]=;
     dfs1();
     init_pa(n);
     cost[]=;
     dis[]=;
     for(int i=;i<=n;i++)
     {
         if(dep[e[i][]]>dep[e[i][]])
             swap(e[i][],e[i][]);
         cost[e[i][]]=e[i][];
     }
     dfs2(,-);

     int m;
     scanf("%d",&m);
     for(int i=;i<=m;i++)
     {
         int u,v;
         scanf("%d%d",&u,&v);
         printf("%d\n",query(u,v,n));
     }
     return ;
 }

 int main()
 {
     int n;
     while(~scanf("%d",&n))
     {
         init();
         int m;
         scanf("%d",&m);
         for(int i=;i<=m;i++)
         {
             int u,v,w;
             char ch;
             scanf("%d %d %d %c",&e[i][],&e[i][],&e[i][],&ch);
             addedge(e[i][],e[i][]);
             addedge(e[i][],e[i][]);
         }
         solve(n);
     }
     return ;
 }