线段树优化建图 学习笔记

最新推荐文章于 2022-04-20 21:10:04 发布
最新推荐文章于 2022-04-20 21:10:04 发布
阅读量118 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/SGCollin/p/9949287.html
版权

\(\\\)

适用情况

当点数很多，并且边集以区间形式 \((\) 点 \(\to\) 区间 \(/\) 区间 \(\to\) 点 \()\) 给出时，我们发现强行连边复杂度太大，考虑如何维护同一个子区间的连边，容易想到线段树。

\(\\\)

优化思路

我们先考虑 点 \(\to\) 区间 连边的部分。

考虑建图的复杂度真正体现在哪里。

如果所有的被连边区间不交，那么总复杂度是对的。

所以真正建图的复杂度，产生在被连边区间相交的部分，尤其是一个同一个区间被多个点连边，那么我们每一个都要产生区间长度的代价。

那么有一个思路，如果有一个区间被多次连边，那么不妨我们建立这个区间的一个代表节点。

首先预处理的时候将这个代表节点连向区间里的每一个节点，边权为 \(0\) ，就代表了连向代表节点的每一条边都连向了区间里的每一个节点，然后都每次都将边连向这个代表节点即可。

\(\\\)

建图过程 (点 \(\to\) 区间)

但是注意到这种区间并不是很好找，这种找区间的方法并不是具有很强的普适性。

我们知道线段树的每一个节点维护的是一个固定的区间，线段树的区间操作是 \(log\) 的。

回忆区间加的过程，如果一个节点的代表区间被完全覆盖，那么我们会在这个节点上打标记，等到需要的时候再下传。这体现了一种代表的关系，即区间共有的性质我可以只标记在代表这个区间的节点上。

于是有了一个思路，如果要从一个点连向一个区间，那么可以像区间加那样，把这个点向完全覆盖的区间连边。

也就是说，在区间连边时，在线段树上每找到一个完全覆盖的节点，就将出发点向这个区间的代表节点连边。

同样的，我们先考虑预处理。

一个节点被连边，代表这个节点的 子树 都可以到达。

之所以强调子树，而不是强调区间里的每一个节点，因为我们预处理的边只会向下 连一层 。

只连下一层的边数量级是 \(O(2N)\) ，而连向区间里的每一个节点显然每一层都是 \(O(N)\) ，总的边的数量级就是 \(O(Nlog_2N)\) ，边的级别显然大了很多，并且也不符合线段树的关系定义。

一个 \(8\) 个节点的线段树预处理之后的连边情况如图所示。图中边权全部为 \(0\)。

5be9808a3cb4b.png

\(\\\)

然后一条连边就可以按照我们说的那样了，找到对应的区间就好。

假如 \(8\) 号点要向区间 \([2,5]\) 连边，最后会是蓝边的样子（边权就省略了）：

5be9806ebbcd8.png

\(\\\)

建图过程 (区间 \(\to\) 点)

发现原来线段树的区间传递关系并不对了。

如果我们找到了每一段区间，直接向指向的点连边，子树内真正建边的点并没有连出这一条边。

如图，如果要区间 \([5,8]\) 向 \(T\) 连边，蓝框框起来的点并没有真正向 \(T\) 连边。

因为建树的时候绿色边的方向是向区间内传递的。

5be9804a1c26d.png

\(\\\)

很容易想到反向再建一棵树。显然叶节点是相同的，所以两棵树会共用叶节点。

5be97fb9ec90a.png

\(\\\)

此时在这颗倒着的树上传递关系就变为，一个节点连了出边，那么他所代表的区间里所有节点都向外连了一条出边。

同理，这些绿色的边的边权都是 \(0\) 。

关于正确性，显然更大的区间并不会到达小区间，所以连边不用担心范围超界。

此时我们就可以在倒着的树上找所有的区间，然后连出边就可以了。

\(\\\)

实现

其实做的时候共用叶节点并不好写（至少对于我这种封装数据结构的就很不友善）。

每个线段树节点维护一个 \(p\) 代表这个节点的编号，显然两棵树的叶节点对应的部分编号相同，其他部分两棵树的每一个节点都要重新编号。

首先是建树部分，注意两棵树的初始化边的方向并不同。

void build_in(ll &rt,ll l,ll r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build_in(c[rt].ls,l,mid);
    build_in(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[rt].p,c[c[rt].ls].p,0);
    add(c[rt].p,c[c[rt].rs].p,0);
  }
void build_out(ll &rt,ll l,ll r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build_out(c[rt].ls,l,mid);
    build_out(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[c[rt].ls].p,c[rt].p,0);
    add(c[c[rt].rs].p,c[rt].p,0);
  }

然后 \(updata\) 的时候需要分靠讨论。

