线段树合并

最新推荐文章于 2023-05-19 11:53:24 发布

_lifehappy_

最新推荐文章于 2023-05-19 11:53:24 发布

阅读量900

点赞数 2

分类专栏：数据结构-线段树

本文链接：https://blog.csdn.net/weixin_45483201/article/details/113058439

版权

数据结构-线段树专栏收录该内容

21 篇文章 0 订阅

订阅专栏

线段树合并

略谈

线段树合并说全来就是动态开点权值线段树合并，所以你需要掌握权值线段树的基本知识以及知道什么是动态开点

对于两个普通权值线段树如果暴力合并的话复杂度将会是 $\log n$ ，更别说是合并 $n$ 棵权值线段树了（炸空间，炸内存），但是在动态开点权值线段树中，这一操作是可以优化为 $\log n$ 的。

具体处理如下：

当这两棵树中有一个已经是空的了，我们只需要把有权值的一部分返回即可。

当合并进行到叶子节点了，我们就需要对叶子节点的权值进行累加，然后再返回。

如果不是上述的两种情况，我们就只需要递归分别处理左右儿子即可。

int merge(int x, int y, int l, int r) {
	if (!x || !y) {
		return x | y;
	}
	if (l == r) {
		maxv[x] += maxv[y];
		return x;
	}
	int mid = l + r >> 1;
	ls[x] = merge(ls[x], ls[y], l, mid);
	rs[x] = merge(rs[x], rs[y], mid + 1, r);
  push_up(x);
  return x;
}

下面是一些线段树合并的题目。

P4556 [Vani有约会]雨天的尾巴 /【模板】线段树合并

由于修改是修改树上的一段，我们可以利用树上差分来实现操作，最后统计数量最多的点。

注意输出的时候一定要特判 $m a x v [r t] = = 0$ ，不能直接写 $a n s [r t] = m a x p [r t]$ 。

因为在树上差分的时候，我们可能会对某些节点进行了不必要的操作，这个时候会有 $m a x p [r t]$ 的错误记录。

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int head[N], to[N << 1], nex[N << 1], cnt = 1;

int n, m, tot, num, root[N], sz[N], fa[N], top[N], dep[N], son[N], ans[N];

int ls[N * 60], rs[N * 60], maxv[N * 60], maxp[N * 60];

void add(int x, int y) {
  to[cnt] = y;
  nex[cnt] = head[x];
  head[x] = cnt++;
}

void dfs1(int rt, int f) {
  fa[rt] = f, dep[rt] = dep[f] + 1, sz[rt] = 1;
  for (int i = head[rt]; i; i = nex[i]) {
    if (to[i] == f) {
      continue;
    }
    dfs1(to[i], rt);
    sz[rt] += sz[to[i]];
    if (!son[rt] || sz[to[i]] > sz[son[rt]]) {
      son[rt] = to[i];
    }
  }
}

void dfs2(int rt, int tp) {
  top[rt] = tp;
  if (!son[rt]) {
    return ;
  }
  dfs2(son[rt], tp);
  for (int i = head[rt]; i; i = nex[i]) {
    if (to[i] == fa[rt] || to[i] == son[rt]) {
      continue;
    }
    dfs2(to[i], to[i]);
  }
}

int lca(int x, int y) {
  while (top[x] != top[y]) {
    if (dep[top[x]] < dep[top[y]]) {
      swap(x, y);
    }
    x = fa[top[x]];
  }
  return dep[x] < dep[y] ? x : y;
}

void push_up(int rt) {
  if (maxv[ls[rt]] >= maxv[rs[rt]]) {
    maxv[rt] = maxv[ls[rt]];
    maxp[rt] = maxp[ls[rt]];
  }
  else {
    maxv[rt] = maxv[rs[rt]];
    maxp[rt] = maxp[rs[rt]];
  }
}

void update(int &rt, int l, int r, int x, int value) {
  if (!rt) {
    rt = ++num;
  }
  if (l == r) {
    maxv[rt] += value;
    maxp[rt] = l;
    return ;
  }
  int mid = l + r >> 1;
  if (x <= mid) {
    update(ls[rt], l, mid, x, value);
  }
  if (x > mid) {
    update(rs[rt], mid + 1, r, x, value);
  }
  push_up(rt);
}

int merge(int x, int y, int l, int r) {
	if (!x || !y) {
		return x | y;
	}
	if (l == r) {
		maxv[x] += maxv[y];
		return x;
	}
	int mid = l + r >> 1;
	ls[x] = merge(ls[x], ls[y], l, mid);
	rs[x] = merge(rs[x], rs[y], mid + 1, r);
  push_up(x);
  return x;
}

