20200918 专题：Kruskal重构树

最新推荐文章于 2023-07-12 07:07:51 发布
最新推荐文章于 2023-07-12 07:07:51 发布
阅读量194 收藏
点赞数
分类专栏： 专题 -----图论-----
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongkongreporter/article/details/108665832
版权

总览：

处理当一个图只能经过边权大于（小于）某个权值的边的问题
对图做最小生成树，当合并两个点集时，建立新结点，并将联通两个点集的最小边权作为点权，将这个点作为原来两个点集的父亲在这里插入图片描述
树的节点树为 2 n − 1 2n-1 2n−1
树上的叶节点为原图的点，一个非叶节点代表原图中一个最小生成树
原图任意两个点路径上边权的最大值为它们树上的 LCA 的点权
以每个节点为起点，走边权不超过一定值的边所能到达的点集为树上某一结点的子树，dfn 连续

T1 P4768 [NOI2018]归程

思路：
先跑最短路，然后建树，节点上维护子树叶节点的 m i n d i s min_{dis} mindis​，查询就倍增到能到达的最浅节点，然后输出 m i n d i s min_{dis} mindis​

代码：

#include <bits/stdc++.h>
using namespace std;

#define re register
#define LL long long
typedef unsigned int uint;
typedef unsigned long long ull;
#define pb push_back
#define mp make_pair

namespace IO {
char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                                 \
  (_p1 == _p2 &&                                                             \
           (_p2 = (_p1 = _buf) + fread(_buf, 1, 1 << 21, stdin), _p1 == _p2) \
       ? EOF                                                                 \
       : *_p1++)
inline int in() {
  int s = 0, f = 1;
  char x = ch();
  for (; x < '0' || x > '9'; x = ch())
    if (x == '-') f = -1;
  for (; x >= '0' && x <= '9'; x = ch()) s = (s * 10) + (x & 15);
  return f == 1 ? s : -s;
}
char buf_[1 << 21];
int p1_ = -1;
inline void flush() {
  fwrite(buf_, 1, p1_ + 1, stdout);
  p1_ = -1;
}
inline void pc(char x) {
  if (p1_ == (1 << 21) - 1) flush();
  buf_[++p1_] = x;
}
inline void out(int x) {
  char k[30];
  int pos = 0;
  if (!x) {
    pc('0');
    return;
  }
  if (x < 0) {
    pc('-');
    x = -x;
  }
  while (x) {
    k[++pos] = (x % 10) | 48;
    x /= 10;
  }
  for (int i = pos; i; i--) pc(k[i]);
  return;
}
inline void out(string x) {
  int k = x.size();
  for (int i = 0; i < k; i++) pc(x[i]);
}
}  // namespace IO
using namespace IO;

const int A = 5e5 + 5;
const int logA = 20;
const int INF = 1e9 + 5;
int n, m;
int dis[A], val[A];
vector<int> rt;

namespace Tree {
int head[A], tot_road;
struct Road {
  int nex, to;
} road[2 * A];
inline void edge(int x, int y) {
  road[++tot_road] = {head[x], y}, head[x] = tot_road;
}

int lg[A];
int dep[A], st[A][logA];
inline void DFS(int x) {
  for (int i = 1; i <= lg[dep[x]]; i++) st[x][i] = st[st[x][i - 1]][i - 1];
  for (int y = head[x]; y; y = road[y].nex) {
    int z = road[y].to;
    dep[z] = dep[x] + 1;
    st[z][0] = x;
    DFS(z);
    dis[x] = min(dis[x], dis[z]);
  }
  return;
}

inline int qurey(int x, int v) {
  for (int i = lg[dep[x]]; ~i; i--)
    if (val[st[x][i]] > v) x = st[x][i];
  return dis[x];
}

inline void work() {
  lg[1] = 0;
  for (int i = 2; i <= (n << 1); i++) lg[i] = lg[i >> 1] + 1;
  for (int i = 0; i < rt.size(); i++) {
    dep[rt[i]] = 1;
    DFS(rt[i]);
  }
  int Q = in(), K = in(), S = in(), ans = 0;
  while (Q--) {
    int x = in(), y = in();
    x = (x + K * ans - 1) % n + 1, y = (y + K * ans) % (S + 1);
    out(ans = qurey(x, y)), pc('\n');
  }
  return;
}

}  // namespace Tree

