Kruskal重构树学习

最新推荐文章于 2023-07-28 13:41:36 发布
最新推荐文章于 2023-07-28 13:41:36 发布
阅读量449 收藏 2
点赞数 1
分类专栏： 图论 文章标签： 算法 数据结构 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45724872/article/details/121668064
版权

引入

简单来讲，就是在Kruskal算法进行的过程中，我们把最小生成树的边权改为点权;

可以看成是Kruskal算法的扩展使用；

假设原树有 n n n个结点，因为最小生成树是 n − 1 n-1 n−1条边；

那么重构树有 2 n − 1 2n-1 2n−1个结点；

举个例子，比如 x x x到 y y y连了一条边；
在这里插入图片描述
那么重构以后变成这样；

在这里插入图片描述

性质

  • 是一个小/大根堆(由建树时边权的排序方式决定)
  • 所有原来的点是叶子节点
  • L C A ( u , v ) LCA(u,v) LCA(u,v)的点权是 原图 u u u到 v v v路径上最大边权的最小值或者最小边权的最大值(由建树时边权的排序方式决定)

重构流程

在这里插入图片描述
其实就是在 K r u s k a l Kruskal Kruskal基础上加点代码;

void EX_Kru(){
    sort(input+1,input+1+m);
    for(int i=1;i<=2*n-1;++i) p[i] = i;
    for(int i=1;i<=m;++i){
        int u = input[i].p1,v = input[i].p2,val = input[i].val;
        int fu = _find(u),fv = _find(v);
        //如果不形成环
        if(fu != fv){
            //化边权为点权
            p[fu] = p[fv] = ++idx;
            pval[idx] = val;
            add(idx,fu),add(idx,fv);
        }
    }
}

例题

货车运输

题面

传送门
在这里插入图片描述
在这里插入图片描述

思路

因为想让运送的货物尽可能重；

不难想到，货物重量的下限是取决于称重最少的边；

比如当前从 u u u到 v v v，我们需要求 u u u到 v v v中最短路径中权值最小的，而我们希望这条路径的边权是尽可能大的，也就是求最大边权的最小值；

之所以是最短路径，是因为现在 u u u已经能到 v v v了，那么多加其他的边，只可能让最小边权变小，因此我们可以贪心的搞；

Code

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;

typedef long long ll;

const int N = 2e4 + 10,M = 5e4 + 10;

int p[N],n,m,q;

struct Edge{
    int next,to;
}e[M << 1];

struct Node{
    int p1,p2,val;
    bool operator<(const Node &o){
        return val > o.val;
    }
}input[M];
int head[N],tot;
int _find(int x){
    if(x == p[x]) return x;
    return p[x] = _find(p[x]);
}
int pval[N],idx;//点权、点的编号
void add(int u,int v){
    e[++tot].to = v;
    e[tot].next = head[u];
    head[u] = tot;
}
//Kru重构树
void EX_Kru(){
    sort(input+1,input+1+m);
    for(int i=1;i<=2*n-1;++i) p[i] = i;
    for(int i=1;i<=m;++i){
        int u = input[i].p1,v = input[i].p2,val = input[i].val;
        int fu = _find(u),fv = _find(v);
        //如果不形成环
        if(fu != fv){
            //化边权为点权
            p[fu] = p[fv] = ++idx;
            pval[idx] = val;
            add(idx,fu),add(idx,fv);
        }
    }
}
int dep[N],fa[N][30];
void init_LCA(int root){
    queue<int> que;
    dep[0] = 0,dep[root] = 1;
    que.push(root);
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i=head[u];i;i=e[i].next){
            int to = e[i].to;
            if(dep[to] > dep[u] + 1){
                dep[to] = dep[u] + 1;
                que.push(to);
                fa[to][0] = u;
                for(int k=1;k<=25;++k){
                    fa[to][k] = fa[fa[to][k-1]][k-1];
                }
            }
        }
    }
}
int LCA(int u,int v){
    if(dep[u] < dep[v]) swap(u,v);
    for(int k=25;k>=0;--k){
        if(dep[fa[u][k]] >= dep[v]){
            u = fa[u][k];
        }
    }
    if(u == v) return u;
    for(int k=25;k>=0;--k){
        if(fa[u][k] != fa[v][k]){
            u = fa[u][k];
            v = fa[v][k];
        }
    }
    return fa[u][0];
}