void dfs(int rt, int fa) {
  for (int i = head[rt]; i; i = nex[i]) {
    if (to[i] == fa) {
      continue;
    }
    dfs(to[i], rt);
    root[rt] = merge(root[rt], root[to[i]], 1, 100000);
  }
  if (maxv[root[rt]] == 0) {
    ans[rt] = 0;
  }
  else {
    ans[rt] = maxp[root[rt]];
  }
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d %d", &n, &m);
  for (int i = 1; i < n; i++) {
    int x, y;
    scanf("%d %d", &x, &y);
    add(x, y); 
    add(y, x);
  }
  dfs1(1, 0);
  dfs2(1, 1);
  for (int i = 1; i <= m; i++) {
    int x, y, z;
    scanf("%d %d %d", &x, &y, &z);
    int f = lca(x, y), ff = fa[f];
    update(root[x], 1, 100000, z, 1);
    update(root[y], 1, 100000, z, 1);
    update(root[f], 1, 100000, z, -1);
    if (ff) {
      update(root[ff], 1, 100000, z, -1);
    }
  }
  dfs(1, 0);
  for (int i = 1; i <= n; i++) {
    printf("%d\n", ans[i]);
  }
  return 0;
}

E. Lomsat gelral

这题最简单的做法应该是 $dsu\ on\ tree$ ，但是线段树合并同样也具有优秀的复杂度，可以来完成这一题。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1e5 + 10;

int head[N], to[N << 1], nex[N << 1], cnt = 1;

int n, tot, value[N], root[N];

int ls[N * 60], rs[N * 60], maxn[N * 60];

ll ans[N], sum[N * 60];

void push_up(int rt) {
  if (maxn[ls[rt]] > maxn[rs[rt]]) {
    maxn[rt] = maxn[ls[rt]];
    sum[rt] = sum[ls[rt]];
  }
  else if (maxn[rs[rt]] > maxn[ls[rt]]) {
    maxn[rt] = maxn[rs[rt]];
    sum[rt] = sum[rs[rt]];
  }
  else {
    maxn[rt] = maxn[ls[rt]];
    sum[rt] = sum[ls[rt]] + sum[rs[rt]];
  }
}

void update(int &rt, int l, int r, int x, int value) {
  if (!rt) {
    rt = ++tot;
  }
  if (l == r) {
    maxn[rt] += value;
    sum[rt] = x;
    return ;
  }
  int mid = l + r >> 1;
  if (x <= mid) {
    update(ls[rt], l, mid, x, value);
  }
  else {
    update(rs[rt], mid + 1, r, x, value);
  }
  push_up(rt);
}

int merge(int x, int y, int l, int r) {
  if (x == 0 || y == 0) {
    return x | y;
  }
  if (l == r) {
    maxn[x] += maxn[y];
    return x;
  }
  int mid = l + r >> 1;
  ls[x] = merge(ls[x], ls[y], l, mid);
  rs[x] = merge(rs[x], rs[y], mid + 1, r);
  push_up(x);
  return x;
}

void dfs(int rt, int fa) {
  for (int i = head[rt]; i; i = nex[i]) {
    if (to[i] == fa) {
      continue;
    }
    dfs(to[i], rt);
    root[rt] = merge(root[rt], root[to[i]], 1, n);
  }
  update(root[rt], 1, n, value[rt], 1);
  ans[rt] = sum[root[rt]];
}

void add(int x, int y) {
  to[cnt] = y;
  nex[cnt] = head[x];
  head[x] = cnt++;
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d", &value[i]);
  }
  for (int x, y, i = 1; i < n; i++) {
    scanf("%d %d", &x, &y);
    add(x, y);
    add(y, x);
  }
  dfs(1, 0);
  for (int i = 1; i <= n; i++) {
    printf("%lld%c", ans[i], i == n ? '\n' : ' ');
  }
  return 0;
}

P3224 [HNOI2012]永无乡

并查集，加权值线段树上区间查找第 $k$ 大，只不过是并查集要用线段树合并来维护信息，然后把查找第 $k$ 大放到了动态开点线段树上。

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n, m, fa[N], value[N];

int tot, root[N], ls[N * 60], rs[N * 60], sum[N * 60];

int find(int rt) {
  return fa[rt] == rt ? rt : fa[rt] = find(fa[rt]);
}

void push_up(int rt) {
  sum[rt] = sum[ls[rt]] + sum[rs[rt]];
}

void update(int &rt, int l, int r, int x, int value) {
  if (!rt) {
    rt = ++tot;
  }
  if (l == r) {
    sum[rt] += value;
    return ;
  }
  int mid = l + r >> 1;
  if (x <= mid) {
    update(ls[rt], l, mid, x, value);
  }
  if (x > mid) {
    update(rs[rt], mid + 1, r, x, value);
  }
  push_up(rt);
}