如果是 点 \(\to\) 区间 连边，要在第一棵树上找区间，然后向内连入边，也就是出发点向这个节点连边。

inline void updata(ll rt,ll l,ll r,ll L,ll R,ll p,ll w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(p,c[rt].p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

反之要在第二棵树上找区间，然后向外连出边，也就是这个节点向终点连边。

inline void updata(ll rt,ll l,ll r,ll L,ll R,ll p,ll w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(c[rt].p,p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

然后该跑什么图论算法就跑什么图论算法就好了。

\(\\\)

我们以 [ CodeForces 786 B ] Legacy 为例提供一份模板。

#include<cmath>
#include<queue>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 200010
#define gc getchar
#define Rg register
#define mid ((l+r)>>1)
#define inf 900000000000000000ll
using namespace std;
typedef long long ll;

inline ll rd(){
  ll x=0; bool f=0; char c=gc();
  while(!isdigit(c)){if(c=='-')f=1;c=gc();}
  while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
  return f?-x:x;
}

ll n,m,s,cnt,tot,hd[N<<2];

struct edge{ll w,to,nxt;}e[N*10];

inline void add(ll u,ll v,ll w){
  e[++tot].to=v; e[tot].w=w;
  e[tot].nxt=hd[u]; hd[u]=tot;
}

struct segmentin{

  ll root,ptr;

  inline ll newnode(){return ++ptr;}

  struct node{ll ls,rs,p;}c[N<<1];

  void build(ll &rt,ll l,ll r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build(c[rt].ls,l,mid);
    build(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[rt].p,c[c[rt].ls].p,0);
    add(c[rt].p,c[c[rt].rs].p,0);
  }

  inline void updata(ll rt,ll l,ll r,ll L,ll R,ll p,ll w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(p,c[rt].p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

}treein;

struct segmentout{

  ll root,ptr;

  inline ll newnode(){return ++ptr;}

  struct node{ll ls,rs,p;}c[N<<1];

  void build(ll &rt,ll l,ll r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build(c[rt].ls,l,mid);
    build(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[c[rt].ls].p,c[rt].p,0);
    add(c[c[rt].rs].p,c[rt].p,0);
  }

  inline void updata(ll rt,ll l,ll r,ll L,ll R,ll p,ll w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(c[rt].p,p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

}treeout;

bool vis[N<<2];

ll dis[N<<2];

priority_queue<pair<ll,ll> >q;

inline void dij(){
  for(Rg ll i=1;i<=(n<<2);++i) dis[i]=inf;
  dis[s]=0; q.push(make_pair(0,s));
  while(!q.empty()){
    ll u=q.top().second; q.pop();
    if(vis[u]) continue; vis[u]=1;
    for(Rg ll i=hd[u],v;i;i=e[i].nxt)
      if(dis[v=e[i].to]>dis[u]+e[i].w){
        dis[v]=dis[u]+e[i].w;
        q.push(make_pair(-dis[v],v));
      }
  }
}

int main(){
  cnt=n=rd(); m=rd(); s=rd();
  treein.build(treein.root,1,n);
  treeout.build(treeout.root,1,n);
  for(Rg ll i=1,op,u,l,r,w;i<=m;++i){
    op=rd();
    if(op==1){
      l=rd(); r=rd();
      w=rd(); add(l,r,w);
    }
    else if(op==2){
      u=rd(); l=rd(); r=rd(); w=rd();
      treein.updata(treein.root,1,n,l,r,u,w);
    }
    else{
      u=rd(); l=rd(); r=rd(); w=rd();
      treeout.updata(treeout.root,1,n,l,r,u,w);
    }
  }
  dij();
  for(Rg ll i=1;i<=n;++i)
    printf("%lld ",dis[i]<inf?dis[i]:-1);
  return 0;
}

\(\\\)

一道例题

一张 \(N\) 个点的 无向图 ，边以以下 \(M\) 条信息的形式给出：

  • \(l_1\ r_1\ l_2\ r_2\) 代表区间 \([l_1,r_1]\) 内的每一个点与区间 \([l_2,r_2]\) 内的每一个点之间都有一条长度为 \(1\) 的无向边。

求 \(S\) 点的单源最短路，保证图连通。

  • \(N\le 5\times10^5,M\le 10^5,1\le l_1,l_2,r_1,r_2\le N\)

\(\\\)

就是把问题放到了区间向区间连边上。

朴素的想法是两侧都找出对应的若干区间，然后枚举两侧的每一个区间构成的 \(pair\) ，然后对应连边。

实际上并不需要这样。

我们对每一条信息都单独开出来一个转移节点，然后就变成了 区间 \(\to\) 点和 点 \(\to\) 区间的问题了。

但是双向边不能共用一个转移节点。因为这样其实上在 \([l_1,r_1]\) 内的每个点之间都连了一条长度为 \(2\) 的边。

实际做的时候，对每一个单向边都开一个转移节点，然后出边边权都设为 \(0\) ，入边边权都设为 \(1\) 就可以了。

还有一个比较妙的方法，是出入边权都设为 \(1\) 然后最短路的答案除以 \(2\) ，也是可以的。

\(\\\)

n#include<cmath>
#include<queue>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 1000010
#define M 4000010
#define gc getchar
#define Rg register
#define mid ((l+r)>>1)
using namespace std;

inline int rd(){
  int x=0; bool f=0; char c=gc();
  while(!isdigit(c)){if(c=='-')f=1;c=gc();}
  while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
  return f?-x:x;
}

int n,m,s,cnt,tot,hd[N<<3];

struct edge{int w,to,nxt;}e[M<<1];

inline void add(int u,int v,int w){
  e[++tot].to=v; e[tot].w=w;
  e[tot].nxt=hd[u]; hd[u]=tot;
}

struct segmentin{

  int root,ptr;

  inline int newnode(){return ++ptr;}

  struct node{int ls,rs,p;}c[N<<1];

  void build(int &rt,int l,int r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build(c[rt].ls,l,mid);
    build(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[rt].p,c[c[rt].ls].p,0);
    add(c[rt].p,c[c[rt].rs].p,0);
  }

  void updata(int rt,int l,int r,int L,int R,int p,int w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(p,c[rt].p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

}treein;

struct segmentout{

  int root,ptr;

  inline int newnode(){return ++ptr;}

  struct node{int ls,rs,p;}c[N<<1];

  void build(int &rt,int l,int r){
    rt=newnode();
    if(l==r){c[rt].p=l;return;}
    build(c[rt].ls,l,mid);
    build(c[rt].rs,mid+1,r);
    c[rt].p=++cnt;
    add(c[c[rt].ls].p,c[rt].p,0);
    add(c[c[rt].rs].p,c[rt].p,0);
  }

  void updata(int rt,int l,int r,int L,int R,int p,int w){
    if(l>R||r<L) return;
    if(l>=L&&r<=R){add(c[rt].p,p,w);return;}
    if(L<=mid) updata(c[rt].ls,l,mid,L,R,p,w);
    if(R>mid) updata(c[rt].rs,mid+1,r,L,R,p,w);
  }

}treeout;

int dis[N<<3];

bool vis[N<<3];

priority_queue<pair<int,int> >q;

inline void dij(){
  memset(dis,0x3f,sizeof(dis));
  dis[s]=0; q.push(make_pair(0,s));
  while(!q.empty()){
    int u=q.top().second; q.pop();
    if(vis[u]) continue; vis[u]=1;
    for(Rg int i=hd[u],v;i;i=e[i].nxt)
      if(dis[v=e[i].to]>dis[u]+e[i].w){
        dis[v]=dis[u]+e[i].w;
        q.push(make_pair(-dis[v],v));
      }
  }
}

int main(){
  cnt=n=rd(); m=rd(); s=rd();
  treein.build(treein.root,1,n);
  treeout.build(treeout.root,1,n);
  for(Rg int i=1,l1,r1,l2,r2;i<=m;++i){
    ++cnt;
    l1=rd(); r1=rd();
    l2=rd(); r2=rd();
    treein.updata(treein.root,1,n,l1,r1,cnt,1);
    treein.updata(treein.root,1,n,l2,r2,cnt,1);
    treeout.updata(treeout.root,1,n,l1,r1,cnt,1);
    treeout.updata(treeout.root,1,n,l2,r2,cnt,1);
  }
  dij();
  for(Rg int i=1;i<=n;++i) printf("%d\n",dis[i]/2);
  return 0;
}

转载于:https://www.cnblogs.com/SGCollin/p/9949287.html

Angela㐅cc
关注
线段树优化建图学习笔记
Zbr162的博客
07-19 845
文章目录$线段树优化建图的作用$$问题$$线段树优化建图的实现$$线段树优化建图的相关代码$1. $建图$2. $点\rightarrow区间 连边$3. $区间\rightarrow点 连边$ 线段树优化建图的作用线段树优化建图的作用线段树优化建图的作用 问题问题问题 有 NNN 个节点, 执行 MMM 次以下连边操作, 倩输出以 sss 为起点的单源最短路: a→ba \right...
P1816 忠诚
NOIP提高组日志
08-20 195
https://www.luogu.org/problem/P1816 #include <algorithm> #include <iostream> #include <cstring> #include <cstdio> #include <queue> #include <stack> #include <cma...
线段树优化建图
andyc_03的博客
08-01 326
考虑这样一个问题： 有N()个节点的完全图，其中有M()条边的边权是a，其余边的边权为b，求这样一张图上的最短路 暴力连边一定是不行的 考虑到它只有两种边权，也就是说有很多相邻节点的边权是一样的，相当于对区间连边，这时，就可以用到线段树来解决了 首先建造一个1-N的线段树，每条边都是0 然后，对于M条边权为a的边，我们可以一条一条的与线段树的叶子节点连边 对于其余的节点，我们可以进行区间连边 然后在这样一个图上跑最短路即可 ...
2018.06.27 NOIP模拟 节目（支配树+可持久化线段树）
苟为蒟蒻又何妨
10-11 728
题目背景 SOURCE：NOIP2015-GDZSJNZX（难） 题目描述 学校一年一度的学生艺术节开始啦！在这次的艺术节上总共有 N 个节目，并且总共也有 N 个舞台供大家表演。其中第 i 个节目的表演时间为第 i 个单位时间，表演的舞台为 Ai ，注意可能有多个节目使用同一个舞台。作为 Tom 的忠实粉丝之一的 Alice，当然要来逛一下啦，顺便看一下能不能要到 Tom 的签名。 Al...
学习笔记(OI)
qq_43589598的博客
12-06 389
虽迟但到 #1.树上问题 这东西一直是我的弱项所以从它开始。 1.树的直径 指树上最长的链。 首先随便找个点DFS找到距离这个点最远的点，然后以这个点为起点DFS找对距离它最远的点，这两个点之间的路径就是树的直径 code： const int N = 10000 + 10; int n, c, d[N]; vector<int> E[N]; void dfs(int u, int fa) { for (int v : E[u]) { if (v == fa) continue
学习笔记——拓扑排序
蒟蒻的博客
02-18 735
简介 拓扑排序是将一张有向图的节点进行排序，使得形成的拓扑序满足一个节点的前驱必然在其前面，一个节点的后继必然在其后面。 拓扑排序是根据各个节点的入度来实现的（即该节点前驱的个数）。首先先将入度为0的节点扔进队列里（即没有前驱的节点），每次弹出一个节点，即已经将他排好序，把它从图中拿出来。因为该节点已经从图中拿出来了，因此要遍历该节点的所有后继，将它的所有后继入度减一。此时如果他的某一个后继入度减...
[学习笔记]网络流·最小割题目选讲
女装的你，如此好看！
01-01 725
已经 2 周没写博客了 引入 最小割的概念：给定一个图，含源点 SSS 和汇点 TTT ，每条有向边有容量 选出一些边删掉，使得没有从 SSS 到 TTT 的路径 求选出的边的容量和的最小值 最大流和最小割都是线性规划问题中的一类 最小割可以看成是最大流的对偶问题 定理：最大流 === 最小割 证明 显然最小割不能小于最大流 我们知道，跑完最大流之后，残余网络中没有从 SSS 到 TTT 的...
【模板】线段树优化建图
gyp0205的博客
04-20 990
Problem 三种方案：v to u,v to [l,r],[l,r] to v。 求单源最短路。 Solution 由于存在结点与区间内所有结点间的连边，可以考虑用线段树优化建图。 具体来说维护两个线段树，线段树1表示有向边的终止结点，同时父亲连向儿子权为0；线段树2表示有向边的起始结点，同时儿子连向父亲权为0。两线段树的叶子结点间连无向边权为0（线段树1的叶子结点连向线段树2的叶子结点也可），表示同一结点自己和自己是连通的；对于任意有向边，线段树2连向线段树1，如图： Code #inclu
模板：线段树优化建图
BUG_Creater_jie的博客
09-09 191
前言 百川到海，天下归一 解析 线段树优化建图是用于对一个区间的点连边时的优化方法 建一棵in树一棵出树分别往上和下指即可 大概长这样 （pia的洛谷的照片） 建树 正常动态开点即可 void build(int &k,int l,int r){ tr[k=++tot]=(tree){0,0}; if(l==r){ addline(k,l); return; } build(tr[k].ls,l,mid);build(tr[k].rs,mid+1,r); addline(k,
学习笔记第二十六节：线段树优化建图
Deep_Kevin的娱乐空间
11-08 464
正题       这真是一个神奇的东西。       既然有这个算法，那么就一定有他能解决的题目。       我们以这一题为例：[POI2015]PUS。       给出n个数，m个操作，每次规定l到r中的k个数比这个区间的其他数大，询问是否有解。       简化问题，给出n个数，m个操作，每次规定第a个数比第b个数大。（还规定一些数的值       那么很明显是一个差分约束的问...
线段树优化算法：高效处理区间操作
"线段树是一种高效的数据结构，用于处理区间查询和更新问题。它通过分治策略优化了对大规模数据的处理效率，尤其在解决动态区间统计问题时展现出强大性能。线段树常用于竞赛编程（如ACM/ICPC）和算法设计中，能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值