namespace T {
int head[A], tot_road;
struct Road {
  int nex, to, w;
} road[2 * A];
inline void edge(int x, int y, int w) {
  road[++tot_road] = {head[x], y, w}, head[x] = tot_road;
}

struct node {
  int x, y, w;
  inline friend bool operator<(node u, node v) { return u.w > v.w; }
} p[A];

int ex[A];
inline void djk() {
  for (int i = 1; i <= (n << 1); i++) dis[i] = INF, ex[i] = 0;
  priority_queue<pair<int, int> > q;
  dis[1] = 0;
  q.push(mp(-dis[1], 1));
  while (!q.empty()) {
    int x = q.top().second;
    q.pop();
    if (ex[x]) continue;
    ex[x] = 1;
    for (int y = head[x]; y; y = road[y].nex) {
      int z = road[y].to, w = road[y].w;
      if (dis[z] > dis[x] + w) {
        dis[z] = dis[x] + w;
        q.push(mp(-dis[z], z));
      }
    }
  }
  return;
}

int all;
int f[A];
inline int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
inline void build() {
  sort(p + 1, p + 1 + m);
  all = n;
  for (int i = 1; i <= (n << 1); i++) f[i] = i;
  for (int i = 1; i <= m; i++) {
    int x = p[i].x, y = p[i].y;
    if (find(x) == find(y)) continue;
    val[++all] = p[i].w;
    Tree::edge(all, find(x)), Tree::edge(all, find(y));
    f[find(x)] = all, f[find(y)] = all;
  }
  for (int i = 1; i <= all; i++)
    if (find(i) == i) rt.pb(i);
  return;
}

inline void work() {
  n = in(), m = in();
  for (int i = 1; i <= m; i++) {
    int u = in(), v = in(), l = in(), a = in();
    edge(u, v, l), edge(v, u, l);
    p[i].x = u, p[i].y = v, p[i].w = a;
  }
  djk();
  build();
  return;
}
}  // namespace T

inline void clean() {
  T::tot_road = 0;
  memset(T::head, 0, sizeof(T::head));
  rt.clear();
  Tree::tot_road = 0;
  memset(Tree::head, 0, sizeof(Tree::head));
  memset(Tree::st, 0, sizeof(Tree::st));
  return;
}

signed main() {
  int T = in();
  while (T--) {
    clean();
    T::work();
    Tree::work();
  }
  flush();
  return 0;
}

T2 P4197 Peaks

思路：
建树后就是查询子树内第 k k k 高的高度
在 dfn 序上维护主席树即可

代码：

#include <bits/stdc++.h>
using namespace std;

#define re register
#define LL long long
typedef unsigned int uint;
typedef unsigned long long ull;
#define pb push_back
#define mp make_pair

namespace IO {
char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                                 \
  (_p1 == _p2 &&                                                             \
           (_p2 = (_p1 = _buf) + fread(_buf, 1, 1 << 21, stdin), _p1 == _p2) \
       ? EOF                                                                 \
       : *_p1++)
inline int in() {
  int s = 0, f = 1;
  char x = ch();
  for (; x < '0' || x > '9'; x = ch())
    if (x == '-') f = -1;
  for (; x >= '0' && x <= '9'; x = ch()) s = (s * 10) + (x & 15);
  return f == 1 ? s : -s;
}
char buf_[1 << 21];
int p1_ = -1;
inline void flush() {
  fwrite(buf_, 1, p1_ + 1, stdout);
  p1_ = -1;
}
inline void pc(char x) {
  if (p1_ == (1 << 21) - 1) flush();
  buf_[++p1_] = x;
}
inline void out(int x) {
  char k[30];
  int pos = 0;
  if (!x) {
    pc('0');
    return;
  }
  if (x < 0) {
    pc('-');
    x = -x;
  }
  while (x) {
    k[++pos] = (x % 10) | 48;
    x /= 10;
  }
  for (int i = pos; i; i--) pc(k[i]);
  return;
}
inline void out(string x) {
  int k = x.size();
  for (int i = 0; i < k; i++) pc(x[i]);
}
}  // namespace IO
using namespace IO;

