2019牛客暑期多校训练营（第八场）E.Explorer

最新推荐文章于 2024-07-17 00:28:28 发布

原创最新推荐文章于 2024-07-17 00:28:28 发布 · 323 阅读

1 ·

CC 4.0 BY-SA版权

线段树同时被 3 个专栏收录

7 篇文章

订阅专栏

搜索

4 篇文章

订阅专栏

并查集

3 篇文章

订阅专栏

本文介绍了一种结合图论、线段树和并查集的算法，用于解决特定图上的路径问题。通过对边的size属性离散化，利用线段树存储边信息，再结合并查集判断连通性，最终通过深度优先搜索（DFS）找到所有可能的size值，使得从起点到终点存在路径。

题意:给你一张有着n个点的图，图上有m条边，每条边有一个属性[l,r]代表只有size在这个区间范围内的才能通过，你在一开始可以喝下一瓶魔法药水，改变自己的size，问你有多少种可能的size使你能从1号点走到n号点。

思路：对size离散化,线段树节点存储size段，按秩合并幷查集判断是否连通，dfs从线段树根节点遍历所有可能到达的路径。

详细操作：

首先我们将题目给出的m条边的size从小到大离散化，根据[l,r]属性找线段树代表[l,r]区间的对应节点，然后push进去，比如离散化之后我有一条边的属性是[1,4]，我就得放到线段树中代表[1,4]的节点中去

如果我们有一条边的属性是[1,3]那么它就得迭代它的l,r，放到对应着区间[1,2],[3,3]的线段树节点里去

所有边都push进线段树节点之后，我们开始从根节点dfs，每次当搜索到叶子节点的时候，我们可以判断1号点是否和n号点在一个集合里边，如果在的话，这个叶子节点所代表的区间段就是可行的size。

显然这种方法是可行的，因为当我们搜索到一个线段树节点的时候，假若这个节点所代表的size是[l,r]，如果我们往[1,l-1],[r,max_r]区间搜索，显然是无法形成通路的，因为size段没有形成交集，所以我们每次dfs走到叶子节点所判断的所有可行size必定就是答案全部的可行size。

至于为什么要走到叶子节点再判断是否size段是否可行，因为我们没有路径压缩，所以每次都找一下1号点和n号点是否连通会爆栈，至于我们为什么没有路径压缩，因为我们的dfs需要进行回退操作，而压缩完之后就无法回退了。

标程代码：

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
#define N 100000 + 5
#define M 524288 + 5
#define ls(x) x << 1
#define rs(x) x << 1 | 1

int n, m, sz, ans, T[N << 1], Fa[N], Height[N];
vector<pair<int, int>> Vec[M];

struct Edge
{
	int a, b, l, r;
	Edge() {}
	Edge(int a, int b, int l, int r) : a(a), b(b), l(l), r(r) {}
}E[N];

void Add(int x, int l, int r, int s, int t, int a, int b)
{
	if (l == s && r == t)
	{
		Vec[x].push_back(make_pair(a, b));
		return ;
	}
	int mid = l + r >> 1;
	if (t <= mid)
		Add(ls(x), l, mid, s, t, a, b);
	else if (s >= mid)	
		Add(rs(x), mid, r, s, t, a, b);
	else Add(ls(x), l, mid, s, mid, a, b), Add(rs(x), mid, r, mid, t, a, b);
}
int Find(int x)
{
	return x == Fa[x] ? x : Find(Fa[x]);
}
struct Record
{
	int u, v, h_v;
	Record(int u, int v, int h_v) : u(u), v(v), h_v(h_v) {}
};
void DFS(int x, int l, int r)
{
	vector<Record> Stack;
	for (int i = 0; i < Vec[x].size(); i ++)
	{
		int a = Find(Vec[x][i].first), b = Find(Vec[x][i].second);
		if (a == b)
			continue;
		if (Height[a] > Height[b])
			swap(a, b);
		Stack.push_back(Record(a, b, Height[b]));
		Fa[a] = b, Height[b] = max(Height[b], Height[a] + 1);
	}
	if (l == r-1)
		ans += (Find(1) == Find(n)) ? T[r] - T[l] : 0;
	else
	{
		int mid = l + r >> 1;
		DFS(ls(x), l, mid);
		DFS(rs(x), mid, r);
	}
	while (!Stack.empty())
	{
		Fa[Stack.back().u] = Stack.back().u;
		Height[Stack.back().v] = Stack.back().h_v;
		Stack.pop_back();
	}
}
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i ++)
		Fa[i] = i, Height[i] = 1;
	for (int i = 1, a, b, l, r; i <= m; i ++)
	{
		scanf("%d%d%d%d", &a, &b, &l, &r);
		E[i] = Edge(a, b, l, r + 1);
		T[i] = l, T[i + m] = r + 1;
	}
	sort(T + 1, T + 2 * m + 1);
	sz = unique(T + 1, T + 2 * m + 1) - T - 1;
	for (int i = 1; i <= m; i ++)
	{
		E[i].l = lower_bound(T + 1, T + sz + 1, E[i].l) - T;
		E[i].r = lower_bound(T + 1, T + sz + 1, E[i].r) - T;
		Add(1, 1, sz, E[i].l, E[i].r, E[i].a, E[i].b);
	}
	DFS(1, 1, sz);
	printf("%d\n", ans);
	return 0;
}