int merge(int x, int y, int l, int r) {
  if (x == 0 || y == 0) {
    return x | y;
  }
  if (l == r) {
    sum[x] += sum[y];
    return x;
  }
  int mid = l + r >> 1;
  ls[x] = merge(ls[x], ls[y], l, mid);
  rs[x] = merge(rs[x], rs[y], mid + 1, r);
  push_up(x);
  return x;
}

int find_k_th(int rt, int l, int r, int k) {
  if (sum[rt] < k) {
    return 0;
  }
  if (l == r) {
    return l;
  }
  int mid = l + r >> 1;
  if (k > sum[ls[rt]]) {
    return find_k_th(rs[rt], mid + 1, r, k - sum[ls[rt]]);
  }
  return find_k_th(ls[rt], l, mid, k);
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d %d", &n, &m);
  for (int i = 1, x; i <= n; i++) {
    scanf("%d", &x);
    value[x] = i;
    update(root[i], 1, n, x, 1);
    fa[i] = i;
  }
  for (int i = 1, x, y; i <= m; i++) {
    scanf("%d %d", &x, &y);
    int fx = find(x), fy = find(y);
    if (fx != fy) {
      fa[fx] = fy;
      root[fy] = merge(root[fy], root[fx], 1, n);
    }
  }
  value[0] = -1;
  scanf("%d", &m);
  char op[10];
  for (int i = 1, x, y; i <= m; i++) {
    scanf("%s %d %d", op, &x, &y);
    if (op[0] == 'Q') {
      printf("%d\n", value[find_k_th(root[find(x)], 1, n, y)]);
    }
    else {
      int fx = find(x), fy = find(y);
      if (fx != fy) {
        fa[fx] = fy;
        root[fy] = merge(root[fy], root[fx], 1, n);
      }
    }
  }
  return 0;
}

P3521 [POI2011]ROT-Tree Rotations

逆序对的统计分成了三种

一、在左儿子上。

二、在右儿子上。

三、左右儿子互相产生的。

递归处理，先处理左儿子的逆序对，再处理右儿子的逆序对，这里已经处理好了（一、二）两种情况了，接下来只要处理第三种。

不管左右儿子如何交换，是不会影响（一、二）种情况的逆序对的产生，座所以只要记录第三种情况的最小值，然后累加到答案上即可。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 6e6 + 10;

int ls[N], rs[N], value[N], tot, n;

ll ans, ans1, ans2;

void push_up(int rt) {
  value[rt] = value[ls[rt]] + value[rs[rt]];
}

void update(int &rt, int l, int r, int x, int w) {
  if (!rt) {
    rt = ++tot;
  }
  if (l == r) {
    value[rt] += w;
    return ;
  }
  int mid = l + r >> 1;
  if (x <= mid) {
    update(ls[rt], l, mid, x, w);
  }
  else {
    update(rs[rt], mid + 1, r, x, w);
  }
  push_up(rt);
}

int merge(int x, int y, int l, int r) {
  if (x == 0 || y == 0) {
    return x | y;
  }
  if (l == r) {
    value[x] += value[y];
    return x;
  }
  ans1 += 1ll * value[ls[x]] * value[rs[y]];
  ans2 += 1ll * value[ls[y]] * value[rs[x]];
  int mid = l + r >> 1;
  ls[x] = merge(ls[x], ls[y], l, mid);
  rs[x] = merge(rs[x], rs[y], mid + 1, r);
  push_up(x);
  return x;
}

void dfs(int &x) {
  int cur, ls, rs;
  x = 0;
  scanf("%d", &cur);
  if (!cur) {
    dfs(ls), dfs(rs);
    ans1 = ans2 = 0;
    x = merge(ls, rs, 1, n);
    ans += min(ans1, ans2);
  }
  else {
    update(x, 1, n, cur, 1);
  }
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d", &n);
  int rt = 0;
  dfs(rt);
  printf("%lld\n", ans);
  return 0;
}

_lifehappy_

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
线段树合并

线段树合并略谈线段树合并说全来就是动态开点权值线段树合并，所以你需要掌握权值线段树的基本知识以及知道什么是动态开点对于两个普通权值线段树如果暴力合并的话复杂度将会是nlog⁡nn \log nnlogn，更别说是合并nnn棵权值线段树了（炸空间，炸内存），但是在动态开点权值线段树中，这一操作是可以优化为log⁡n\log nlogn的。具体处理如下：当这两棵树中有一个已经是空的了，我们只需要把有权值的一部分返回即可。当合并进行到叶子节点了，我们就需要对叶子节点的权值进行累加，然后再返回。如果不
复制链接

扫一扫