【UOJ #198】【CTSC 2016】时空旅行

http://uoj.ac/problem/198

（先补一下以前的题解）

这道题5分暴力好写好调，链上部分分可以用可持久化线段树，每次旅行\(x\)值相同的可以用标记永久化线段树。我还听到某些神犇说可以用KD-Treebalabalabala。

---

很显然\(y,z\)坐标都没用。然后。。。



在一个时空中，对于固定的\(x_0\)，要求最小的\(ans=c_i+(x_i-x_0)^2\)，拆开可以得到\(ans-x_0^2=(c_i+x_i^2)-2x_ix_0\)，这样只需要求\(min_i\{(c_i+x_i^2)-2x_ix_0\}\)。

把\(c_i+x_i^2\)看成\(y\)轴上的截距，\(-2x_i\)看成斜率，相当于一个\(y=kx+b\)的一次函数。在一个时空中有若干个一次函数，我们要求\(x=x_0\)时这些函数的最小值，很明显只要维护一个上凸壳，在上凸壳上查找就可以了。



对每个时空都维护一个上凸壳是必须的，暴力对每个星球所影响的时空都添加一条一次函数时间代价太高了。

还可以把每一部决策都抽象成一棵树，这样一个在第\(i\)个时空中殖民了一个星球，这个星球的一次函数能影响的其他时空是它在决策树中以\(i\)为根的子树。

对决策树的dfs序建线段树，以\(i\)为根的子树在dfs序中构成了一个连续的区间。在线段树上能表示这个区间的节点上都加上一次函数所带来的影响(标记永久化)。

至于放弃殖民的星球，只要记录一下星球在哪个时空中放弃了，线段树update的时候避开这些放弃的时空中的区间就可以了。

那么怎么维护线段树每个节点上的凸壳呢？

splay？复杂度\(O(n\log^2n)\)？

其实只要先对每个星球的\(x\)值从小到大排序，保证加入的一次函数的斜率单调递减，就可以用单调栈维护了，初始化复杂度\(O(n\log n)\)。



对于每个询问，可以直接从线段树的根节点到线段树的叶子节点的路径上所有的节点统计一下\(x=x_0\)时的最小值，最后和地球的值取min。

那么怎么统计一个凸壳上\(x=x_0\)时的最小值呢？

二分？复杂度\(O(n\log^2n)\)？

其实只要对询问的\(x_0\)从小到大排序，这样在凸壳上的位置也是单调递增的，每个凸壳记录上一次在哪里取得最小值，下一次的位置一定在其之后，回答询问时间复杂度\(O(n\log n)\)。



主要采用了离线排序后利用单调性的思想QAQ。

#include<cstdio>

#include<vector>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

const int N = 500003;

ll c0;

struct Edge {int nxt, to;} E[N];

int n, m, cnt = 0, point[N], tmp[N];

vector <int> del[N];

void ins(int u, int v) {E[++cnt] = (Edge) {point[u], v}; point[u] = cnt;}

struct node {

	int x; ll c;

	node(int _x = 0, ll _c = 0) : x(_x), c(_c) {}

	bool operator < (const node &A) {

		return x < A.x;

	}

} Planet[N];

int L_dfn[N], R_dfn[N], settle_to[N];

void dfs(int x) {

	L_dfn[x] = ++cnt;

	for(int i = point[x]; i; i = E[i].nxt)

		dfs(E[i].to);

	R_dfn[x] = cnt;

}

struct Querynode {

	int s, x0, id;

	bool operator < (const Querynode &A) const {

		return x0 < A.x0;

	}

} Q[N];

ll ans[N];

struct Knode {

	int k; ll b;

	Knode(int _k = 0, ll _b = 0) : k(_k), b(_b) {}

	ll cal(int x) {return b + 1ll * k * x;}

};

namespace SegmentTree {

	vector <Knode> Tu[N << 2];

	int tmp[N << 2];

	bool Cross(Knode a, Knode b, Knode c) {

		if (b.k == c.k) return c.b <= b.b;

		return 1.0 * (b.b - a.b) * (a.k - c.k) > 1.0 * (c.b - a.b) * (a.k - b.k);

	}

