【BZOJ5077】【UOJ198】【CTSC2016】时空旅行

【题目链接】

• BZOJ
  
• UOJ
  

【思路要点】

• 我们发现所有星球的\(y\)和\(z\)坐标没有实质作用，问题仅和\(x\)和\(c\)有关。
• 令询问给出的横坐标为\(qx\)，那么一个属性为\((x,c)\)的星球被探索的代价为\((qx-x)^2+c=qx^2-2x*qx+(x^2+c)\)。显然\(qx^2\)只和询问有关，因此我们需要求\(-2x*qx+(x^2+c)\)的最小值，令\(k=-2x,b=x^2+c\)，则要求的是\(k*qx+b\)的最小值。
• 令\(k_1>k_2\)，则\((k_1,b_1)\)优于\((k_2,b_2)\)的充要条件为\(k_1*qx+b_1≤k_2*qx+b_2\)，也即\(-qx≥\frac{b_1-b_2}{k_1-k_2}\)，容易看出，我们可以通过类似斜率优化的方式维护一个\((k,b)\)的下凸壳来快速找到最优解。
• 在原树的DFS序上建立线段树，则每一个星球存在的时空是线段树上一段或多段区间，这样的区间的总数是\(O(N)\)的。在线段树定位到的每一个区间中加入\((k,b)\)并维护下凸壳，对于每个询问，查询包含询问点的所有区间的答案，取最小值。
• 直接使用平衡树维护每个凸壳，询问时在凸壳上二分，时间复杂度为\(O(NLog^2N)\)（\(N\)、\(M\)同阶）。
• 考虑离线操作，并将星球按照\(k\)排序，依次加入线段树，就可以用单调队列来维护凸壳了。
• 同样地，我们离线询问，将询问按照\(-qx\)排序，依次询问，在线段树每个节点的询问就可以达到均摊\(O(1)\)的时间复杂度。
• 时间复杂度\(O(NLogN)\)（\(N\)、\(M\)同阶）。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const int MAXP = 7e6 + 5;
const long long INF = 1e18;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct SegmentTree {
	struct Node {
		int lc, rc;
		int head, tail;
	} a[MAXN * 2];
	int n, root, size, tot;
	int nxt[MAXP], pre[MAXP];
	long long k[MAXP], b[MAXP];
	void build(int &root, int l, int r) {
		root = ++size;
		if (l == r) return;
		int mid = (l + r) / 2;
		build(a[root].lc, l, mid);
		build(a[root].rc, mid + 1, r);
	}
	void init(int x) {
		n = x;
		root = size = 0;
		build(root, 1, n);
	}
	void insert(int root, int l, int r, int ql, int qr, long long vk, long long vb) {
		if (l == ql && r == qr) {
			if (a[root].tail) {
				if (k[a[root].tail] == vk) {
					if (vb >= b[a[root].tail]) return;
					else {
						a[root].tail = pre[a[root].tail];
						nxt[a[root].tail] = 0;
						if (a[root].tail == 0) a[root].head = 0;
					}
				}
				while (a[root].tail != a[root].head) {
					int tmp = a[root].tail;
					int tnp = pre[tmp];
					if ((vk - k[tnp]) * (b[tmp] - b[tnp]) >= (k[tmp] - k[tnp]) * (vb - b[tnp])) {
						a[root].tail = pre[a[root].tail];
						nxt[a[root].tail] = 0;
					} else break;
				}
				if (a[root].tail) {
					nxt[a[root].tail] = ++tot;
					pre[tot] = a[root].tail;
					k[tot] = vk, b[tot] = vb;
					a[root].tail = tot;
				} else {
					a[root].head = a[root].tail = ++tot;
					k[tot] = vk, b[tot] = vb;
				}
			} else {
				a[root].head = a[root].tail = ++tot;
				k[tot] = vk, b[tot] = vb;
			}
			return;
		}
		int mid = (l + r) / 2;
		if (mid >= ql) insert(a[root].lc, l, mid, ql, min(mid, qr), vk, vb);
		if (mid + 1 <= qr) insert(a[root].rc, mid + 1, r, max(mid + 1, ql), qr, vk, vb);
	}
	void insert(int l, int r, long long vk, long long vb) {
		insert(root, 1, n, l, r, vk, vb);
	}
	long long query(int root, int l, int r, int pos, long long x) {
		long long ans = INF;
		if (a[root].head) {
			ans = k[a[root].head] * x + b[a[root].head];
			while (a[root].head != a[root].tail) {
				int tmp = nxt[a[root].head];
				long long tnp = k[tmp] * x + b[tmp];
				if (tnp <= ans) {
					ans = tnp;
					a[root].head = nxt[a[root].head];
					pre[a[root].head] = 0;
				} else break;
			}
		}
		if (l == r) return ans;
		int mid = (l + r) / 2;
		if (mid >= pos) chkmin(ans, query(a[root].lc, l, mid, pos, x));
		else chkmin(ans, query(a[root].rc, mid + 1, r, pos, x));
		return ans;
	}
	long long query(int pos, long long x) {
		return query(root, 1, n, pos, x);
	}
} ST;
vector <int> a[MAXN], del[MAXN];
int n, m, fa[MAXN], ins[MAXN];
int timer, dfn[MAXN], rit[MAXN];
long long k[MAXN], b[MAXN];
int to[MAXN]; long long x[MAXN], ans[MAXN];
void dfs(int pos) {
	dfn[pos] = ++timer;
	for (unsigned i = 0; i < a[pos].size(); i++)
		dfs(a[pos][i]);
	rit[pos] = timer;
}
bool cmp(int x, int y) {
	return k[x] < k[y];
}
bool cnp(int x, int y) {
	return dfn[x] < dfn[y];
}
bool mmp(int a, int b) {
	return x[a] > x[b];
}
int main() {
	read(n), read(m), read(b[1]); ins[1] = 1;
	for (int i = 2; i <= n; i++) {
		int opt; read(opt);
		read(fa[i]), fa[i]++;
		a[fa[i]].push_back(i);
		int id; read(id), id++;
		if (opt == 0) {
			ins[id] = i;
			long long x, y, z, c;
			read(x), read(y), read(z), read(c);
			k[id] = -2 * x, b[id] = c + x * x;
		} else del[id].push_back(i);
	}
	dfs(1);
	static int pos[MAXN];
	for (int i = 1; i <= n; i++)
		pos[i] = i;
	sort(pos + 1, pos + n + 1, cmp);
	ST.init(n);
	for (int i = 1; i <= n; i++) {
		int tmp = pos[i];
		if (ins[tmp] == 0) continue;
		sort(del[tmp].begin(), del[tmp].end(), cnp);
		int lft = dfn[ins[tmp]];
		for (unsigned i = 0; i < del[tmp].size(); i++) {
			int tnp = del[tmp][i];
			if (dfn[tnp] != lft) ST.insert(lft, dfn[tnp] - 1, k[tmp], b[tmp]);
			lft = rit[tnp] + 1; 
		}
		if (lft <= rit[ins[tmp]]) ST.insert(lft, rit[ins[tmp]], k[tmp], b[tmp]);
	}
	for (int i = 1; i <= m; i++) {
		read(to[i]), read(x[i]), to[i]++;
		pos[i] = i;
	}
	sort(pos + 1, pos + m + 1, mmp);
	for (int i = 1; i <= m; i++) {
		int tmp = pos[i];
		ans[tmp] = ST.query(dfn[to[tmp]], x[tmp]) + x[tmp] * x[tmp];
	}
	for (int i = 1; i <= m; i++)
		printf("%lld\n", ans[i]);
	return 0;
}