线段树优化连边
有的时候,
对于一个点,向一段区间内所有点连边
边数是\(O(n^2)\)的
复杂度爆炸
于是就有了线段树优化连边......
线段树优化连边,利用到线段树的思想.
对于每个区间,新建一个节点,向子区间递归连边.
这样,当连向一段区间,就等于连向了所有其子节点
十分抽象.
看几道例题
[luogu 5025] [SNOI2017]炸弹
题解
暴力做法很显然
连完边后跑\(tarjan + DAG dp\)
然后,线段树优化连边
Code
#include<bits/stdc++.h>
#define LL long long
#define RG register
using namespace std;
template<class T> inline void read(T &x) {
x = 0; RG char c = getchar(); bool f = 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
x = f ? -x : x;
return ;
}
template<class T> inline void write(T x) {
if (!x) {putchar(48);return ;}
if (x < 0) x = -x, putchar('-');
int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}
const int N = 500010, M = 20000010, Mod = 1000000007;
int n, num[N << 2], isleaf[N << 2], tot;
#define ls (rt << 1)
#define rs (rt << 1 | 1)
struct node {
int to, nxt;
}g[M];
int last[N << 2], gl, L[N], R[N];
void add(int x, int y) {
g[++gl] = (node) {y, last[x]};
last[x] = gl;
return ;
}
struct Segment_Tree {
void build(int rt, int l, int r) {
tot = max(tot, rt);
if (l == r) {
isleaf[rt] = 1;
num[l] = rt;
return ;
}
int mid = (l + r) >> 1;
add(rt, ls); add(rt, rs);
build(ls, l, mid), build(rs, mid + 1, r);
return ;
}
void link(int rt, int l, int r, int L, int R, int id) {
if (L <= l && r <= R) {
add(id, rt);
return ;
}
int mid = (l + r) >> 1;
if (L <= mid) link(ls, l, mid, L, R, id);
if (R > mid) link(rs, mid + 1, r, L, R, id);
return ;
}
}T;
LL x[N], y[N];
int dfn[N << 2], low[N << 2], cnt, color[N << 2], C, val[N << 2];
bool in[N << 2];
stack<int> s;
void tarjan(int u) {
dfn[u] = low[u] = ++cnt;
in[u] = 1;
s.push(u);
for (int i = last[u]; i; i = g[i].nxt) {
int v = g[i].to;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
}
else if (in[v]) low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
C++;
while (in[u]) {
color[s.top()] = C;
val[C] += isleaf[s.top()];
in[s.top()] = 0;
s.pop();
}
}
return ;
}
int dp[N << 2];
vector<int> G[N << 2];
inline int dfs(int u) {
if (dp[u]) return dp[u];
dp[u] = val[u];
for (int i = 0; i < (int) G[u].size(); i++) {
int v = G[u][i];
dp[u] += dfs(v);
}
return dp[u];
}
int main() {
read(n);
for (int i = 1; i <= n; i++)
read(x[i]), read(y[i]);
for (int i = 1; i <= n; i++) {
L[i] = lower_bound(x + 1, x + 1 + n, x[i] - y[i]) - x;
R[i] = upper_bound(x + 1, x + 1 + n, x[i] + y[i]) - x - 1;
}
T.build(1, 1, n);
for (int i = 1; i <= n; i++)
T.link(1, 1, n, L[i], R[i], num[i]);
for (int i = 1; i <= tot; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= tot; i++)
for (int j = last[i]; j; j = g[j].nxt) {
int v = g[j].to;
if (color[i] == color[v]) continue;
G[color[i]].push_back(color[v]);
}
for (int i = 1; i <= C; i++) {
sort(G[i].begin(), G[i].end());
G[i].erase(unique(G[i].begin(), G[i].end()), G[i].end());
}
for (int i = 1; i <= C; i++)
if (!dp[i])
dfs(i);
LL ans = 0;
for (int i = 1; i <= n; i++)
(ans += 1ll * i * dp[color[num[i]]]) %= Mod;
write(ans);
return 0;
}
看完这题后,应该对于线段树优化连边有了个大概..
然后看一道稍微难一点的.
BZOJ3073 Journeys
权限题警告
题目描述
Seter建造了一个很大的星球，他准备建造N个国家和无数双向道路。N个国家很快建造好了，用1..N编号，但是他发现道路实在太多了，他要一条条建简直是不可能的！于是他以如下方式建造道路：(a,b),(c,d)表示，对于任意两个国家x,y，如果a<=x<=b,c<=y<=d，那么在xy之间建造一条道路。Seter保证一条道路不会修建两次，也保证不会有一个国家与自己之间有道路。 Seter好不容易建好了所有道路，他现在在位于P号的首都。Seter想知道P号国家到任意一个国家最少需要经过几条道路。当然，Seter保证P号国家能到任意一个国家。
注意：可能有重边
题解
这回有两个区间了怎么办?
不能对于(a,b)每个点连区间吧..
我们弄两棵线段树
对于每个点,一棵树管出边,另一棵管入边
线段树里面的边长度都为\(0\)
两棵线段树对应点之间连\(0\)的边
至于为什么要两棵线段树,
想想第一题,我们线段树之中的边只能控制一个方向(如果双向边,那两点距离不就变成\(0\)了)?
因为第一题是点连向区间,所以只要一个线段树来控制区间
然而,这题是区间连向区间
所以我们需要两棵线段树
然后考虑加边,
因为两个区间都被分成了很多段
我们不能每段两两连边
那么我们可以新建一个节点来整合区间
具体实现看代码
Code
#include<bits/stdc++.h>
#define LL long long
#define RG register
using namespace std;
template<class T> inline void read(T &x) {
x = 0; RG char c = getchar(); bool f = 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
x = f ? -x : x;
return ;
}
template<class T> inline void write(T x) {
if (!x) {putchar(48);return ;}
if (x < 0) x = -x, putchar('-');
int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}
int n, m, p, tot;
const int N = 2000010;
struct node {
int ls, rs;
}t[N << 2];
struct Graph {
int to, nxt, w;
}g[N * 5];
int last[N << 1], gl, pos[N];
inline void add(int x, int y, int z) {
g[++gl] = (Graph) {y, last[x], z};
last[x] = gl;
}
inline void build1(int &rt, int l, int r) {
rt = ++tot;
if (l == r) {
pos[l] = rt;
return ;
}
int mid = (l + r) >> 1;
build1(t[rt].ls, l, mid), build1(t[rt].rs, mid + 1, r);
add(t[rt].ls, rt, 0), add(t[rt].rs, rt, 0);
return ;
}
inline void build2(int &rt, int l, int r) {
rt = ++tot;
if (l == r) {
add(rt, pos[l], 0);
return ;
}
int mid = (l + r) >> 1;
build2(t[rt].ls, l, mid), build2(t[rt].rs, mid + 1, r);
add(rt, t[rt].ls, 0), add(rt, t[rt].rs, 0);
return ;
}
inline void link1(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) {
add(rt, tot, 1);
return ;
}
int mid = (l + r) >> 1;
if (L <= mid)
link1(t[rt].ls, l, mid, L, R);
if (R > mid)
link1(t[rt].rs, mid + 1, r, L, R);
return ;
}
inline void link2(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) {
add(tot, rt, 1);
return ;
}
int mid = (l + r) >> 1;
if (L <= mid)
link2(t[rt].ls, l, mid, L, R);
if (R > mid)
link2(t[rt].rs, mid + 1, r, L, R);
return ;
}
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > >q;
int dis[N << 1];
bool vis[N << 1];
void dijkstra() {
memset(dis, 127/3, sizeof(dis));
dis[pos[p]] = 0;
q.push(make_pair(0, pos[p]));
while (!q.empty()) {
while (vis[q.top().second] && !q.empty()) q.pop();
if (q.empty()) break;
int u = q.top().second; q.pop();
vis[u] = 1;
for (RG int i = last[u]; i; i = g[i].nxt) {
int v = g[i].to;
if (dis[v] > dis[u] + g[i].w) {
dis[v] = dis[u] + g[i].w;
q.push(make_pair(dis[v], v));
}
}
}
return ;
}
int main() {
read(n), read(m), read(p);
int rt1, rt2;
rt1 = rt2 = 0;
build1(rt1, 1, n); build2(rt2, 1, n);
while (m--) {
int a, b, c, d;
read(a), read(b), read(c), read(d);
++tot; link1(rt1, 1, n, a, b); link2(rt2, 1, n, c, d);
++tot; link1(rt1, 1, n, c, d); link2(rt2, 1, n, a, b);
}
dijkstra();
for (int i = 1; i <= n; i++)
printf("%d\n", dis[pos[i]] / 2);
return 0;
}