const int A = 5e5 + 5;
const int INF = 1e9 + 5;
const int logA = 20;
int n, m, Q;
int hi[A], val[A], all;
int ex[A];
vector<int> root;

namespace Tree {
int head[A], tot_road;
struct Road {
  int nex, to;
} road[2 * A];
inline void edge(int x, int y) {
  road[++tot_road] = {head[x], y}, head[x] = tot_road;
}
int lg[A], f[A][logA];
int dep[A], sz[A], pos[A], idx[A], ed[A], tot;
struct SGT {
  int ls, rs;
  int num;
} tr[4 * logA * A];
int rt[A], tot_;
inline void insert(int &x, int y, int l, int r, int v) {
  x = ++tot_;
  tr[x] = tr[y];
  tr[x].num++;
  if (l == r) return;
  int mid = (l + r) >> 1;
  if (v <= mid)
    insert(tr[x].ls, tr[y].ls, l, mid, v);
  else
    insert(tr[x].rs, tr[y].rs, mid + 1, r, v);
  return;
}
inline int Kth(int x, int y, int l, int r, int k) {
  if (l == r) return l;
  int mid = (l + r) >> 1;
  int num = tr[tr[y].rs].num - tr[tr[x].rs].num;
  if (k <= num)
    return Kth(tr[x].rs, tr[y].rs, mid + 1, r, k);
  else
    return Kth(tr[x].ls, tr[y].ls, l, mid, k - num);
}
inline void DFS(int x) {
  pos[x] = ++tot, idx[pos[x]] = x;
  for (int i = 1; i <= lg[dep[x]]; i++) f[x][i] = f[f[x][i - 1]][i - 1];
  for (int y = head[x]; y; y = road[y].nex) {
    int z = road[y].to;
    dep[z] = dep[x] + 1;
    f[z][0] = x;
    DFS(z);
    sz[x] += sz[z];
  }
  if (!sz[x]) sz[x] = 1;
  ed[x] = tot;
  return;
}
inline int qurey(int x, int v, int k) {
  for (int i = lg[dep[x]]; ~i; i--)
    if (val[f[x][i]] <= v) x = f[x][i];
  if (sz[x] < k) return -1;
  return Kth(rt[pos[x] - 1], rt[ed[x]], 0, INF, k);
}
inline void work() {
  lg[1] = 0;
  for (int i = 2; i <= all; i++) lg[i] = lg[i >> 1] + 1;
  for (int i = 0; i < root.size(); i++) {
    dep[root[i]] = 1;
    DFS(root[i]);
  }
  for (int i = 1; i <= tot; i++) {
    rt[i] = rt[i - 1];
    if (hi[idx[i]]) insert(rt[i], rt[i - 1], 0, INF, hi[idx[i]]);
  }
  while (Q--) {
    int x = in(), v = in(), k = in();
    out(qurey(x, v, k)), pc('\n');
  }
  return;
}
}  // namespace Tree

namespace T {
struct Road {
  int x, y, w;
  inline friend bool operator<(Road u, Road v) { return u.w < v.w; }
} p[A];
int f[A];
inline int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
inline void work() {
  n = in(), m = in(), Q = in();
  for (int i = 1; i <= n; i++) hi[i] = in();
  for (int i = 1; i <= m; i++) p[i].x = in(), p[i].y = in(), p[i].w = in();
  sort(p + 1, p + 1 + m);
  for (int i = 1; i <= (n << 1); i++) f[i] = i;
  all = n;
  for (int i = 1; i <= m; i++) {
    int x = p[i].x, y = p[i].y;
    if (find(x) == find(y)) continue;
    val[++all] = p[i].w;
    Tree::edge(all, find(x)), Tree::edge(all, find(y));
    f[find(x)] = f[find(y)] = all;
  }
  val[0] = INF;
  for (int i = 1; i <= n; i++)
    if (!ex[find(i)]) {
      root.pb(find(i));
      ex[find(i)] = 1;
    }
  return;
}
}  // namespace T