void solve(){
    cin >> n >> m;
    idx = n;
    for(int i=1;i<=m;++i){
        cin >> input[i].p1 >> input[i].p2 >> input[i].val;
    }
    EX_Kru();
    //因为这道题可能是一个森林 因此我们需要初始化每颗树
    memset(dep,0x3f,sizeof dep);
    for(int i=n+1;i<=idx;++i){
        //说明是根结点
        if(p[i] == i){
            init_LCA(i);
        }
    }
    cin >> q;
    while(q--){
        int u,v;
        cin >> u >> v;
        //不连通肯定不在同一个集合中
        if(_find(u) != _find(v)) cout << -1 << '\n';
        else{
            int anc = LCA(u,v);
            cout << pval[anc] << '\n';
        }
    }
}

signed main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

归程

传送门

题面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

思路

由题意我们知道，从 v v v到 1 1 1，我们分为一半坐车另一半走路；

假设在点 u u u下车，那么答案要求 v v v到 u u u可以开车， u u u到 1 1 1走路距离最短；

要使得 v v v到 u u u可以开车，那么就要求这些路径的水位线高于当天的水位线；

这些路径一定在原图的最大生成树上，这就启发我们可以使用Kruskal重构树；

而从任意一点到点 1 1 1走路的最短距离，我们只需要以点 1 1 1为源点，跑一个迪杰斯特拉最短路即可；

现在我们将每条边以海拔为关键字降序排序；

比如说重构树上的某个子树的根root的水位线是大于当天的水位线的；

那么这个子树内部的其他路径也必然是满足大于当天水位线的(小根堆性质)；

也就是这棵子树的叶子结点是开车可达的；

那么我们枚举从这些点到点 1 1 1走路的最小值，即是答案；

由于是树形，我们只需要用树形DP来处理出dist(u)，这样就不需要枚举了；

dist(u)表示以某点为根，走路到点 1 1 1的最小长度；

而如何快速的找到重构树上的某一点的深度是最浅的，且大于水位线，只需要使用树上倍增即可；

Code

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
#include <utility>

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int N = 400000 + 10,M = 800000 + 10;

int p[N],idx;
struct Node{
    int u,v,height;
    bool operator<(const Node &o){
        return height > o.height;
    }
}ip[M];
struct Edge{
    int next,to,val;
}e[M];
int head[N],dist[N],tot;
bool vis[N];
void add(int u,int v,int w){
    e[++tot].to = v;
    e[tot].val = w;
    e[tot].next = head[u];
    head[u] = tot;
}
void add(int u,int v){
    e[++tot].to = v;
    e[tot].next = head[u];
    head[u] = tot;
}
int n,m,pval[N],fa[N][30];
int _find(int x){
    if(x == p[x]) return x;
    return p[x] = _find(p[x]);
}

