P6348 [PA 2011] Journeys 题解

原创已于 2025-09-21 10:48:12 修改 · 644 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #图论

于 2025-09-21 10:46:26 首次发布

OI 专栏收录该内容

11 篇文章

订阅专栏

# P6348 [PA 2011] Journeys
题意简析：对一个n个点的图，使用(a, b)-(c, d)表示把每一个在(a, b)中的点向每一个在(c, d)中的点建边，问P节点到最远节点的距离。

做法分析：对于这种问题，我们一般的思路是建立虚点来减少边的个数，集中信息。为了最高效的建立虚点，我们可以考虑类似线段树的方法，用大概2 * n个点来表示一些区间，这样任意长度的区间就被分摊到了 $l o g n$ 个点上，注意到我们需要用一些节点作为“汇入”点，一些作为“汇出”点，即我们要建立两颗线段树，在第一棵树上到达父节点意味着可以到达以下的所有子节点，在第二棵树上到达子节点，可以到达以上的左右祖先节点，这样我们就使得虚点的逻辑自洽了。建立区间边的时候，只需从汇出树连到汇入树上，就能保证不出现奇怪的问题。若只建一棵树，则难免所有节点互相可达的状况。虽然边的个数已经降至 $mlog^2n$ 级别，面对本题数据范围仍然出现不过，这样一来，我们需要对每次询问继续优化，即每次不再建立 $log^2n$ 条边，而是通过新建一个虚点的方式只建立 $2 l o g n$ 条边。这样一来边的数量就可以接受了。不在一开始就通过直接建立虚点而是先建立线段树再建立虚点原因是一开始的边数量过多，最终虽然仍然是m个虚点，却会产生 $2 mn$ 条边，显然不可接受。而对于某个小区间不再使用线段树继续划分的原因是在只有一次的情况下，单独建立虚点显然更优。

代码：

#include <iostream>
#include <vector>
#include <cstring>
#include <queue>

const int N = 5e5;

int n, m, P;
int dis[N << 3];//表示到达某个节点的最小代价
int shot[N << 3];
int vis[N << 3];
struct node{
	int pos, val;
};
std::vector<node> G[N << 3];
int pointcnt = 0;

void BuildI(int u, int l, int r){
	if(l == r){
		G[u].push_back(node{u + (N << 2), 0});
		G[u + (N << 2)].push_back(node{u, 0});
		shot[l] = u;
		return;
	}
	int mid = (l + r) / 2;
	G[u].push_back(node{u * 2, 0});
	G[u].push_back(node{u * 2 + 1, 0});
	BuildI(u * 2, l, mid);
	BuildI(u * 2 + 1, mid + 1, r);
	return;
}

void BuildO(int u, int l, int r){
	if(l == r){
		pointcnt = std::max(pointcnt, u + (N << 2));
		G[u + (N << 2)].push_back(node{(u / 2) + (N << 2), 0});
		return;
	}
	int mid = (l + r) / 2;
	BuildO(u * 2, l, mid);
	BuildO(u * 2 + 1, mid + 1, r);
	if(u != 1){
		G[u + (N << 2)].push_back(node{(u / 2) + (N << 2), 0});
	}
	return;
}

void AddI(int u, int l, int r, int c, int d){
	if(l >= c && r <= d){
		G[pointcnt].push_back(node{u, 1});
		return;
	}
	int mid = (l + r) / 2;
	if(c <= mid){
		AddI(u * 2, l, mid, c, d);
	}
	if(d > mid){
		AddI(u * 2 + 1, mid + 1, r, c, d);
	}
	return;
}

void AddO(int u, int l, int r, int a, int b){
	if(l >= a && r <= b){//找到一组a, b
		G[u + (N << 2)].push_back(node{pointcnt, 1});
		return;
	}
	int mid = (l + r) / 2;
	if(a <= mid){
		AddO(u * 2, l, mid, a, b);
	}
	if(b > mid){
		AddO(u * 2 + 1, mid + 1, r, a, b);
	}
	return;
}

void Bfs(){
	std::queue<int> Q;
	Q.push(shot[P]);
	dis[shot[P]] = 0;
	vis[shot[P]] = 1;
	while(!Q.empty()){
		int u = Q.front();
		Q.pop();
		vis[u] = 0;
		for(int i = 0; i < G[u].size(); ++i){
			int v = G[u][i].pos;
			if(dis[u] + G[u][i].val >= dis[v]){
				continue;
			}
			dis[v] = dis[u] + G[u][i].val;
			if(vis[v] == 0){
				Q.push(v);
				vis[v] = 1;
			}
		}
	}
	return;
}

int main(){
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);

	std::cin >> n >> m >> P;
	BuildI(1, 1, n);//入树，父节点链接子节点
	BuildO(1, 1, n);//出树， 子节点链接父节点
	std::memset(dis, 0x3f, sizeof(dis));
	pointcnt += 10;
	int a, b, c, d;
	for(int i = 1; i <= m; ++i){
		std::cin >> a >> b >> c >> d;
		++pointcnt;
		AddO(1, 1, n, a, b);
		AddI(1, 1, n, c, d);
		++pointcnt;
		AddO(1, 1, n, c, d);
		AddI(1, 1, n, a, b);
	}

	Bfs();

	for(int i = 1; i <= n; ++i){
		std::cout << dis[shot[i]] / 2 << '\n';
	}
	return 0;
}