signed main() {
  T::work();
  Tree::work();
  flush();
  return 0;
}
ハルカナソラヘ
关注
专栏目录
【学习笔记】kruskal 重构树
vectorwyx的博客
01-04 414
写这篇博客主要是因为oi-wiki上写得太精简了……我对着这几段话弄了一晚上才搞明白/kk 前置知识：最小生成树，与 kruskal 算法 在进行 kruskal 算法时，我们会将当前边的两个端点 xxx 和 yyy 所在的树合并成一棵，即连一条由 xxx 的树根指向 yyy 的树根的边，写成代码就是f[xx]=yy（假设 xxxxxx 和 yyyyyy 分别为 xxx 和 yyy 对应的根结点）。而 kruskal 重构树则是在合并时引入一个新的结点 nodnodnod，用 nodnodnod 作为 x
【模板】Kruskal重构树
本居小铃的博客
03-09 269
Kruskal 重构树模板 知识点 Kruskal 算法 LCA（倍增LCA或者Trajan算法） 模板 这里使用用倍增LCA。例题为：P1967 火车运输。 除了Kruskal求生成树含在main函数里面，其他都已经用结构体封装好。 #include <bits/stdc++.h> using namespace std; #define all(x) std::begin(x), std::end(x) const int MAXN = 1e6 + 10; int n, m; vec
Kruskal重构树
weixin_30575309的博客
09-19 81
Kruskal重构树是基于Kruskal算法的，典型的应用是求两点之间边权最大值的最小值。 首先，我们运行Kruskal算法，将边从小到大排列，在运行过程中，每加入一条边，就建立一个节点u，权值为边权的权值w，然后所连两点a,b所在子树的根节点作为它的儿子，就像这样： 由于边是按升序加入的，所以这棵二叉树为大根堆，如果需要求两点之间在生成树中路径上最大权值，那么求两点LCA就好了 ...
Kruskal重构树（货车运输）
weixin_33932129的博客
12-09 133
。。。 和Kruskal生成树一样 本来是u，v连一条f的边 现在变成新建一个点，点权为f，u v都像它连无边权的边 （实际上应该是u的根和v的根） 这样树有一些性质： 1.二叉树 2.原树与新树两点间路径上边权(点权)的最大（最小）值相等 3.子节点的边权（大于等于）小于等于父亲节点 4.原树中两点之间路径上边权的最大（最小）值等于新树上两点的LCA的点权 # incl...
kruskal重构树
最新发布
weixin_55851276的博客
07-12 1036
kruskal重构树就是在进行kruskal算法时将边权改成点权，构造出一棵具有2n−1个点的树形结构。
KWT:Kruskal Wallis测试代码
04-01
在统计学中，克鲁斯卡尔-华利斯检验（Kruskal-Wallis H test），也称为非参数的Mann-Whitney-U检验，是一种用于比较三个或更多独立样本总体的中位数是否相等的非参数检验方法。这种方法适用于数据不满足正态分布或...
Kruskal 重构树 学习笔记
cryozwq的博客
08-19 213
算法介绍 Kruskal 重构树就是在 Kruskal 算法过程中重新建出了一棵树，这棵树具有一些优美的性质可以解决一类问题，下面就详细叙述一下： 首先复习一下什么是 Kruskal 算法，本质上来说这是一种贪心算法，用于解决最小生成树的问题，把所有边权由小到大排序，用并查集维护连通性，若当前边 (u,v)(u,v)(u,v) 不联通，就把当前边加入到最小生成树中。 下面说说什么是 Kruskal 重构树，在 krusakl 算法过程中，每当一条边 (u,v)(u,v)(u,v) 被加入最小生成树，令 gu
Kruskal 重构树
Fighting_Peter的博客
10-19 454
Kruskal重构树
kruscal重构树
czn的博客
03-27 426
因为NOI2018第一题考了这个算法，所以就来学一下。 简介 kruscal重构树从名字上来看就一定和kruscal有联系，那么这个数据结构到底是怎么构成的呢？、 这个数据结构与正常的kruscal有一个相同的方法来做题，那么就是使用并差集，那么是如何将题目中的两点和之间连的边的边权存成并差集呢？难道是带权并差集吗？然而使用带权并差集会超时，那么我们就需要一个新的数据结构叫做kruscal重构树。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值