线段树优化连边

有的时候,

对于一个点,向一段区间内所有点连边

边数是(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
", dis[pos[i]] / 2);
	return 0;
}