树的直径+LCA （最近公共祖先）学习记录

双DFS :首先以任意点x为根进行一次dfs，找出距离x距离最大的点pos。

再以pos为根进行一次dfs，距离pos最远的距离即为树的直径。

这个这样理解比较容易，一次DFS找到距离选中点最远的一个点，那么我两次DFS呢？就是第一次找到了一个端点，那么下一次DFS找到就是另一个。所以这两个点的距离就是树的直径。下面是代码。

vector<pair<int, ll> > rod[N];
ll d[N];
int pos;
void dfs(int u, int f,int lth)
{
d[u]=d[f]+lth;
if(d[u]>d[pos])pos=u;
for (int i = 0; i < rod[u].size(); i++)
{
if (rod[u][i].first == f)
continue;
dfs(rod[u][i].first, u,rod[u][i].second);
}
}
ll tree_r(int n)
{
for(int i=1;i<=n;i++)d[i]=0;
pos=0;
dfs(1,1,0);
for(int i=1;i<=n;i++)d[i]=0;
dfs(pos,pos,0);
return d[pos];
}

树状DP：

定义 d1[u] 表示 u 到达子树中叶子节点的最长链，d2[u] 表示 u 到达子树中叶子节点的次长 链，并且两条链不能有交集；

 在具体操作中，只要保证 d1[u] 与 d2[u] 不被 u 的同一个子节点更新，即可保证 d1 与 d2 无 公共部分；

vector<pair<int, ll> > rod[100005];//存图
ll d1[100005], d2[100005];
void dfs(int u, int f)
{
for (int i = 0; i < rod[u].size(); i++)
{
if (rod[u][i].first == f)
continue;
dfs(rod[u][i].first, u);
if (d1[rod[u][i].first] + rod[u][i].second > d1[u])
d2[u] = d1[u], d1[u] = d1[rod[u][i].first] + rod[u]
[i].second;
else if(d1[rod[u][i].first] + rod[u][i].second > d2[u])
d2[u]=d1[rod[u][i].first] + rod[u][i].second;
}
}
ll tree_r(int n)//传入总点数
{
for(int i=1;i<=n;i++)d1[i]=d2[i]=0;
ll ans=0;
dfs(1,1);
for(int i=1;i<=n;i++)
{
ans=max(ans,d1[i]+d2[i]);
}
return ans;
}

二、最近公共祖先：

倍增 首先考虑两个深度一样的点，对于两个深度相同的点 x，y ， 他们到LCA的深度差是相同 的，那么我们可以采取x,y同时向上移动，直到移动到相同的节点。

如果线性地向上跳，时间复杂度不是很让人满意，由于祖先存在二段性，我们可以通过这个 性质进行倍增，找到最远的不同祖先，再找到那个祖先的父节点。

如果两个结点深度不同，我们可以将较深结点向上回溯至与另一节点深度相同，再进行上 移；

对于倍增的具体过程如下： 定义fa[u][j] 为 u 结点的 2的j次方级祖先，有递推式                          fa[i][j]=fa[fa[i][j-1][j-1]]；

对于两个同级结点，其 LCA 及更高层的祖先均相同，我们可以按照这个二段性进行倍增； j 从大到小遍历.下面是代码：

int fa[N + 1][M + 1], dep[N + 1];
vector<int> rod[N + 1];
int LCA(int x, int y, int s)
{
if (dep[x] < dep[y])
swap(x, y);
while (dep[x] > dep[y])
x = fa[x][(int)log2(dep[x] - dep[y])];
if (x == y)
return y;
for (int i = M; i >= 0; i--)
{
if (fa[x][i] != fa[y][i])
{
x = fa[x][i], y = fa[y][i];
}
}
return fa[x][0];
}
void dfs(int u, int f)
{
fa[u][0] = f;
dep[u] = dep[f] + 1;
for (auto v : rod[u])
{
if (v != f)
dfs(v, u);
}
}
void lca_init(int s, int n)
{
dfs(s, 0);//处理出fa[u][0]
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++)
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}