Kruskal重构树

最新推荐文章于 2023-07-28 13:41:36 发布
最新推荐文章于 2023-07-28 13:41:36 发布
阅读量115 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ACMSN/p/10646306.html
版权

先推荐一篇对我帮助很大的博客：Kruskal重构树入门

前置知识

1、\(Kruskal\)算法

2、基础数据结构，如主席树

简述

\(Kruskal\)重构树与\(Kruskal\)算法密切相关。

我们知道，\(Kruskal\)算法是按照边权排序，依次合并节点，并用并查集维护联通。

\(Kruskal\)重构树则是合并节点\(x，y\)时，断开\(x，y\)的连边，新建一个节点\(z\)，将\(z\)作为\(x，y\)的父亲，同时把\(（x，y）\)的边权作为\(z\)的点权，然后用并查集维护联通。

1503934-20190402235815823-898145925.png
1503934-20190402235827644-1938858608.png

那么它有一些很有用的性质。

1、它是一个二叉堆。

2、若边权升序，则它是一个大根堆

3、任意两点路径边权最大值为\(Kruskal\)重构树上\(LCA\)的点权。

实现大致如下：

int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void Kruskal()
{
    sort(E+1, E+m+1, cmp);
    for (int i=1; i<=n; i++) fa[i]=i; int now=n;
    for (int i=1; i<=m; i++)
    {
        int x=E[i].x, y=E[i].y, w=E[i].w;
        int fx=find(x), fy=find(y);
        if (fx^fy)
        {
            val[++now]=w; fa[fx]=fa[fy]=fa[now]=now; 
            add(now, fx, 1); add(now, fy, 1);
        }
    }
}

例题

我们来看一道例题：

bzoj3551 Peaks

题目传送门

你没发现这是两个链接吗

Description

\(N​\)座山峰，有高度\(h_i​\)。山峰间有\(M​\)条双向边，有边权。\(Q​\)组询问，询问从\(v​\)开始经过边权不超过\(x​\)能到达的山峰中第\(k​\)高。强制在线。

Solution

显然，一个点能到达，在最小生成树上必定能到达。但建出最小生成树并没有什么用，于是我们建出\(Kruskal\)重构树，然后发现\(dfs\)+主席树静态区间\(K\)大就可以了。

代码如下（本代码为洛谷4197AC代码）：

#include<bits/stdc++.h>
using namespace std;
const int N=200005, M=500005;
struct node{int x, y, w;}E[M];
struct NODE{int to, nxt;}edge[N];
int size[N], deg[N], fa[N], dfn[N];
int in[N], out[N], h[N>>1], val[N];
int f[N][30], head[N], cnt, Cnt, tot, n, m, q;
int rt[N], ls[N<<5], rs[N<<5], sum[N<<5];

inline int read()
{
    int x=0,f=1;char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
    for (;ch>='0'&&ch<='9';ch=getchar()) x=(x<<1)+(x<<3)+ch-'0';
    return x*f;
}

void add(int u, int v)
{
    edge[++Cnt]=(NODE){v, head[u]};
    head[u]=Cnt; deg[v]++;
}

bool cmp(node a, node b){return a.w<b.w;}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}

void dfs(int u)
{
    dfn[++tot]=u; in[u]=tot; 
    for (int i=1; (1<<i)<=(n<<1); i++) f[u][i]=f[f[u][i-1]][i-1];
    for (int i=head[u]; i; i=edge[i].nxt)
    {
        int v=edge[i].to; if (v==f[u][0]) continue;
        f[v][0]=u; dfs(v); size[u]+=size[v];
    }
    if (!size[u]) size[u]=1; out[u]=tot;
}

void insert(int &o, int l, int r, int x, int v)
{
    ls[++cnt]=ls[o]; rs[cnt]=rs[o]; 
    sum[cnt]=sum[o]+v; o=cnt;
    if (l==r) return; int mid=(l+r)>>1;
    if (x<=mid) insert(ls[o], l, mid, x, v);
        else insert(rs[o], mid+1, r, x, v);
}

