重构树 Fiolki

问题 B: Fiolki
时间限制: 3 Sec 内存限制: 128 MB
题目描述
化学家吉丽想要配置一种神奇的药水来拯救世界。
吉丽有n种不同的液体物质,和n个药瓶(均从1到n编号)。初始时,第i个瓶内装着g[i]克的第i种物质。吉丽需要执行一定的步骤来配置药水,第i个步骤是将第a[i]个瓶子内的所有液体倒入第b[i]个瓶子,此后第a[i]个瓶子不会再被用到。瓶子的容量可以视作是无限的。
吉丽知道某几对液体物质在一起时会发生反应产生沉淀,具体反应是1克c[i]物质和1克d[i]物质生成2克沉淀,一直进行直到某一反应物耗尽。生成的沉淀不会和任何物质反应。当有多于一对可以发生反应的物质在一起时,吉丽知道它们的反应顺序。每次倾倒完后,吉丽会等到反应结束后再执行下一步骤。
吉丽想知道配置过程中总共产生多少沉淀。
输入
第一行三个整数 n,m,k(0<=m,n<=200000,0<=k<=500000),
分别表示药瓶的个数(即物质的种数),操作步数,可以发生的反应数量。
第二行有n个整数g[1],g[2],…,g[n](1<=g[i]<=10^9),表示初始时每个瓶内物质的质量。
接下来m行,每行两个整数a[i],bi,表示第i个步骤。保证a[i]在以后的步骤中不再出现。
接下来k行,每行是一对可以发生反应的物质c[i],di,按照反应的优先顺序给出。同一个反应不会重复出现。
输出
配置过程中总共产生多少沉淀。
样例输入
3 2 1
2 3 4
1 2
3 2
2 3
样例输出
6
给自己普及一下克鲁斯卡尔重构树
假如要给两个点连一条边,就新建一个点,作为那两个点的父亲,那么这样就可以考虑时间的问题了。
对于这道题,有两个关键字,1时间,2反映顺序。
反映顺序好处理,主要是建边之后如何考虑时间先后的问题。那就可以用到了。每合并一次新建一个点,那就相当于处理了时间。在这里建立了最初的图。每给出一对反应,他最多反应一次,就可以LCA出两物质相交的位置,在那个节点vector存储先后顺序。最后从前到后模拟每一次合并就能完美O(M+K*log+K)的效率了。
因为不同反应间可能不连通,利用并查集。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#define ll long long
#define N 200005
using namespace std;
int read()
{
    int sum=0,f=1;char x=getchar();
    while(x<'0'||x>'9'){if(x=='-')f=-1;x=getchar();}
    while(x>='0'&&x<='9'){sum=(sum<<1)+(sum<<3)+x-'0';x=getchar();}
    return sum*f;
}
struct road{int v,next;}lu[4*N];
int n,m,k,e,cnt,v1[N*5],v2[N*5],t[N*2],f[N*2],adj[N*2],dep[N*2],p[N*2][23];
vector<int> v[N*2];
ll ans,g[N];
inline void add(int u,int v){lu[++e].v=v;lu[e].next=adj[u];adj[u]=e;}
inline int find(int x){return f[x]==x? x:f[x]=find(f[x]);}
inline void dfs1(int x,int deep)
{
    dep[x]=deep;
    for(int i=adj[x];i;i=lu[i].next)
        if(lu[i].v!=p[x][0])
            dfs1(lu[i].v,deep+1);
}
void init()
{
    for(int j=1;j<=18;j++)
        for(int i=1;i<=cnt;i++)
                p[i][j]=p[p[i][j-1]][j-1];
}
inline int LCA(int x,int y)
{
    int i,j;
    if(dep[x]<dep[y])swap(x,y);
    for(i=0;(1<<i)<=dep[x];i++);
    i--;
    for(j=i;j>=0;j--)
        if(dep[x]-(1<<j)>=dep[y])
            x=p[x][j];
    if(x==y)return x;
    for(j=i;j>=0;j--)
        if(p[x][j]!=0&&p[x][j]!=p[y][j])
            x=p[x][j],y=p[y][j];
    return p[x][0];
}
int main()
{
    //freopen("fio.in","r",stdin);
    //freopen("fio.out","w",stdout);
    n=read();m=read();k=read();int x,y;cnt=n;
    for(int i=1;i<=n;i++)scanf("%lld",&g[i]);
    for(int i=1;i<=n+m;i++)f[i]=i;
    for(int i=1;i<=m;i++)
    {
        x=read(),y=read();x=find(x),y=find(y);++cnt;
        t[i]=f[x]=f[y]=p[y][0]=p[x][0]=cnt;
        add(cnt,y);add(cnt,x);
    }
    for(int i=1;i<=cnt;i++)if(!dep[i])dfs1(find(i),1);
    init();
    for(int i=1;i<=k;i++)
    {
        x=read();y=read();if(find(x)!=find(y))continue;
        int h=LCA(x,y);
        v[h].push_back(i);v1[i]=x,v2[i]=y;
    }
    for(int i=1;i<=m;i++)
    {
        x=t[i];
        for(int j=0;j<v[x].size();j++)
        {
            int a=v1[v[x][j]],b=v2[v[x][j]];
            if(!g[a]||!g[b])continue;
            if(g[a]<g[b]){g[b]-=g[a],ans+=g[a],g[a]=0;}
            else {g[a]-=g[b],ans+=g[b],g[b]=0;}
        }
    }
    cout<<ans*2;
}
<think>我们注意到用户查询中提到了"Kru重构树",但根据常见的计算机科学术语,这可能是指"Kruskal重构树"(Kruskal Reconstruction Tree),这是一种基于Kruskal最小生成树算法的扩展数据结构。然而,用户输入中写的是"Kru重构树",可能是拼写错误或简写。在中文语境中,Kruskal算法通常被音译为"克鲁斯卡尔"算法,其重构树也常被称为"Kruskal重构树"。 因此,我们将围绕Kruskal重构树进行回答。Kruskal重构树是Kruskal算法在执行过程中构建的一棵二叉树,它不仅可以用于求解最小生成树,还可以用于解决一些图上的路径查询问题,特别是瓶颈边问题。 ### Kruskal重构树 #### 基本概念 Kruskal重构树是在执行Kruskal算法时构建的一棵二叉树。在Kruskal算法中,我们按边权从小到大的顺序考虑边,如果加入该边不会形成环,则加入该边。在重构树中,我们将每次加入的边转化为一个节点,并将该边连接的两个连通分量的根节点作为该新节点的左右子节点。这样,原图中的节点成为叶子节点,而内部节点则对应加入的边。 重构树具有以下性质: 1. 二叉树,每个内部节点有两个子节点。 2. 叶子节点对应原图的节点,内部节点对应加入的边。 3. 重构树的点数为$2n-1$,其中$n$是原图节点数。 4. 从叶子节点到根的路径上,节点的边权(即内部节点对应的边权)是递增的(如果按最小生成树的方式构建,则是递增的;如果是按最大生成树,则是递减的)。 5. 原图中两个节点$u$和$v$之间的路径上的最大边权(或最小边权,取决于构建方式)等于重构树上$u$和$v$的最近公共祖先(LCA)对应的边权。 #### 构建过程 1. 初始化:将每个节点视为一个独立的连通块,并为每个连通块创建一个树节点(叶子节点)。 2. 对边按权值从小到大排序(最小生成树情况)。 3. 遍历每条边: - 如果当前边连接的两个连通块不在同一个连通块中,则: - 创建一个新的内部节点,其权值为当前边的权值。 - 将两个连通块的根节点作为新节点的左右子节点。 - 将新节点设为合并后连通块的根节点。 4. 最终得到的树就是Kruskal重构树。 #### 应用场景 1. **最小瓶颈路**:在重构树中,任意两点$u$和$v$的最小瓶颈路(即路径上最大边权最小的路径)的最大边权等于它们在重构树中LCA的权值。因此,我们可以通过LCA快速查询任意两点间的最小瓶颈路的最大边权。 2. **从某个点出发经过边权不超过$w$的边能到达的节点**:在重构树中,从叶子节点$u$向上跳到权值不超过$w$的最远的祖先节点,则该祖先节点的子树中所有叶子节点就是$u$能到达的节点(因为子树中任意节点与$u$的路径上的最大边权都不超过$w$)。 3. **结合其他数据结构**:重构树可以与其他数据结构(如树链剖分、倍增、可持久化线段树等)结合,解决更多复杂问题。 #### 示例代码(构建Kruskal重构树) ```python class Node: def __init__(self, weight, left=None, right=None): self.weight = weight # 对于叶子节点,weight可以设为0,或者不存储;内部节点存储边权 self.left = left self.right = right def kruskal_tree(n, edges): # 初始化:每个节点是一个连通块,并创建一个叶子节点 parent = [i for i in range(2*n-1)] # 重构树节点数最多为2n-1 nodes = [None] * (2*n-1) # 初始化叶子节点,可以没有权值,或者用0 for i in range(n): nodes[i] = Node(0) # 按边权排序(最小生成树) edges.sort(key=lambda x: x[2]) # 并查集初始化 fa = list(range(2*n-1)) # 并查集父节点 def find(x): if fa[x] != x: fa[x] = find(fa[x]) return fa[x] # 当前新节点创建位置 idx = n # 当前可用的新节点索引,从n开始(0到n-1是叶子节点) # 遍历边 for u, v, w in edges: fu = find(u) fv = find(v) if fu != fv: # 创建新节点 new_node = Node(w, nodes[fu], nodes[fv]) nodes[idx] = new_node # 合并并查集 fa[fu] = idx fa[fv] = idx fa[idx] = idx # 自己作为根 idx += 1 if idx == 2*n-1: break # 根节点是最后一个创建的内部节点 root = nodes[idx-1] return root ``` 注意:上述代码中,我们假设原图的节点编号为0到n-1,内部节点从n开始编号。并查集用于维护连通性,同时记录每个连通块的根节点在重构树中的节点。 §§相关问题§§ 1. Kruskal重构树与最小生成树有什么关系? 2. 如何利用Kruskal重构树查询两点间的最小瓶颈路? 3. Kruskal重构树在哪些算法竞赛题目中有应用? 4. 除了Kruskal重构树,还有哪些重构树(如Prim重构树)?它们有何不同?</think>### Kruskal重构树详解 Kruskal重构树是基于Kruskal最小生成树算法扩展的一种数据结构,主要用于高效解决图上路径查询问题。下面从算法原理、数据结构和应用场景三个维度详细说明。 #### 一、算法原理 1. **基础Kruskal算法** 在构建最小生成树(MST)时,按边权从小到大遍历边: - 若边连接两个不同连通块,则加入MST - 使用并查集维护连通性 2. **重构过程** 在Kruskal算法基础上进行扩展: - 当合并连通块$A$和$B$时 - 创建新节点$u$,权值为当前边权$w$ - 将$A$和$B$的根节点设为$u$的子节点 $$ \text{重构树节点} = (A_{root}, B_{root}, w) $$ - 最终形成二叉树结构,叶子节点为原图顶点 #### 二、数据结构特性 1. **树结构性质**: - 叶子节点:原图的$n$个顶点 - 内部节点:$n-1$个合并操作节点 - 总节点数:$2n-1$ - 满足堆性质:从叶到根路径上节点权值单调递增(最小生成树情况) 2. **关键操作**: ```python def kruskal_tree(n, edges): parent = list(range(2*n-1)) # 并查集 tree = [None] * (2*n-1) # 重构树存储 # 初始化叶子节点 for i in range(n): tree[i] = {'val': 0, 'left': None, 'right': None} edges.sort(key=lambda x: x[2]) # 按边权排序 idx = n # 新节点索引 for u, v, w in edges: fu = find(u, parent) # 并查查找 fv = find(v, parent) if fu != fv: # 创建新节点 tree[idx] = {'val': w, 'left': fu, 'right': fv} parent[fu] = parent[fv] = idx idx += 1 return tree ``` #### 三、应用场景 1. **最小瓶颈路查询** 查询两点间路径的最大边权最小值: $$ \text{max\_min\_edge}(u,v) = \text{LCA}(u,v)\text{.val} $$ 时间复杂度:$O(\log n)$(使用倍增LCA) 2. **连通性分析** 给定边权阈值$w$,快速判断: - 两点是否可通过边权$≤w$的路径连通 - 从某点出发能到达的连通区域(子树查询) 3. **网络可靠性设计** 在通信网络中优化基站部署: - 重构树根节点对应关键连接边 - 识别网络脆弱点(权值高的内部节点) 4. **竞赛题目应用** 典型问题类型: - 求图中两点间所有路径的最大边权最小值 - 动态加边过程中的连通块管理 - 结合树链剖分的路径统计问题 > **示例**:城市道路规划中,用重构树可快速查询任意两居民区之间的最差路况(路径上最破旧的道路质量),辅助制定道路维修优先级[^1]。 #### 四、优势与局限 | 优势 | 局限 | |------|------| | 将图问题转化为树问题 | 仅适用于无向图 | | 支持高效LCA查询 | 需预计算$O(m\log m)$ | | 直观反映连通关系 | 空间开销$O(n)$ |
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值