void dij(int start){
    priority_queue<pii,vector<pii>,greater<pii>> pq;
    memset(dist,0x3f,sizeof dist);
    memset(vis,0,sizeof vis);
    dist[start] = 0;
    pq.push({dist[start],start});
    while(!pq.empty()){
        int u = pq.top().second;
        pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int i=head[u];i;i=e[i].next){
            int to = e[i].to;
            if(dist[to] > dist[u] + e[i].val){
                dist[to] = dist[u] + e[i].val;
                pq.push({dist[to],to});
            }
        }
    }
}
void EX_Kru(){
    idx = n;
    for(int i=1;i<=2*n-1;++i) p[i] = i;
    sort(ip+1,ip+1+m);
    int cnt = 0;
    for(int i=1;i<=m;++i){
        int u = ip[i].u, v = ip[i].v, h = ip[i].height;
        int fu = _find(u), fv = _find(v);
        if(fu != fv){
            if(++cnt == n) break;
            //化边为点
            p[fu] = p[fv] = ++idx;
            pval[idx] = h;
            add(idx,fu),add(idx,fv);  
        }
    }
}
void dfs(int u){
    //先处理深度较浅的点
    for(int k=1;k<=25;++k)
        fa[u][k] = fa[fa[u][k-1]][k-1];
    for(int i=head[u];i;i=e[i].next){
        int to = e[i].to;
        fa[to][0] = u;
        dfs(to);
        dist[u] = min(dist[u],dist[to]);
    }
}
int query(int u,int p){
    for(int k=25;k>=0;--k)
        //水位线要高于p
        if(fa[u][k] && pval[fa[u][k]] > p)
            u = fa[u][k];
    return dist[u];
}
void solve(){
    memset(head,0,sizeof head);
    memset(fa,0,sizeof fa);
    tot = 0;
    cin >> n >> m;
    for(int i=1,u,v,w,h;i<=m;++i){
        cin >> u >> v >> w >> h;
        ip[i] = {u,v,h};
        add(u,v,w),add(v,u,w);
    }
    dij(1);//处理出dist数组
    tot = 0;
    memset(head,0,sizeof head);
    EX_Kru();
    for(int i=n+1;i<=2*n-1;++i){
        if(p[i] == i){ //处理每颗树
            dfs(i);
        }
    }
    int q,k,s;
    cin >> q >> k >> s;
    int lastans = 0;
    while(q--){
        int v0,p0;
        cin >> v0 >> p0;
        v0 = (v0+k*lastans-1)%n+1;
        p0 = (p0+k*lastans)%(s+1);
        lastans = query(v0,p0);
        cout << lastans << '\n';
    }
}

signed main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t;
    cin >> t;
    while(t--)
        solve();
    return 0;
}

Life is a Game

题面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

题意

从某点出发，

思路

不难想到，因为我们要获取尽可能多的声望；

因此从当前点到另一个点，肯定要走所需声望少的边；

那么实际上，我们如果要走完所有的点，那么走的必然是最小生成树；

因此我们可以考虑使用Kruskal重构树；

我们按所需声望从小到大排序，搞出一个大根堆；

Code

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
#include <utility>
#include <set>

using namespace std;

typedef long long ll;

const int N = 2e5 + 10;

int n,m,q,pval[N];
struct Edge{
    int next,to;
}e[N];
int head[N],tot;
void add(int u,int v){
    e[++tot].to = v;
    e[tot].next = head[u];
    head[u] = tot;
}
struct Node{
    int u,v,w;
    bool operator<(const Node &o){
        return w < o.w; //大根堆
    }
}ip[N];
int p[N],fa[N][30],g[N][30],tr_sum[N];
int _find(int x){
    if(x == p[x]) return x;
    return p[x] = _find(p[x]);
}
void EX_Kru(){
    int idx = n;
    int cnt = 0;
    for(int i=1;i<=2*n-1;++i) p[i] = i;
    sort(ip+1,ip+1+m);
    for(int i=1;i<=m;++i){
        int u = ip[i].u,v = ip[i].v,w = ip[i].w;
        int fu = _find(u),fv = _find(v);
        if(fu != fv){
            //最小生成树,n-1条边
            if(++cnt == n) break;
            p[fu] = p[fv] = ++idx;
            pval[idx] = w;
            add(idx,fu),add(idx,fv);
        }
    }
}
//当前结点
void dfs(int u){
    for(int k=1;k<=25;++k){
        fa[u][k] = fa[fa[u][k-1]][k-1];
    }
    for(int i=head[u];i;i=e[i].next){
        //这里是单向边
        int to = e[i].to;
        fa[to][0] = u;
        dfs(to);
        tr_sum[u] += tr_sum[to];
        g[to][0] = pval[u] - tr_sum[to];
    } 
}
typedef pair<int,int> pii;
void solve(){
    cin >> n >> m >> q;
    for(int i=1;i<=n;++i) cin >> pval[i],tr_sum[i] = pval[i];
    for(int i=1;i<=m;++i){
        cin >> ip[i].u >> ip[i].v >> ip[i].w;
    }
    EX_Kru();
    for(int i=n+1;i<=2*n-1;++i){
        if(p[i] == i){
            fa[i][0] = 0;
            dfs(i);
        }
    }
    for(int k=1;k<=25;++k)
        for(int i=1;i<=2*n-1;++i)
            //防止父亲满足但是儿子不满足
            g[i][k] = max(g[i][k-1],g[fa[i][k-1]][k-1]);
    int x,power;
    while(q--){
        cin >> x >> power;
        for(int k=25;k>=0;--k){
            if(fa[x][k] == 0) continue;
            if(g[x][k] <= power){
                x = fa[x][k];
            }
        }
        cout << power + tr_sum[x] << '\n';
    }
}