int kth(int u, int v, int l, int r, int k)
{
    if (l==r) return l; 
    int mid=(l+r)>>1, s=sum[rs[v]]-sum[rs[u]];
    if (k<=s) return kth(rs[u], rs[v], mid+1, r, k);
        else return kth(ls[u], ls[v], l, mid, k-s);
}

int query(int v, int x, int k)
{
    for (int i=25; ~i; i--) 
        if (f[v][i] && val[f[v][i]]<=x) v=f[v][i];
    if (size[v]<k) return -1;
    return kth(rt[in[v]-1], rt[out[v]], 0, 1e9, k);
}

int main()
{
    n=read(); m=read(); q=read(); int nn=n;
    for (int i=1; i<=n; i++) h[i]=read();
    for (int i=1; i<=m; i++) E[i]=(node){read(), read(), read()};
    sort(E+1, E+m+1, cmp);
    for (int i=1; i<=(n<<1); i++) fa[i]=i;
    for (int i=1; i<=m; i++)
    {
        int fx=find(E[i].x), fy=find(E[i].y);
        if (fx^fy)
        {
            val[++nn]=E[i].w; fa[fx]=fa[fy]=nn;
            add(nn, fx); add(nn, fy); 
        }
    }
    for (int i=1; i<=nn; i++) if (!deg[i]) dfs(i);
    for (int i=1; i<=nn; i++)
    {
        rt[i]=rt[i-1]; 
        if (dfn[i]<=n) insert(rt[i], 0, 1e9, h[dfn[i]], 1);
    }
    for (int i=1; i<=q; i++)
    {
        int v=read(), x=read(), k=read();
        printf("%d\n", query(v, x, k));
    }
    return 0;
}

再看一题

NOI2018 归程

题目传送门

机房神犇\(zzr\)用200+行可持久化并查集大力秒题，可是我不会。

Description

\(N\)个点\(M\)条边的连通图，用\(l, a\)表示长度，海拔。

\(Q​\)次询问，每次询问给定起点\(v ​\)，水位线\(p​\)，求经过海拔不低于\(p​\)能到达的点中距离1号节点最近的距离。

Solution

建立以海拔为关键字的\(Kruskal\)重构树（海拔为降序），那么能到达的点在\(Kruskal\)重构树的一个子树中。

那么就很清晰了，先用\(Dijkstra\)预处理单源最短路，再构建\(Kruskal\)重构树，然后\(dfs\)维护每个店为根的子树中距1号点的最小距离。处理询问时树上倍增即可。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=800005;
struct node{int x, y, l;}E[N];
struct Edge{int to, nxt, w;}edge[N];
struct heap{int u, w;};
int f[N][21], fa[N], vis[N], dis[N], mn[N], val[N];
int head[N], cnt, n, m;
bool operator < (heap a, heap b){return a.w>b.w;}
bool cmp(node a, node b){return a.l>b.l;}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}

inline int read()
{
    int x=0,f=1;char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
    for (;ch>='0'&&ch<='9';ch=getchar()) x=(x<<1)+(x<<3)+ch-'0';
    return x*f;
}

void add(int u, int v, int w)
{
    edge[++cnt]=(Edge){v, head[u], w};
    head[u]=cnt;
}

void Dijkstra()
{
    memset(vis, 0, sizeof(vis)); vis[1]=1;
    memset(dis, 0x3f, sizeof(dis)); dis[1]=0;
    priority_queue<heap> q; q.push((heap){1, 0});
    while (!q.empty())
    {
        int u=q.top().u; q.pop();
        for (int i=head[u]; i; i=edge[i].nxt)
        {
            int v=edge[i].to, w=edge[i].w;
            if (dis[v]>dis[u]+w)
                dis[v]=dis[u]+w, q.push((heap){v, dis[v]});
        }
    }
}

