[ SHOI 2012 ] 随机树

本文探讨了通过随机选择叶子节点并添加子节点的方式生成树的过程。主要关注两个期望值的计算:所有叶节点平均高度的期望和树高的期望。通过对概率和期望的巧妙转化,提出了解决方案,并详细解释了递推公式和概率计算的方法。

\(\\\)

\(Description\)


开始有一棵只有一个根节点的树。每次随机选择一个叶子节点,为他添上左右子节点,求:

  • 生成一棵有\(N\)个叶节点的树,所有叶节点平均高度的期望。
  • 生成一棵有\(N\)个叶节点的树,树高的期望。

约定根节点深度为\(0\)

  • \(N\in [1,100]\)

\(\\\)

\(Solution\)


果然还是太菜了只会抄题解 一道期望和概率间巧妙转化的好题。

\(\\\)

第一问,平均的性质。

考虑每次扩展会随机选择一个叶节点,假设该叶节点的深度为\(d_i\),对总叶节点深度和的贡献为\((d_i+1)\times 2-d_i=d_i+2\)

等概率的选择,对深度的平均值增量之和\(=\frac{\sum_{v\in Leaf}d_v+2}{|Leaf|}=2+\frac{\sum_{v\in Leaf}d_v}{|Leaf|}=2+ave\)。所以一次扩展节点对期望的增量是\(\frac{ave+2}{|Leaf|}\)

\(g[i]\)表示\(i\)个叶节点的深度平均值的期望,有

\[ g[0]=0.0\ ,\ g[i]=\frac{g[i-1]+2}{i}+\frac{g[i-1]\times(i-1)}{i}=g[i-1]+\frac{2}{i} \]

愉快的递推就好。

\(\\\)

第二问,一种期望向概率的转化。

先考虑一种期望的表示方式。

\[ E(X)=\sum_{i=1}^\infty i\times p_i=\sum_{i=1}^\infty\sum_{j=1}^i p_i=\sum_{i=1}^\infty \sum_{j=i}^\infty p_j \]
关于证明,第一个等号显然成立。

第二个等号可以理解为,每个概率会被累加权值那么多次。

第三个等号可以理解为,越大的权值对应的概率被累加的越多,当可取的权值\(+1\)时,对应的所有小于它的数字都会累加上一份最大权的概率,但是小于最大权的数字个数为最大权\(-1\),所以还需要累加上一份。

于是设\(f_i\)表示大于等于\(i\)的概率,进一步转化有
\[ E(X)=\sum_{i=1}^\infty f_i \]
思考如何用这个性质求解树高期望。

将状态定义为一种基于最小值的设计方式。设\(f[i][j]\)表示,有\(i\)个叶节点的树,树高\(\ge j\)的期望,答案有
\[ E(树高)=\sum_{i=0}^{N-1} f[N][i] \]
原理和上面是一样的。

考虑如何求\(f\)数组。有边界\(f[i][0]=1.0\ \big |\ i\in [1,N]\),因为任意时刻树高都会\(\ge 0\)

然后将任务下放到子树,左右子树的大小分布是等概率的,注意只要不是叶节点就一定左右子树都有。

所以只要有一棵深度合法就好,注意容斥掉两种情况重合时的部分。
\[ f[i][j]=\frac{1}{i-1}\sum_{k=1}^{i-1}\ \big(\ f[k][j-1]+f[i-k][j-1]-f[k][j-1]\times f[i-k][j-1]\ \big) \]
好像漏掉了关于前面系数为什么是\(\frac{1}{i-1}\)的问题,发现问题被巨佬diss之后又上了一波百度,发现没有...

问了学长,证明大概是,考虑用\(1\)表示扩展了一个左子树内节点,用\(0\)表示扩展了一个右子树内的节点,那么生成一个\(01\)序列的概率就可以表示成,\(\frac{1}{2}\times\frac{2(1)}{3}\times\frac{3(2)(1)}{4}\times...\),分子部分表示选择一个左子树\(/\)右子树节点的概率。

比如生成树序列\(00111\),概率可以表示成\(\frac{1}{2}\times\frac{2}{3}\times\frac{1}{4}\times\frac{2}{5}\times\frac{3}{6}\),注意到交换\(01\)位置得到的式子的值不变。

为什么呢?因为分母部分一定是\((i+1)!\),而分子部分一定是\(k!\times (i-k)!\),表示两棵子树的生成过程。

于是一个左子树大小为\(k\),右子树大小为\(n-k\)的树生成的概率就是\(\frac{k!\times(i-k)!}{(i+1)!}=\frac{1}{i+1}\),与\(k\)无关。

\(\\\)

\(Code\)


#include<cmath>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 110
#define R register
using namespace std;

int n,q;
double g[N],f[N][N];

