Chro's Blog

だから 迷わない 頑張ろう

Those things that hurt, instruct.


「BZOJ 3672」「UOJ 7」「NOI2014」购票

  1. 1. Description
  2. 2. Input
  3. 3. Output
  4. 4. Sample Input
  5. 5. Sample Output
  6. 6. HINT
  7. 7. Solution

Description

今年夏天,NOI在SZ市迎来了她30周岁的生日。来自全国 n 个城市的OIer们都会从各地出发,到SZ市参加这次盛会。

全国的城市构成了一棵以SZ市为根的有根树,每个城市与它的父亲用道路连接。为了方便起见,我们将全国的 n 个城市用 1 到 n 的整数编号。其中SZ市的编号为 1。对于除SZ市之外的任意一个城市 v,我们给出了它在这棵树上的父亲城市 fv 以及到父亲城市道路的长度 sv。

从城市 v 前往SZ市的方法为:选择城市 v 的一个祖先 a,支付购票的费用,乘坐交通工具到达 a。再选择城市 a 的一个祖先 b,支付费用并到达 b。以此类推,直至到达SZ市。

对于任意一个城市 v,我们会给出一个交通工具的距离限制 lv。对于城市 v 的祖先 a,只有当它们之间所有道路的总长度不超过 lv 时,从城市 v 才可以通过一次购票到达城市 a,否则不能通过一次购票到达。对于每个城市 v,我们还会给出两个非负整数 pv,qv 作为票价参数。若城市 v 到城市 a 所有道路的总长度为 d,那么从城市 v 到城市 a 购买的票价为 dpv+qv。

每个城市的OIer都希望自己到达SZ市时,用于购票的总资金最少。你的任务就是,告诉每个城市的OIer他们所花的最少资金是多少。

Input

第 1 行包含2个非负整数 n,t,分别表示城市的个数和数据类型(其意义将在后面提到)。输入文件的第 2 到 n 行,每行描述一个除SZ之外的城市。其中第 v 行包含 5 个非负整数 f_v,s_v,p_v,q_v,l_v,分别表示城市 v 的父亲城市,它到父亲城市道路的长度,票价的两个参数和距离限制。请注意:输入不包含编号为 1 的SZ市,第 2 行到第 n 行分别描述的是城市 2 到城市 n。

Output

输出包含 n-1 行,每行包含一个整数。其中第 v 行表示从城市 v+1 出发,到达SZ市最少的购票费用。同样请注意:输出不包含编号为 1 的SZ市。

Sample Input

1
2
3
4
5
6
7
7 3
1 2 20 0 3
1 5 10 100 5
2 4 10 10 10
2 9 1 100 10
3 5 20 100 10
4 4 20 0 10

Sample Output

1
2
3
4
5
6
40
150
70
149
300
150

HINT

对于所有测试数据,保证 0≤pv≤106,0≤qv≤1012,1≤fv<v;保证 0<sv≤lv≤2×1011,且任意城市到SZ市的总路程长度不超过 2×1011。

输入的 t 表示数据类型,0≤t<4,其中:

当 t=0 或 2 时,对输入的所有城市 v,都有 fv=v-1,即所有城市构成一个以SZ市为终点的链;

当 t=0 或 1 时,对输入的所有城市 v,都有 lv=2×1011,即没有移动的距离限制,每个城市都能到达它的所有祖先;

当 t=3 时,数据没有特殊性质。

n=2×10^5

Solution

如果没有 L[u] 的限制,以及如果图是一条链(此时把节点按照在链上的顺序重新编号为 1~n),并用 f[u] 表示节点 u 到 1 的最少费用、用 dis[u] 表示 u 到 1 的距离,那么 $f(u)=\min_{1\le v< u}\{f(v)+p(u)(dis(u)-dis(v))+q(u)\}$。这个方程很容易按照通常的套路化为一个斜率优化 DP 的形式。

该方程之所以能斜率优化,是因为没有 L[u] 的限制,这保证每个元素至多进出单调栈各一次。

加上了 L[u] 的限制之后,其实也没有变得多么复杂。所谓「斜率优化」,其实是维护平面上一堆点的凸壳(在本题中为下凸壳)。而我们在计算 DP 的每一项时,只是在凸壳上按照斜率找一个点而已。

如果能以一种特殊的顺序来 DP 呢?……


嗯,于是我们有了分治算法。

链的前一半递归,后一半按照 dis[u]-L[u] 降序排序。按照这个顺序依次进行。对于一个节点 u,找到在 L[u] 限制下它最靠近根可以走到哪里。由于排序了,这个位置是非严格单调靠近根节点的,该位置每向根前进一步,就把它放入单调栈。

单调栈中的元素会形成一个凸壳。对于当前节点 u,在凸壳上二分(斜率单调递增),找到斜率刚好 >p[u] 的位置,用该位置更新 f(u)。

这样我们就处理完了跨两半的 DP。然后我们要考虑涉及中心的情况。

这个要简单一些,如果一个节点满足 $dis[u]-L[u] < dis[center]$,那么直接用 center 更新 f(u) 即可。

