WikiOI 2370 小机房的树 (最裸LCA)

本文介绍了一道关于树的LCA(最近公共祖先)问题的实战练习题,通过具体实例讲解了如何利用DFS(深度优先搜索)和DP(动态规划)等算法解决这类问题。文章包含完整的程序代码实现,并附带样例输入输出。

2370 小机房的树
时间限制: 1 s
空间限制: 256000 KB
题目等级 : 钻石 Diamond
题解
题目描述 Description
小机房有棵焕狗种的树,树上有N个节点,节点标号为0到N-1,有两只虫子名叫飘狗和大吉狗,分居在两个不同的节点上。有一天,他们想爬到一个节点上去搞基,但是作为两只虫子,他们不想花费太多精力。已知从某个节点爬到其父亲节点要花费 c 的能量(从父亲节点爬到此节点也相同),他们想找出一条花费精力最短的路,以使得搞基的时候精力旺盛,他们找到你要你设计一个程序来找到这条路,要求你告诉他们最少需要花费多少精力

输入描述 Input Description
第一行一个n,接下来n-1行每一行有三个整数u,v, c 。表示节点 u 爬到节点 v 需要花费 c 的精力。
第n+1行有一个整数m表示有m次询问。接下来m行每一行有两个整数 u ,v 表示两只虫子所在的节点
输出描述 Output Description
一共有m行,每一行一个整数,表示对于该次询问所得出的最短距离。

样例输入 Sample Input
3

1 0 1

2 0 1

3

1 0

2 0

1 2

样例输出 Sample Output
1

1

2

数据范围及提示 Data Size & Hint
1<=n<=50000, 1<=m<=75000, 0<=c<=1000

学LCA之后写的第一道练习题,很裸,但是很基础,很多后来写的lca也是从这一题的代码演变出来的。

program mys;

type ab=^node;
node=record
data,ends:longint;
next:ab;
end;

var x,y,z,u,v,i,j,k,m,n:longint;
f,d,c:array[0..50000]of longint;
dp:array[0..50000,0..30] of longint;
b:array[0..50000]of boolean;
p,a,pa,pp:array[0..50000]of ab;

procedure add(x,y,z:longint);
var i:ab;
begin 
i:=p[x];
new(p[x]);
p[x]^.data:=z;
p[x]^.ends:=y;
p[x]^.next:=i;
end;

procedure dfs(x:longint);
var i:ab;
y:longint;
begin 
b[x]:=true;
i:=p[x];
while i<>nil do
begin 
if b[i^.ends]=false then 
begin 
f[i^.ends]:=x;
d[i^.ends]:=d[x]+1;
c[i^.ends]:=c[x]+i^.data;
dfs(i^.ends);
end;
i:=i^.next;
end;
b[x]:=false;
end;

function lca(u,v:longint):longint;
var i:longint;
begin
if d[u]<d[v] then 
begin 
i:=u;
u:=v;
v:=i;
end;
i:=30;
while d[u]>d[v] do 
begin 
while d[dp[u,i]]<d[v] 
do dec(i);
u:=dp[u,i];
end;
if u=v then exit(u);
i:=30;
while i>=0 do
begin 
while (i>=0) and(dp[u,i]=dp[v,i]) do dec(i);
if i>=0 then 
begin 
u:=dp[u,i];
v:=dp[v,i];
end;
end;
exit(f[u]);
end;