void dfs(int u, int fa)
{
    f[u][0]=fa; mn[u]=dis[u];
    for (int i=1; i<=20; i++) f[u][i]=f[f[u][i-1]][i-1];
    for (int i=head[u]; i; i=edge[i].nxt)
    {
        int v=edge[i].to; 
        dfs(v, u); mn[u]=min(mn[u], mn[v]);
    }
}

void Kruskal()
{
    sort(E+1, E+m+1, cmp);
    for (int i=1; i<=n; i++) fa[i]=i; int now=n;
    memset(head, 0, sizeof(head)); cnt=0;
    for (int i=1; i<=m; i++)
    {
        int x=E[i].x, y=E[i].y, w=E[i].l;
        int fx=find(x), fy=find(y);
        if (fx^fy)
        {
            val[++now]=w; fa[fx]=fa[fy]=fa[now]=now; 
            add(now, fx, 1); add(now, fy, 1);
        }
    }
    dfs(now, 0);
}

int main()
{
    int T=read();
    while (T--)
    {
        memset(head, 0, sizeof(head)); cnt=0;
        memset(mn, 0, sizeof(mn));
        memset(f, 0, sizeof(f));
        n=read(); m=read();
        for (int i=1; i<=m; i++)
        {
            int u=read(), v=read(), l=read(), a=read();
            E[i]=(node){u, v, a}; add(u, v, l); add(v, u, l);
        }
        Dijkstra(); Kruskal();
        int q=read(), k=read(), s=read();
        for (int i=1, last=0; i<=q; i++)
        {
            int v=(read()+k*last-1)%n+1, p=(read()+k*last)%(s+1);
            for (int j=20; ~j; j--)
                if (f[v][j] && val[f[v][j]]>p) v=f[v][j];
            printf("%d\n", last=mn[v]);
        }   
    }
    return 0;
}

最后一题

此题借鉴了Dance_Of_Faith大佬的博客。

IOI2018 Werewolf狼人

Description

\(N\)个点\(M\)条边的无向连通图。对于每次询问，给定\(S,E,L,R\)，求出能否从\(S\)出发，前一段只经过\(L\)到\(N\)的点，后一段只经过\(1\)到\(R\)的点，到达\(E\)点。

Solution

我们构建两棵Kruskal重构树。

一棵从大到小枚举点\(u\)，枚举连边且编号比它大的\(v\)，让\(v\)所在集合为\(u\)的儿子节点，那么从\(S\)出发前一段能经过的点在一个子树中，用树上倍增即可找到这个子树。

\(E​\)能到达的后一段也可同理求得。

接下来要找到一个前后两段的分界线，我们只需考虑每一个点在两棵树的\(dfs\)序是否都在每一次询问的\(S\)，\(E\)的出入的\(dfs\)序的区间中。这是经典的二维数点问题，离线用树状数组解决，在线用主席树解决。

因为本人比较懒，只给出了离线树状数组实现的代码。

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int N=200005;
struct node{int x, y, id, typ, sig;}q[N<<3];
bool operator < (node a, node b){return a.x<b.x || (a.x==b.x && a.typ<b.typ);}
vector<int> G[N];
int ans[N], d[N], n, m, Q;

struct dsu
{
    int fa[N];
    void init(){for (int i=1; i<=n; i++) fa[i]=i;}
    int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
}u, v;

struct Kruskal
{
    vector<int> G[N];
    int in[N], out[N], deg[N], dep[N], rnk[N], f[N][22], tot;
    void add(int u, int v){G[u].push_back(v); deg[v]++;}
    void dfs(int u, int fa)
    {
        in[u]=++tot; rnk[tot]=u;
        dep[u]=dep[fa]+1; f[u][0]=fa;
        for (int i=1; i<=20; i++) f[u][i]=f[f[u][i-1]][i-1];
        for (int v: G[u]) dfs(v, u);
        out[u]=tot;
    }
    void build()
    {
        int rt; for (int i=1; i<=n; i++) if (!deg[i]) rt=i;
        dfs(rt, 0);
    }
}U, V;

