重构树 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;
}
### Kruskal 重构树的概念与实现 #### 什么是 Kruska l重构树? Kruskal 重构树是一种基于 Kruska l最小生成树算法构建的数据结构。其核心思想是在执行 Kruska l算法的过程中,通过引入新的节点来记录边的信息,从而形成一棵具有特殊性质的树[^1]。 具体来说,在 Kruska l最小生成树算法中,当尝试加入一条边 \((x, y, z)\)(其中 \(z\) 是边权)时,会创建一个新的节点,并将其作为 \(x\) 和 \(y\) 的父节点。新节点的点权被设为 \(z\),表示这条边的最大权重。这一过程利用了并查集的思想,动态维护连通分量的关系[^2]。 最终形成的是一棵自下而上点权不减的二叉树,这棵树被称为 Kruska l重构树[^3]。 --- #### Kruska l重构树的强大性质 Kruska l重构树的一个重要特性是:对于原图中的任意两点 \(u\) 和 \(v\),它们之间所有路径上的 **边最大权值的最小值** 等于在 Kruska l重构树上这两点最近公共祖先(LCA)的点权[^4]。这种映射关系使得 Kruska l重构树成为解决某些最短路或瓶颈问题的有效工具。 --- #### Kruska l重构树的实现步骤 以下是 Kruska l重构树的具体实现方法: 1. 使用 Kruska l算法计算最小生成树。 2. 在每次合并两个集合时,新建一个节点作为这两个集合的新根节点。 3. 将当前边的权重赋给这个新节点作为它的点权。 4. 更新并查集中对应集合的父亲指针指向新节点。 5. 继续上述操作直到生成完整的最小生成树为止。 下面是具体的代码实现示例: ```python class UnionFind: def __init__(self, n): self.parent = list(range(n)) def find(self, x): if self.parent[x] != x: self.parent[x] = self.find(self.parent[x]) return self.parent[x] def union(self, x, y, new_node): fx, fy = self.find(x), self.find(y) if fx != fy: self.parent[fx] = new_node self.parent[fy] = new_node def build_kruskal_reconstruction_tree(edges, n): edges.sort(key=lambda e: e[2]) # Sort by weight uf = UnionFind(n) tree_nodes = [] node_count = n for u, v, w in edges: fu, fv = uf.find(u), uf.find(v) if fu != fv: new_node = node_count node_count += 1 # Add the new node with its weight as point value tree_nodes.append((new_node, w)) # Update parent pointers to this new node uf.union(fu, fv, new_node) return tree_nodes, node_count ``` 此函数接收一组带权边 `edges` 和顶点数 `n`,返回的是重建后的 Kruska l重构树及其总节点数量。 --- #### 应用场景举例 - 计算两节点间的最大边权最小值。 - 解决涉及路径瓶颈的问题,比如网络流量分析或者资源分配优化等问题。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值