begin 
readln(n);
fillchar(f,sizeof(f),0);
for i:=1 to n do
f[i-1]:=i-1;
for i:=1 to n-1 do 
begin 
readln(u,v,z);
add(u,v,z);
add(v,u,z);
end;
dfs(0);
for i:=1 to n do 
dp[i-1,0]:=f[i-1];
for j:=1 to 30 do 
for i:=1 to n do 
dp[i-1,j]:=dp[dp[i-1,j-1],j-1];
readln(m);
for i:=1 to m do
begin  
readln(x,y);
z:=lca(x,y);
writeln(c[x]+c[y]-2*c[z]);
end;
end.
<think>我们正在讨论笛卡尔在求解近公共祖先(LCA)问题上的应用。根据引用[2],笛卡尔具有两个重要特性: 1. 对于下标(即中序遍历)是二叉搜索(中序遍历为原序列顺序)。 2. 对于元素值,它满足堆的性质(子根节点是子值)。 引用[1]提到可以将RMQ(区间小值)问题转化为笛卡尔上的LCA问题。因为一个序列的RMQ问题可以转化为该序列构建的笛卡尔上的LCA问题:区间小值所在的下标就是该区间对应子的根节点(即LCA)。 因此,如果我们已经构建了序列的笛卡尔,那么对于任意两个节点(下标)的LCA,其实就是这两个节点在笛卡尔上的近公共祖先。 但是,请注意,这里我们要求的是原序列中两个位置(下标)的LCA,而笛卡尔中节点的编号就是原序列的下标。所以,在笛卡尔上求两个下标的LCA,得到的结果就是这两个下标对应的节点的近公共祖先节点,而这个祖先节点的值(即原序列中的值)就是这两个下标所夹区间的小值(如果是小根堆)。 那么,如何利用笛卡尔求解LCA呢?步骤如下: 1. 根据给定的序列(通常我们关心的是序列的值,但构建笛卡尔需要同时考虑下标和值)构建笛卡尔。注意:笛卡尔的下标就是原序列的下标,而节点值则是原序列的值。构建时,我们按照下标顺序(即中序遍历顺序)插入节点,同时维护堆性质(通常是小根堆或大根堆,根据问题需要)。 2. 构建好笛卡尔后,我们实际上得到了一棵。然后,我们可以使用任意一种LCA算法(如Tarjan离线算法、倍增法、RMQ转LCA等)来求解上任意两个节点的LCA。 但是,引用[1]和引用[5]提供了笛卡尔的构建模板,而引用[3]介绍了Tarjan算法求LCA。然而,我们这里更关心的是如何通过笛卡尔来求解LCA,特别是当我们将RMQ问题转化为LCA问题后,就可以用笛卡尔来高效解决。 实际上,笛卡尔求解LCA的过程就是普通的上的LCA求解。但是,由于笛卡尔具有特殊的性质(即的结构由序列的值决定),我们可以利用一些特性(如单调栈构建过程)来优化,但通常LCA的求解还是使用标准算法。 因此,我们有两种做法: - 先构建笛卡尔,然后在笛卡尔上使用倍增法或Tarjan算法求LCA(离线)。 - 或者,我们可以将笛卡尔上的LCA问题再转化为RMQ问题?注意:上的LCA问题可以通过DFS序转化为RMQ问题。但这样可能绕远了。 所以,我们通常的做法是: 1. 构建笛卡尔(线性时间)。 2. 在笛卡尔上预处理LCA(倍增法预处理O(nlogn),查询O(logn);或者Tarjan离线算法O(n+Q))。 但是,我们注意到,在笛卡尔中,两个节点的LCA就是它们之间区间的小值对应的节点。因此,如果我们已经构建了笛卡尔,那么求两个下标i和j的LCA,实际上就是求区间[i,j]的小值对应的下标。而求区间小值我们可以用RMQ(如ST表)在O(1)时间内回答,前提是做了O(nlogn)的预处理。 所以步骤可以这样: - 构建笛卡尔(得到结构)。 - 对笛卡尔进行DFS,得到欧拉序,然后构建欧拉序上的RMQ(用于求LCA)。 这样,我们就把原序列的RMQ问题(求区间小值)通过笛卡尔转化为了LCA问题,然后又将LCA问题通过欧拉序转化为了RMQ问题(欧拉序上的区间小值)。虽然看起来绕,但这样做的意义在于,原序列的RMQ问题(即求区间小值)可以转化为笛卡尔上的LCA,而LCA问题可以转化为欧拉序上的RMQ,而欧拉序上的RMQ(即±1RMQ)有更高效的解决方法。 但是,如果我们只需要求原序列的RMQ,那么直接使用ST表即可。那么为什么还要用笛卡尔呢?因为笛卡尔可以将多个RMQ问题转化为上的LCA问题,从而利用的结构特性(比如结合链剖分)或者用于解决其他问题(比如结合莫队等)。 回到用户的问题:他想使用笛卡尔求解近公共祖先(LCA)问题。这里要注意,笛卡尔本身并不是用来直接求任意上的LCA,而是用来将序列上的RMQ问题转化为笛卡尔上的LCA问题。但是,如果我们的问题本身就是在一个序列上,并且我们想求的是序列中两个位置之间的小值(即RMQ),那么我们可以通过笛卡尔将其转化为LCA问题。 所以,如果用户的问题是:给定一个序列,以及多个查询,每个查询要求序列区间[L,R]的小值。那么我们可以: 1. 构建序列的笛卡尔(小根堆)。 2. 对于每个查询[L,R],区间小值所在的位置就是笛卡尔中节点L和节点R的LCA节点(注意节点编号就是下标)。 因此,我们只需要求节点L和节点R在笛卡尔上的LCA,然后输出这个LCA节点的值(或者下标)即可。 那么,如何实现笛卡尔上的LCA呢?我们可以选择倍增法。 具体实现步骤: 一、构建笛卡尔 根据引用[5]的代码,我们可以用单调栈构建笛卡尔。这里是小根堆。 二、在笛卡尔上求LCA(倍增法) 1. 对笛卡尔进行DFS,得到每个节点的深度和父节点信息。 2. 预处理每个节点的祖先数组(倍增表)。 3. 对于每个查询,使用倍增法求LCA。 下面我们分别实现这两个部分。 第一部分:构建笛卡尔 我们使用数组`a[]`存储原序列,`n`为序列长度。 我们定义: - `lch[i]`: 节点i的左儿子 - `rch[i]`: 节点i的右儿子 - `parent[i]`: 节点i的父节点(可选,倍增法可以不用,但为了记录结构,我们至少需要记录左右儿子) 构建过程(参考引用[5]): ```cpp stack<int> st; int root; // 根 for (int i = 1; i <= n; i++) { int last = 0; while (!st.empty() && a[st.top()] > a[i]) { last = st.top(); // 循环退出时,last为后一个弹出的节点,它应该成为当前节点的左儿子 st.pop(); } if (st.empty()) { root = i; // 栈为空,当前节点为根 } else { rch[st.top()] = i; // 当前节点i成为栈顶节点的右儿子 } lch[i] = last; // 将后一次弹出的节点作为当前节点的左儿子 st.push(i); } ``` 注意:构建完成后,栈中可能还有元素,但根已经确定(root)。 第二部分:倍增法求LCA 1. 首先进行DFS,初始化深度和父节点(第一层祖先)。 2. 预处理祖先数组(倍增表)。 3. 实现LCA查询函数。 由于笛卡尔是一棵二叉,我们可以用标准的倍增法。 代码框架: ```cpp vector<int> depth(n+1, 0); vector<vector<int>> fa(n+1, vector<int>(LOG)); // LOG为大层数,比如20 // DFS初始化深度和直接父节点 void dfs(int u, int father) { depth[u] = depth[father] + 1; fa[u][0] = father; for (int i = 1; i < LOG; i++) { fa[u][i] = fa[fa[u][i-1]][i-1]; } if (lch[u]) dfs(lch[u], u); if (rch[u]) dfs(rch[u], u); } // 初始化根节点 dfs(root, 0); // LCA查询 int lca(int u, int v) { if (depth[u] < depth[v]) swap(u, v); // 将u提升到和v同一深度 int d = depth[u] - depth[v]; for (int i = 0; d; i++, d>>=1) { if (d & 1) u = fa[u][i]; } if (u == v) return u; for (int i = LOG-1; i >= 0; i--) { if (fa[u][i] != fa[v][i]) { u = fa[u][i]; v = fa[v][i]; } } return fa[u][0]; } ``` 后,对于每个查询(L, R),我们调用`lca(L, R)`,得到的结果就是区间[L,R]的小值所在的下标。注意:这里假设L和R是下标,且L<=R(但即使L>R,我们可以交换,因为LCA具有对称性)。但是,在笛卡尔中,节点L和节点R的LCA对应的下标就是[L,R]区间中小值的位置。 因此,我们可以通过这个位置得到小值:`a[lca(L,R)]`。 总结:笛卡尔LCA算法的原理是将序列的RMQ问题转化为笛卡尔上的LCA问题,然后通过上倍增法求解LCA。 注意:构建笛卡尔的时间复杂度是O(n),预处理倍增数组是O(nlogn),每次查询LCA是O(logn)。 相关问题: 1. 笛卡尔构建过程中为什么使用单调栈?它如何保证线性时间复杂度? 2. 除了倍增法,还有哪些方法可以求解笛卡尔上的LCA? 3. 笛卡尔在解决哪些经典问题中有应用?</think>### 笛卡尔求解 LCA 的原理与实现 #### 一、笛卡尔LCA 的关联原理 1. **笛卡尔特性**(引用[2]): - 对**下标**满足二叉搜索性质(中序遍历即原序列顺序) - 对**值**满足堆性质(子根节点是子值) - 示例:序列 $[3,5,1,7,4,6,2]$ 的笛卡尔结构: ``` 1(3) / \ 3(1) 5(2) / \ / \ 2(5)4(7)6(6)7(4) ``` 2. **RMQ 到 LCA 的转化**(引用[1]): - 序列区间 $[L,R]$ 的小值位置 = 节点 $L$ 和 $R$ 在笛卡尔上的 **LCA** - 数学表达: $$\text{argmin}_{i \in [L,R]} a_i = \text{LCA}(L,R)$$ #### 二、算法实现步骤 ##### 1. 笛卡尔构建(单调栈) ```cpp const int N = 1e6+5; int a[N], lch[N], rch[N], root; void build_cartesian_tree(int n) { stack<int> st; for (int i = 1; i <= n; i++) { int last = 0; while (!st.empty() && a[st.top()] > a[i]) { last = st.top(); // 保存后弹出的节点 st.pop(); } if (st.empty()) root = i; // 栈空则当前节点为根 else rch[st.top()] = i; // 当前节点作为栈顶右儿子 lch[i] = last; // 后弹出节点作为左儿子 st.push(i); } } ``` **时间复杂度**:$O(n)$,每个元素入栈出栈各一次[^4]。 ##### 2. LCA 查询(倍增法) ```cpp int depth[N], fa[N][20]; void dfs(int u, int father) { depth[u] = depth[father] + 1; fa[u][0] = father; for (int i = 1; i <= 18; i++) fa[u][i] = fa[fa[u][i-1]][i-1]; // 倍增预处理 if (lch[u]) dfs(lch[u], u); if (rch[u]) dfs(rch[u], u); } int lca(int x, int y) { if (depth[x] < depth[y]) swap(x, y); // 跳到同一深度 for (int i = 18; i >= 0; i--) if (depth[fa[x][i]] >= depth[y]) x = fa[x][i]; if (x == y) return x; // 同步上跳 for (int i = 18; i >= 0; i--) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i]; return fa[x][0]; } ``` **查询使用**: ```cpp int min_pos = lca(L, R); // 获取[L,R]区间小值下标 int min_val = a[min_pos]; // 获取小值 ``` #### 三、算法特性分析 1. **时间复杂度**: - 建:$O(n)$ - 预处理:$O(n \log n)$ - 单次查询:$O(\log n)$ 2. **空间复杂度**:$O(n \log n)$(存储倍增数组) 3. **适用场景**: - 静态序列 RMQ 问题(无需动态修改) - 需要获取值位置而非仅值 - 多次区间查询(如 $10^6$ 次查询)[^5] #### 四、典型例题 1. **洛谷 P1440**:求 $m$ 区间内的小值 - 解法:滑动窗口小值转化为笛卡尔 LCA[^4] 2. **POJ 2201**:构造笛卡尔并输出结构 3. **RMQ 问题扩展**: - 序列 $a = [3,5,1,7,4,6,2]$,查询 $[2,6]$ 的小值位置 **解**:$\text{LCA}(2,6) = 3$(对应值 $a[3]=1$) > 笛卡尔将序列的 RMQ 问题转化为结构的 LCA 问题,通过结合单调栈和倍增法,在 $O(n \log n)$ 预处理后实现高效查询[^1][^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值