	void update(int rt, int l, int r, int L, int R, Knode Line) {

		if (L <= l && r <= R) {

			if (!Tu[rt].size()) Tu[rt].push_back(Line);

			else {

				while (Tu[rt].size() > 1 && Cross(Tu[rt][Tu[rt].size() - 2], Tu[rt].back(), Line)) Tu[rt].pop_back();

				Tu[rt].push_back(Line);

			}

			return;

		}

		int mid = (l + r) >> 1;

		if (L <= mid) update(rt << 1, l, mid, L, R, Line);

		if (R > mid) update(rt << 1 | 1, mid + 1, r, L, R, Line);

	}

	ll query(int rt, int l, int r, int pos, int x) {

		while (tmp[rt] + 1 < Tu[rt].size() && Tu[rt][tmp[rt]].cal(x) > Tu[rt][tmp[rt] + 1].cal(x)) ++tmp[rt];

		ll ans = Tu[rt].size() ? Tu[rt][tmp[rt]].cal(x) : 100000000000000000ll;

		if (l == r) return ans;

		int mid = (l + r) >> 1;

		if (pos <= mid) return min(ans, query(rt << 1, l, mid, pos, x));

		else return min(ans, query(rt << 1 | 1, mid + 1, r, pos, x));

	}

}

ll sqr(int x) {return 1ll * x * x;}

bool cmp_233(int x, int y) {return Planet[x].x < Planet[y].x;}

bool cmp1(int x, int y) {return L_dfn[x] < L_dfn[y];}

int main() {

	scanf("%d%d%lld", &n, &m, &c0);

	int op, fr, id, x, y, z; ll c;

	for(int i = 1; i < n; ++i) {

		tmp[i] = i;

		scanf("%d%d%d", &op, &fr, &id);

		if (op == 0) {

			scanf("%d%d%d%lld", &x, &y, &z, &c);

			settle_to[id] = i;

			Planet[id] = node(x, c);

		} else

			del[id].push_back(i);

		ins(fr, i);

	}

	cnt = 0;

	dfs(0);

	Knode Line; int pl, sp;

	stable_sort(tmp + 1, tmp + n, cmp_233);

	for(int i = 1; i < n; ++i) if (settle_to[tmp[i]]) {

		pl = tmp[i];

		sp = settle_to[pl];

		Line = Knode(-2 * Planet[pl].x, sqr(Planet[pl].x) + Planet[pl].c);

		if (!del[pl].size()) {if (L_dfn[sp] <= R_dfn[sp]) SegmentTree::update(1, 1, n, L_dfn[sp], R_dfn[sp], Line);}

		else {

			stable_sort(del[pl].begin(), del[pl].end(), cmp1);

			if (L_dfn[sp] < L_dfn[del[pl][0]]) SegmentTree::update(1, 1, n, L_dfn[sp], L_dfn[del[pl][0]] - 1, Line);

			if (R_dfn[del[pl].back()] < R_dfn[sp]) SegmentTree::update(1, 1, n, R_dfn[del[pl].back()] + 1, R_dfn[sp], Line);

			for(int j = 0; j < del[pl].size() - 1; ++j)

				if (R_dfn[del[pl][j]] + 1 < L_dfn[del[pl][j + 1]]) SegmentTree::update(1, 1, n, R_dfn[del[pl][j]] + 1, L_dfn[del[pl][j + 1]] - 1, Line);

		}

	}

	for(int i = 1; i <= m; ++i) {

		scanf("%d%d", &Q[i].s, &Q[i].x0);

		Q[i].id = i;

	}

	sort(Q + 1, Q + m + 1);

	for(int i = 1; i <= m; ++i)

		ans[Q[i].id] = min(sqr(Q[i].x0) + c0, sqr(Q[i].x0) + SegmentTree::query(1, 1, n, L_dfn[Q[i].s], Q[i].x0));

	for(int i = 1; i <= m; ++i) printf("%lld\n", ans[i]);

	return 0;

}

终于AC了