题目
如下图所示的一棵二叉树的深度、宽度及结点间距离分别为：
- 深度：44
- 宽度：44
- 结点 8 和 6 之间的距离：88
- 结点 7 和 6 之间的距离：33
其中宽度表示二叉树上同一层最多的结点个数，节点 u, vu,v 之间的距离表示从 uu 到 vv 的最短有向路径上向根节点的边数的两倍加上向叶节点的边数。
给定一颗以 1 号结点为根的二叉树，请求出其深度、宽度和两个指定节点 x, yx,y 之间的距离。
解答
这一道题分为三个问题，第一个问题是求深度，第二个问题是求最大宽度，第三个问题是求a->b的带权路径长度，这里的权指的是如果是向着跟走的路径权值是2，远离根的路径权值是1，例如8->6，那么8->1的路径是要*2,1->6是不需要的，所以是3*2+2=8，样例也就是这样来的。
对于第一个问题求深度，这个只要走一遍dfs就可以求出答案。
对于第二个问题求宽度，只需要算出每一个点的深度，然后统计每个深度的个数，找最大就可以得出，因为深度不会很深，所以造的桶也不会太多。
主要是第三个问题。第三个问题需要算出路径，考虑使用LCA+倍增算法来求解。
LCA也就是最近公共祖先，有了根节点才可以计算路径权值的分界点和长度。计算LCA的方法有多种，暴力的方法就是直接先统一到同一深度，然后两个同时向上找，直到相遇就算找到，这里的数据量比较小大约是可以通过的，但是一旦数据量变大就难以满足，因此不能一个一个跳，那么就以2的幂次的长度来跳，因为任何整数可以表示成2的幂次的和，因此先大步跳然后减小步幅是可以到达任何深度的。
首先先进行预处理，引入f [i] [j] 表示编号为i的点向上跳2^j到达的点，那么f[i][j]=f[ f[i][j-1] ][j-1],这一步可以这样理解：编号为i的点向上跳2^j等同于先跳2^(j-1)到达f[i][j-1]然后再由f[i][j-1]跳2^(j-1)，利用这样的一个递推式，跑一遍dfs就可以预处理出所有点向上跳2的幂次到达的点。
void dfs(int to, int from)//to为当前节点,from为父节点
{
dep[to] = dep[from] + 1;//每个点的深度，也可以进行预处理
f[to][0] = from;
for (int i = 1; i <= lg[dep[to]]; i++)
f[to][i] = f[f[to][i - 1]][i - 1];
for (int i = last[to]; i; i = e[i].next)
if (e[i].to != from)
dfs(e[i].to, to);
}然后接下来进行LCA相关的计算。一般如果没有方向的话，传入参数有两个x,y，分别代表了要计算的起点和终点。大致步骤有两步，第一步是先把两个深度统一，第二步两个点同时向上跳，枚举2的幂次从最大到最后0次，也就是从跳很多步到最后跳一步，因为两个点是一定有公共祖先的，如果跳的很大那么可能一下子找到了非常靠上的祖先，它虽然是公共祖先但却不是最近公共祖先，因此我们要保证跳了之后两个点不会位于同一点（因为位于同一点就代表位于某一层公共祖先了，但是我们无法确定这是否是最近公共祖先），不断缩小步幅，一直到最后两者一定是位于最近公共祖先的左右节点，因为只有这样才能满足最后跳一步都不满足两者位于同一点，而最近公共节点就是两个点的父节点。
当然这道题因为有权值，所以求解过程略有改变，首先是统一深度，因为是x->y，所以x到跟是向根，路径权值为2，根到y是原远离，所以分情况讨论，如果是x深度大，那么在提升的过程中，结果要加上路程*2。然后最后找出共公共祖先，计算公祖祖先深度和统一深度的差值，那么路径长度就知道了，因为长两边是一样的，无非就是一边权值是2，那么结果加上一边路径长度乘3就好了。
int cal(int x, int y)
{
int ans = 0;
if (dep[x] < dep[y])//y先向上走
{
int tmp = dep[y];
while(dep[x]<dep[y])
{
y = f[y][lg[dep[y] - dep[x]] - 1];
}
ans += tmp - dep[y];
}
else//x向上走,这是朝着根的方向
{
int tmp = dep[x];
while (dep[x] > dep[y])
{
x = f[x][lg[dep[x] - dep[y]] - 1];
}
//printf("tmp=%d,dep[x]=%d\n", tmp,dep[x]);
ans += 2 * (tmp - dep[x]);
}
//printf("ans=%d\n", ans);
//接下来找到公共祖先
if (x == y)return ans;//已经找到了
int tmp = dep[x];//存储当前的深度，后面方便计算路径长度
for (int i = lg[dep[x]] - 1;i>=0; i--)
{
if (f[x][i] != f[y][i])
{
x = f[x][i];
y = f[y][i];
}
}
//printf("x=%d\n", x);
//最后的父节点是直接父节点
ans += (tmp - dep[f[x][0]]) * 3;
return ans;
}完整代码
#include<stdio.h>
#include<algorithm>
using namespace std;
#define Max 1000
struct Edge
{
int to, next;
}e[Max];
int last[Max], cnt;
int lg[Max], dep[Max],f[Max][20], deps[20],maxDep;
void add(int from, int to)
{
e[++cnt].to = to;
e[cnt].next = last[from];
last[from] = cnt;
}
void dfs(int to, int from)
{
dep[to] = dep[from] + 1;
deps[dep[to]]++;//统计每一层的个数
maxDep = max(maxDep, dep[to]);
f[to][0] = from;
for (int i = 1; i <= lg[dep[to]]; i++)
f[to][i] = f[f[to][i - 1]][i - 1];
for (int i = last[to]; i; i = e[i].next)
{
//printf("%d %d\n", e[i].next,e[i].to);
if (e[i].to != from)
{
dfs(e[i].to, to);
}
}
}
int cal(int x, int y)
{
int ans = 0;
if (dep[x] < dep[y])//y先向上走
{
int tmp = dep[y];
while(dep[x]<dep[y])
{
y = f[y][lg[dep[y] - dep[x]] - 1];
}
ans += tmp - dep[y];
}
else//x向上走,这是朝着根的方向
{
int tmp = dep[x];
while (dep[x] > dep[y])
{
x = f[x][lg[dep[x] - dep[y]] - 1];
}
//printf("tmp=%d,dep[x]=%d\n", tmp,dep[x]);
ans += 2 * (tmp - dep[x]);
}
//printf("ans=%d\n", ans);
//接下来找到公共祖先
if (x == y)return ans;//已经找到了
int tmp = dep[x];//存储当前的深度，后面方便计算路径长度
for (int i = lg[dep[x]] - 1;i>=0; i--)
{
if (f[x][i] != f[y][i])
{
x = f[x][i];
y = f[y][i];
}
}
//printf("x=%d\n", x);
//最后的父节点是直接父节点
ans += (tmp - dep[f[x][0]]) * 3;
return ans;
}
int n;
int main()
{
scanf("%d", &n);
int x, y;
for (int i = 1; i <= n - 1; i++)
{
scanf("%d%d", &x, &y);
//printf("%d -- %d\n", x, y);
add(x, y);
//printf("%d\n", e[2].to);
//add(y, x);
}
for (int i = 1; i <= n; i++)
lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dfs(1, 0);//预处理树上倍增
int width = 0;
for (int i = 1; i <= maxDep; i++)
{
width = max(width, deps[i]);
}
scanf("%d%d", &x, &y);
//计算路径
int len = cal(x, y);//计算x->y的宽度
printf("%d\n%d\n%d\n", maxDep, width, len);
return 0;
}