signed main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

参考

博客1
博客2
博客3

荼白777
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Kruskal算法 最小生成树
03-08
所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。 具体实现过程如下： <1>　设一个有n个顶点的连通网络为G（V,E）...
Kruskal重构树详解
m0_61735576的博客
05-16 5036
这棵树有很多独特的性质 就比如我们想知道从节点2到7路径的最大边权是多少，其实就是他们公共祖先这个虚点的点权值 再比如我们想知道从某个点出发，给出一个值，在通过所有边的权值都小于等于这个值时，我们走过多少个点，其实就等于这个点一直往上面找，找到最后一个小于等于这个值的虚点，他的子树的点我们都是可以通过的（因为从上到下点权不上升） 以上这种问题我们都可以通过在重构树上倍增的方式，把时间复杂度压到logn
kruskal重构树
weixin_55851276的博客
07-12 800
kruskal重构树就是在进行kruskal算法时将边权改成点权，构造出一棵具有2n−1个点的树形结构。
Kruskal 重构树
m0_59092234的博客
03-15 2043
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
matlab ,kruskal算法，最小生成树
03-13
kruskal算法，最小生成树算法，内有示例，也可改成函数（在示例状态下被注释，要改成函数，取消那个注释，改下函数名或者文件名就行）
Kruskal最小生成树
11-23
利用matlab 编写的kruskal 最小生成树的算法。
最小生成树的kruskal算法实现
04-27
实现了kruskal的算法，测试可行。
最小生成树Kruskal算法
01-05
编写算法能够建立带权图，并能够用Kruskal算法求该图的最小生成树。最小生成树能够选择图上的任意一点做根结点。最小生成树输出采用顶点集合和边的集合的形式。
算法笔记-Kruskal重构树
m0_53899788的博客
10-19 314
Kruskal重构树
Kruskal重构树入门
最新发布
mygrn的博客
07-28 168
Kruskal算法是一种求图上最小生成树的算法具体流程是：1.将图上所有边按边权由小到大排序2.每次取出一条边，若边的两个端点未被连接，则新增一条边3.重复操作2，直至图上所有点联通。
acm-Kruskal重构树学习笔记
qq_30361651的博客
09-30 378
引言 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重构树
AC__dream的博客
03-05 392
用处：求有关两点间路径最大边权最小值和最小边权最大值问题 以求两点路径最大边权最小值为例（n个节点）（以下性质及方法均只适用于按照求两点路径最大边权最小值的方法所重构的树） 性质： 每两个点的最近公共祖先的权值就是两点间路径最大边权最小值（边权从小到大排序） 重构得到的图是一个大根堆（前提原来图是连通的） 重构之后的树是2*n-1个节点，且节点编号为1~n的节点没有点权，而n+1~2*n-1的节点具有点权且点权为原来图中最小生成树的边权 方法： 首先先将图中所有边权从小到大排序，选取一条边，如
【日志】Kruskal重构树
本居小铃的博客
03-09 243
Kruskal重构树
Codeforces Round #809 (Div. 2)（6/6）（Kruskal重构树）
eyuhaobanga的博客
07-25 152
Codeforces Round #809 (Div. 2)
Kruskal重构树学习笔记
袋鼠与蒟蒻
07-24 9895
Kruskal重构树 前几天做noi2018的同步赛时，Day1T1我就拿了离线+树剖的80分暴力。 后来就知道有Kruskal重构树这样一种新科技(14年以前就有了) 什么是Kruskal重构树 简单来讲，就是在Kruskal算法进行的过程中，我们把最小生成树的边权改为点权。 这样，原树的节点个数变成2n-1个，并且有着许多有趣的性质。 Kruskal重构树的性质 1.根据我们构造...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值