最后我们要处理后半链内的 DP。这个直接递归就行。


你可能已经发现这个做法比较麻烦,但它可以非常容易地扩展到一般化的树上。上文所述的分治,就是树的点分治:

  1. 找出当前树的重心;
  2. 把重心为根的子树去掉,递归剩下的部分;
  3. 把重心为根的子树的节点全部取出来,按照 dis[u]-L[u] 降序排序;
  4. 按照上文的核心步骤,跨重心 DP;
  5. 涉及重心本身的 DP;
  6. 递归重心子树。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <bits/stdc++.h>
using namespace std;
#define long long long
const int maxn = 200005;
const long inf = 1ll << 60;
struct edge { int to, next; } e[maxn << 1];
int n, qwq, tot, head[maxn], par[maxn], gravity, nodes, size[maxn];
long dis[maxn], P[maxn], Q[maxn], L[maxn], f[maxn];
bool vis[maxn];
int C[maxn], ccnt, q[maxn], qr;
double K[maxn];
double slope(int a, int b) { return (f[a] - f[b]) * 1.0 / (dis[a] - dis[b]); }
void dfs(int u) {
C[++ccnt] = u;
for (int t = head[u]; t; t = e[t].next) {
int v = e[t].to;
if (!vis[v]) dfs(v);
}
}
bool cmp(int u, int v) { return dis[u] - L[u] > dis[v] - L[v]; }
void center(int u) {
bool flag = true;
size[u] = 1;
for (int t = head[u]; t; t = e[t].next) {
int v = e[t].to;
if (vis[v]) continue;
center(v);
size[u] += size[v];
if ((size[v] << 1) > nodes) flag = false;
}
if (((nodes - size[u]) << 1) > nodes) flag = false;
if (flag) gravity = u;
}
void query(int u, int l, int r) {
while (l < r) {
int mid = (l + r) >> 1;
if (K[mid] >= P[u]) l = mid + 1;
else r = mid;
}
f[u] = min(f[u], f[q[l]] + P[u] * (dis[u] - dis[q[l]]) + Q[u]);
}
void solve(int u) {
center(u);
int r = gravity;
vis[r] = true;
if (r ^ u) {
nodes = size[u] - size[r];
solve(u);
ccnt = 0, dfs(r);
sort(C + 1, C + ccnt + 1, cmp);
int i = 1, p = par[r];
q[qr = 1] = p;
while (i <= ccnt && dis[C[i]] - L[C[i]] > dis[p]) ++i;
for (; i <= ccnt; ++i) {
while (p != u && dis[C[i]] - L[C[i]] <= dis[par[p]]) {
p = par[p];
while (qr > 1 && slope(q[qr - 1], q[qr]) <= slope(q[qr], p)) --qr;
K[qr] = slope(q[qr], p), q[++qr] = p;
}
query(C[i], 1, qr);
}
} else ccnt = 0, dfs(r);
for (int i = 1; i <= ccnt; ++i) if (dis[C[i]] - L[C[i]] <= dis[r])
f[C[i]] = min(f[C[i]], f[r] + P[C[i]] * (dis[C[i]] - dis[r]) + Q[C[i]]);
for (int t = head[r]; t; t = e[t].next) {
int v = e[t].to;
if (!vis[v]) nodes = size[v], solve(v);
}
}
void arc(int f, int t) { e[++tot] = (edge){t, head[f]}, head[f] = tot; }
int main() {
scanf("%d%d", &n, &qwq);
for (int i = 2; i <= n; ++i) {
scanf("%d%lld%lld%lld%lld", par + i, dis + i, P + i, Q + i, L + i);
arc(par[i], i), dis[i] += dis[par[i]];
}
f[1] = 0;
for (int i = 2; i <= n; ++i) f[i] = inf;
nodes = n, solve(1);
for (int i = 2; i <= n; ++i) printf("%lld\n", f[i]);
return 0;
}
最近的文章

「BZOJ 4730」「UOJ 266」「清华集训2016」Alice和Bob又在玩游戏

DescriptionAlice和Bob在玩游戏。有n个节点,m条边(0&lt;=m&lt;=n-1),构成若干棵有根树,每棵树的根节点是该连通块内编号最小的点。Alice和Bob轮流操作,每回合选择一个没有被删除的节点x,将x及其所有祖先全部删除,不能操作的人输。注:树的形态是在一开始就确定好的,…

BZOJ, 博弈论, 树型 DP 继续阅读
更早的文章

「BZOJ 4200」「UOJ 132」「NOI2015」小园丁与老司机

小园丁 Mr. S 负责看管一片田野,田野可以看作一个二维平面。田野上有 n 棵许愿树,编号 1,2,3,…,n,每棵树可以看作平面上的一个点,其中第 i 棵树 (1≤i≤n) 位于坐标 (xi,yi)。任意两棵树的坐标均不相同。 老司机 Mr. P 从原点 (0,0) 驾车出发,进行若干轮行动。每…

BZOJ, UOJ, 上下界最小流, 动态规划, 网络流 继续阅读