int main(){
  scanf("%d%d",&q,&n);
  if(q==1){
    g[1]=0.0;
    for(R int i=2;i<=n;++i) g[i]=g[i-1]+2.0/i;
    printf("%.6lf",g[n]);
  }
  else{
    for(R int i=1;i<=n;++i) f[i][0]=1.0;
    for(R int i=2;i<=n;++i)
      for(R int j=1;j<i;++j){
        for(R int k=1;k<i;++k)
          f[i][j]+=f[k][j-1]+f[i-k][j-1]-f[k][j-1]*f[i-k][j-1];
        f[i][j]/=(i-1);
      }
    double ans=0.0;
    for(R int i=1;i<=n;++i) ans+=f[n][i];
    printf("%.6lf\n",ans);
  }
  return 0;
}

转载于:https://www.cnblogs.com/SGCollin/p/9715829.html

<think>首先,用户要用中文回答问题,所以我必须使用中文。用户的问题是关于“[SHOI2012] 魔法树”的树链剖分详解。 我需要回忆“[SHOI2012] 魔法树”这个题目。这是一个经典的树链剖分问题,涉及路径修改和子树查询。 题目大意:给定一棵树,每个节点有初始值。支持两种操作: 1. 路径加:给从u到v的路径上所有节点加上一个值。 2. 子树查询:查询以u为根的子树中所有节点的值的和。 树链剖分(Heavy-Light Decomposition, HLD)是解决这类问题的有效方法。它将树分解成链,便于用线段树或其他数据结构维护。 树链剖分的关键步骤: - 第一次DFS:计算每个节点的子树大小(size),父节点(parent),深度(depth),重儿子(heavy son)。 - 第二次DFS:分配链顶(top)和DFS序(dfn)。重儿子优先遍历,形成重链。 在树链剖分中,每个节点得到一个DFS序,重链上的节点连续。这样,路径可以被分解成O(log n)条链,每条链在DFS序上是连续的区间。 对于路径加操作: - 从u和v开始,向上跳链,直到它们在同一个链上。每次跳链时,修改当前链上的区间(从当前节点到链顶)。 - 具体地,如果u和v的链顶不同,选择链顶深度较大的节点,修改从该节点到链顶的区间,然后跳到链顶的父节点。 - 当u和v在同一条链上时,修改它们之间的区间。 对于子树查询: - 由于子树在DFS序中是连续的区间(从dfn[u]到dfn[u] + size[u] - 1),所以可以直接查询这个区间。 实现时,通常用一个线段树来维护DFS序上的区间和、区间加。 现在,我需要详细解释树链剖分在本题中的应用。 回答结构: 1. 介绍树链剖分的基本概念。 2. 描述如何应用于“[SHOI2012] 魔法树”。 3. 给出代码框架(伪代码或简化代码)。 4. 最后,提出3-5个相关问题。 用户指定了格式:回答后必须输出“§§相关问题§§”,然后列出问题。第一行必须是“§§相关问题§§”,禁止换行分散。 在示例中,代码是用markdown代码块表示的,所以我应该用类似方式。 完整回答: - 先详细解释树链剖分。 - 然后针对题目给出具体实现。 - 最后输出相关问题。 相关问题应该基于用户的问题和我的回答。可能的主题: 1. 树链剖分的其他应用。 2. 优化或变体。 3. 复杂度分析。 4. 相关题目。 列出3-5个: 1. 树链剖分的时间复杂度是多少? 2. 如何处理子树修改和路径查询? 3. 树链剖分与倍增LCA的区别是什么? 4. 是否有其他树分解方法? 5. 在本题中,如果支持路径查询和子树加,如何修改? 确保问题相关。 现在,写回答。</think>### 树链剖分详解 [SHOI2012] 魔法树 [SHOI2012] 魔法树是一个经典的树链剖分(Heavy-Light Decomposition, HLD)问题。给定一棵 \(n\) 个节点的树,每个节点初始值为 0,支持两种操作: 1. **路径加**:给节点 \(u\) 到 \(v\) 的路径上所有节点增加一个值 \(d\)。 2. **子树查询**:查询以节点 \(u\) 为根的子树中所有节点值的和。 树链剖分通过将树分解为若干条链(重链),并映射到线性序列(DFS 序),从而用线段树高效处理路径和子树操作。以下是详细步骤: #### 1. **树链剖分预处理** - **第一次 DFS**:计算每个节点的父节点(`fa`)、深度(`dep`)、子树大小(`siz`)和重儿子(`son`)。 - 重儿子:子树大小最大的儿子节点。 - **第二次 DFS**:分配 DFS 序(`dfn`)和链顶(`top`)。 - 优先遍历重儿子,形成重链;轻儿子作为新链的起点。 - 记录 DFS 序范围:节点 \(u\) 的子树对应区间 \([dfn[u], dfn[u] + siz[u] - 1]\)。 #### 2. **操作实现** - **路径加操作 `AddPath(u, v, d)`**: - 当 \(u\) 和 \(v\) 不在同一条链上时,将深度较大的节点向上跳至链顶,并修改该链的区间(对应线段树区间加)。 - 当 \(u\) 和 \(v\) 在同一条链上时,直接修改它们之间的区间。 - 时间复杂度:\(O(\log^2 n)\)(每条链跳 \(O(\log n)\) 次,线段树操作 \(O(\log n)\))。 - **子树查询操作 `QuerySubtree(u)`**: - 子树在 DFS 序中是连续区间 \([dfn[u], dfn[u] + siz[u] - 1]\)。 - 直接线段树区间查询。 - 时间复杂度:\(O(\log n)\)。 #### 3. **线段树维护** - 基于 DFS 序建线段树,支持区间加和区间查询。 - 每个节点存储区间和(`sum`)和懒标记(`lazy`)。 #### 代码框架(Python 伪代码) ```python class HLD: def __init__(self, n, graph): self.n = n self.graph = graph self.fa = [-1] * (n+1) # 父节点 self.dep = [0] * (n+1) # 深度 self.siz = [0] * (n+1) # 子树大小 self.son = [-1] * (n+1) # 重儿子 self.top = [-1] * (n+1) # 链顶 self.dfn = [0] * (n+1) # DFS序 self.cnt = 0 # DFS计数器 self.dfs1(1, 0) # 第一次DFS self.dfs2(1, 1) # 第二次DFS self.seg_tree = SegmentTree(n) # 线段树(区间加、区间和) def dfs1(self, u, father): # 计算siz, dep, fa, son self.fa[u] = father self.dep[u] = self.dep[father] + 1 self.siz[u] = 1 max_size = -1 for v in self.graph[u]: if v == father: continue self.dfs1(v, u) self.siz[u] += self.siz[v] if self.siz[v] > max_size: max_size = self.siz[v] self.son[u] = v def dfs2(self, u, top_fa): # 分配dfn和top self.top[u] = top_fa self.dfn[u] = self.cnt self.cnt += 1 if self.son[u] == -1: return self.dfs2(self.son[u], top_fa) # 优先重儿子 for v in self.graph[u]: if v == self.fa[u] or v == self.son[u]: continue self.dfs2(v, v) # 轻儿子作为新链顶 def AddPath(self, u, v, d): # 路径加 while self.top[u] != self.top[v]: if self.dep[self.top[u]] < self.dep[self.top[v]]: u, v = v, u # 修改u到其链顶的区间 l, r = self.dfn[self.top[u]], self.dfn[u] self.seg_tree.update(l, r, d) u = self.fa[self.top[u]] if self.dep[u] > self.dep[v]: u, v = v, u l, r = self.dfn[u], self.dfn[v] self.seg_tree.update(l, r, d) # 修改最后一条链上的区间 def QuerySubtree(self, u): # 子树查询 l, r = self.dfn[u], self.dfn[u] + self.siz[u] - 1 return self.seg_tree.query(l, r) class SegmentTree: # 线段树(简化版) def __init__(self, n): self.n = n self.sum = [0] * (4 * n) self.lazy = [0] * (4 * n) def push_down(self, o, l, r): if self.lazy[o]: mid = (l + r) // 2 self.lazy[o*2] += self.lazy[o] self.lazy[o*2+1] += self.lazy[o] self.sum[o*2] += self.lazy[o] * (mid - l + 1) self.sum[o*2+1] += self.lazy[o] * (r - mid) self.lazy[o] = 0 def update(self, o, l, r, ql, qr, d): # 区间加 if ql <= l and r <= qr: self.sum[o] += d * (r - l + 1) self.lazy[o] += d return self.push_down(o, l, r) mid = (l + r) // 2 if ql <= mid: self.update(o*2, l, mid, ql, qr, d) if qr > mid: self.update(o*2+1, mid+1, r, ql, qr, d) self.sum[o] = self.sum[o*2] + self.sum[o*2+1] def query(self, o, l, r, ql, qr): # 区间查询 if ql <= l and r <= qr: return self.sum[o] self.push_down(o, l, r) mid = (l + r) // 2 res = 0 if ql <= mid: res += self.query(o*2, l, mid, ql, qr) if qr > mid: res += self.query(o*2+1, mid+1, r, ql, qr) return res # 主程序示例 if __name__ == "__main__": n = int(input()) # 节点数 graph = [[] for _ in range(n+1)] for _ in range(n-1): # 建树 u, v = map(int, input().split()) graph[u].append(v) graph[v].append(u) hld = HLD(n, graph) # 处理操作:例如 hld.AddPath(u, v, d) 或 hld.QuerySubtree(u) ``` #### 复杂度分析 - 预处理:两次 DFS,\(O(n)\)。 - 路径加:\(O(\log^2 n)\)(树链剖分分解为 \(O(\log n)\) 条链,每条链线段树操作 \(O(\log n)\))。 - 子树查询:\(O(\log n)\)(线段树区间查询)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值