int getfa_U(int u, int anc)
{
    for (int i=20; ~i; i--) 
        if (U.f[u][i] && U.f[u][i]>=anc) u=U.f[u][i];
    return u;
}
int getfa_V(int v, int anc)
{
    for (int i=20; ~i; i--)
        if (V.f[v][i] && V.f[v][i]<=anc) v=V.f[v][i];
    return v;
}
    

void add(int x){for (; x<=n; x+=x&-x) d[x]++;}
int query(int x){int res=0; for (; x; x-=x&-x) res+=d[x]; return res;}

inline int read()
{
    int x=0,f=1;char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
    for (;ch>='0'&&ch<='9';ch=getchar()) x=(x<<1)+(x<<3)+ch-'0';
    return x*f;
}

int main()
{
    n=read(); m=read(); Q=read();
    for (int i=1; i<=m; i++)
    {
        int u=read()+1, v=read()+1;
        G[u].push_back(v); 
        G[v].push_back(u);
    }
    u.init(); v.init();
    
    for (int i=n; i; i--)
        for (int j: G[i]) if (j>i) 
        {
            int k=u.find(j);
            if (i^k) U.add(i, k), u.fa[k]=u.fa[i];
        }
    for (int i=1; i<=n; i++)
        for (int j: G[i]) if (j<i)
        {
            int k=v.find(j); 
            if (i^k) V.add(i, k), v.fa[k]=v.fa[i];
        }
    U.build(); V.build();
    
    for (int i=1; i<=n; i++)
        q[i].x=U.in[i], q[i].y=V.in[i], q[i].typ=0;
    int cnt=n;
    for (int i=1; i<=Q; i++) 
    {
        int x=read()+1, y=read()+1, l=read()+1, r=read()+1;
        int u=getfa_U(x, l), v=getfa_V(y, r);
        q[++cnt]=(node){U.out[u], V.out[v], i, 1, 1};
        if (U.in[u]>1) 
            q[++cnt]=(node){U.in[u]-1, V.out[v], i, 1, -1};
        if (V.in[v]>1) 
            q[++cnt]=(node){U.out[u], V.in[v]-1, i, 1, -1};
        if (U.in[u]>1 && V.in[v]>1) 
            q[++cnt]=(node){U.in[u]-1, V.in[v]-1, i, 1, 1};
    }
    
    sort(q+1, q+cnt+1);
    for (int i=1; i<=cnt; i++)
        if (q[i].typ)
            ans[q[i].id]+=q[i].sig*query(q[i].y);
        else add(q[i].y);
    for (int i=1; i<=Q; i++) printf("%d\n", (bool)ans[i]);
    return 0;
}

写在最后

其实有很多题目能够用\(Kruskal\)重构树暴力优雅地写过，例如\(NOIp2013\)货车运输。所以看到求经过权值不超过\(k\)的点或边能到达的点的相关的信息时，就可以艰难简单地考虑用\(Kruskal ​\)重构树来做啦。

转载于:https://www.cnblogs.com/ACMSN/p/10646306.html

