四叠半神话大系（bfs序+st+在线倍增+二分）(北理16校赛）

Posted 2020-07-07 chat_c

时间限制1秒 内存限制64M

题目描述：

「我们大部分的烦恼，是来自于梦想另一种有可能的人生。把希望寄托于自己的可能性这种不能指望的东西，正是万恶的根源。」

时间突然停止。

我获得了可以在平行世界中穿梭的能力。

宇宙中存在着无数的平行世界，这些世界组成了一个树形的结构，每个世界有一个编号和一个幸福度。

 

每当我做出选择时，世界会分裂成若干个新的世界。选择会导致幸福度的变化。根据选择的不同，在新的世界里，我可能会变的更加幸福，或者更加不幸。

出于某些原因，我只能在处于相同时间的世界内穿梭，而且只能在由若干个时间单位前的世界分裂来的世界中穿梭。

我要在平行世界中找到一个最幸福的世界，在那里继续生活下去。然而真的存在这样的世界吗？

输入格式：

第一行，一个整数，表示一共有个世界。

接下来行，每行三个整数,, . 表示号世界下一个时间单位内会走向号世界，幸福度会变化。(, )

接下来一行，一个整数，表示接下来有Q个询问。

接下来行，每行两个整数, 。表示现在身处号世界，允许穿梭到从个时间单位前分裂的所有世界。 ，  。

数据保证，1号世界是根节点，且1号节点的幸福度是。

输出格式：

行，每行一个整数。第的整数表示第个询问中，能获得的最大幸福度。

样例输入：

8

1 2 1

2 3 3

1 4 2

1 5 -2

5 6 3

5 7 4

5 8 -2

3

6 1

6 2

5 1

样例输出:

2

4

2

样例解释：

对于第二个询问(6, 2)，6号世界2个时间单位前的世界是1号世界，1号世界分裂的所有世界中，与6号世界处在相同时间的是3号、6号、7号、8号世界，其中幸福度最高的是3号世界(0 + 1 + 3 = 4)。

题目大意：

              一棵有根树，每个节点有一个权值，现在有若干个询问，对于每一个询问（x，y），求与x节点有相同深度且具有相同第y级祖先的所有节点中，权值的最大值。

解题思路：

           用类似在线倍增lca的思路，nlogn预处理，可以在logn内求出他的y级祖先。

           相同深度而且有某个公共y级祖先的节点的bfs序是连续的，如果获得了bfs序的区间，可以用rmq求出这个区间节点中的最大权值。

           先求出所有点的bfs序，构建这些节点的st，然后二分求出区间的左端点和右端点（随着bfs序的增大他们的y级祖先的bfs序也在增大）每次求祖先logn的，因此查询的复杂度是（logn)^2的，总的复杂度o(qlognlogn)

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;
const int maxn = 100050;
const double eps = 1e-6;
int p[maxn][55], head[maxn], tot, val[maxn], vis[maxn], bfsxu, pos[maxn], spos[maxn], mm[maxn];
int maxx[maxn][55];
struct node {
	int from, to, next, val;
}e[maxn];
void init()
{
	tot = 0; bfsxu = 1; pos[1] = 1; spos[1] = 1;
	memset(head, -1, sizeof(head));
	memset(vis, 0, sizeof(vis));
	memset(val, 0, sizeof(val));
	memset(p, -1, sizeof(p));
}
void add(int u, int v, int w)
{
	e[tot].from = u;
	e[tot].to = v;
	e[tot].next = head[u];
	e[tot].val = w;
	head[u] = tot++;
}
void dfs(int u)
{
	vis[u] = 1;
	for (int i = head[u]; ~i; i = e[i].next)
	{
		int v = e[i].to;
		if (!vis[v])
		{
			p[v][0] = u;
			dfs(v);
		}
	}
}
void rmq(int n)
{
	for (int j = 1; (1 << j) <= n; j++)
		for (int i = 1; i <= n; i++)
			if (~p[i][j - 1])p[i][j] = p[p[i][j - 1]][j - 1];
}
void st(int n)
{
	mm[0] = -1;
	for (int i = 1; i <= n; i++)
	{
		mm[i] = ((i&(i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
		maxx[i][0] = val[pos[i]];
	}
	for (int j = 1; j <= mm[n]; j++)
		for (int i = 1; i + (1 << j) - 1 <= n; i++)
			maxx[i][j] = max(maxx[i][j - 1], maxx[i + (1 << (j - 1))][j - 1]);
}
int lca(int x, int y)
{
	int pa = x;
	while (y&&pa != -1)
	{
		int low = y&(-y);
		pa = p[pa][mm[low]];
		y -= low;
	}
	if (pa == -1)return 0;
	return pa;
}
int solve(int x, int y)
{
	int k = mm[y - x + 1];
	return max(maxx[x][k], maxx[y - (1 << k) + 1][k]);
}
int main()
{
	int n, x, y, z, q;
	while (~scanf("%d", &n))
	{
		init();
		for (int i = 1; i < n; i++)
		{
			scanf("%d%d%d", &x, &y, &z);
			add(x, y, z);
		}
		dfs(1);
		rmq(n);
		queue<int>que;
		que.push(1);
		while (!que.empty())
		{
			int u = que.front(); que.pop();
			for (int i = head[u]; ~i; i = e[i].next)
			{
				int v = e[i].to;
				val[v] = val[e[i].from] + e[i].val;
				pos[++bfsxu] = v; spos[v] = bfsxu;
				que.push(v);
			}
		}
		st(n);
		scanf("%d", &q);
		while (q--)
		{
			scanf("%d%d", &x, &y);
			int fa = lca(x, y), ll, rr;
			int l = 1, r = spos[x];
			while (l<r)
			{
				int mid = (l + r) / 2;
				if (spos[lca(pos[mid], y)] < spos[fa])l = mid + 1;
				else r = mid;
			}
			ll = l;
			l = spos[x], r = n;
			while (l<r)
			{
				int mid = (l + r) / 2;
				if (spos[lca(pos[mid], y)]>spos[fa])r = mid - 1;
				else l = mid;
				if (r == l + 1)
				{
					if (spos[lca(pos[r], y)] == spos[fa])l = r;
					else r = l;
				}
			}
			rr = l;
			printf("%d\n", solve(ll, rr));
		}
	}
	return 0;
}