weixin_30539835
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kruskal算法 最小生成树
03-08
所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。 具体实现过程如下： <1>　设一个有n个顶点的连通网络为G（V,E）...
Kruskal重构树详解
m0_61735576的博客
05-16 5162
这棵树有很多独特的性质 就比如我们想知道从节点2到7路径的最大边权是多少，其实就是他们公共祖先这个虚点的点权值 再比如我们想知道从某个点出发，给出一个值，在通过所有边的权值都小于等于这个值时，我们走过多少个点，其实就等于这个点一直往上面找，找到最后一个小于等于这个值的虚点，他的子树的点我们都是可以通过的（因为从上到下点权不上升） 以上这种问题我们都可以通过在重构树上倍增的方式，把时间复杂度压到logn
kruskal重构树
weixin_55851276的博客
07-12 837
kruskal重构树就是在进行kruskal算法时将边权改成点权，构造出一棵具有2n−1个点的树形结构。
【算法】并查集
WanDerIngcc的博客
02-18 184
int findFa(int x) { if(fa[x] == x) return x; return findFa(fa[x]); } void uni(int a,int b) { fa[findFa(a)] = findFa(b); } 路径压缩：只要我们在查询(findFa函数中)的过程中，把沿途的每个节点的父节点都设为根节点即可: int findFa(int x) { if(fa[x] == x) return x; fa[x] = findFa(f
Kruskal最小生成树
11-23
利用matlab 编写的kruskal 最小生成树的算法。
最小生成树的kruskal算法实现
04-27
实现了kruskal的算法，测试可行。
matlab ,kruskal算法，最小生成树
03-13
kruskal算法，最小生成树算法，内有示例，也可改成函数（在示例状态下被注释，要改成函数，取消那个注释，改下函数名或者文件名就行）
最小生成树Kruskal算法
01-05
编写算法能够建立带权图，并能够用Kruskal算法求该图的最小生成树。最小生成树能够选择图上的任意一点做根结点。最小生成树输出采用顶点集合和边的集合的形式。
中断动画的演示
05-03
清晰地看到硬件的工作原理过程。
Kruskal 重构树
m0_59092234的博客
03-15 2054
Kruskal 重构树 kruskal 最小生成树算法相信大家已经很熟悉了，所以这里就不介绍了。顾名思义 kruskal 重构树就是根据 kruskal 改造一下衍生出来的算法。它能解决下面这样的一个问题： 给定 n n n 个点 m m m 条边的无向图，每条边有一个边权为 d i d_i di。现在有 k k k 个询问，每次查询两点 x , y x, y x,y 之间的所有路径中，最长的边的最小值是多少。（ 1 ≤ n ≤ 15000 , 1 ≤ m ≤ 30000 , d i ≤ 1 e 9 , k
算法笔记-Kruskal重构树
m0_53899788的博客
10-19 319
Kruskal重构树
Kruskal重构树入门
最新发布
mygrn的博客
07-28 171
Kruskal算法是一种求图上最小生成树的算法具体流程是：1.将图上所有边按边权由小到大排序2.每次取出一条边，若边的两个端点未被连接，则新增一条边3.重复操作2，直至图上所有点联通。
Kruskal重构树学习笔记（C++）
m0_74036684的博客
01-16 471
Kruskal重构树学习笔记
acm-Kruskal重构树学习笔记
qq_30361651的博客
09-30 379
引言 Kruskal重构树主要用于解决在线查询问题，询问通常涉及的条件为边权小于某值。 原理 考虑利用Kruskal算法构建一个最小生成树，但在此过程中稍稍改动一下。Kruskal算法的过程主要是按照边权由小到大的顺序对边上的两点做合并操作。现在假设正在处理u−v\mathbf{u-v}u−v这条边，Kruskal重构树将不会直接在新图建立边u−v\mathbf{u-v}u−v，而是建立一个新的节点t\mathbf{t}t，然后让该节点连向u和v\mathbf{u和v}u和v各自连通块的根节点，并给t\
Kruskal算法、Kruskal重构树、LCA算法
qq_61786525的博客
05-09 963
KruskalKruskalKruskal 算法是一种求解最小生成树的贪心算法。它的基本思想是从图中的边集中依次选取边，使得选出的边不会构成回路，并且满足边权和最小。具体实现过程如下：将原图中的所有边按照边权从小到大排序。依次选取排序后的边，如果这条边的两个端点不在同一个连通块中，则加入该边，将它们之间的连通块合并成一个新的连通块，并把该边加入最小生成树的边集中。重复上述步骤，直至加入 n−1n−1n−1 条边（其中 nnn 表示原图的节点数），此时得到的边集即为原图的最小生成树。KruskalKruska

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值