建议到UOJ上去交
题解
一眼(DP),先把转移方程写出来
设(dp[i])为从点(i)出发到点(1)的最小费用,那么存在转移
[f[i]=min{f[j]+(d[i]-d[j])p[i]}+q[i]=min{f[j]-d[j]p[i]}+d[i]*p[i]+q[i]
]
这个式子看起来可以斜率优化啊,往下化几步,可以得到类似下面的东西:
若(d[j] < d[k]),则当(frac{dp[j]-dp[k]}{d[j]-d[k]}geqslant p[i])时从(j)转移更优,否则从(k)转移更优
这表明我们只需要维护一个下凸壳,转移时二分一下就行了
假设这个问题是在序列上且没有距离限制,你就已经可以(O(nlogn))地(A)掉它了
加上距离限制时,我们可以拿个线段树维护一下每一小段的凸壳,查询时取个最大值
挪到树上时,只需要上个树剖
托上面两个东西的福,复杂度也变成了(O(nlog^3n))[手动滑稽]
然后就是码码码
#include <bits/stdc++.h>
using namespace std;
#define MAXN 200000
#define vi vector<int>
#define pb push_back
#define ll long long
#define INF 0x7f7f7f7f7f7f7f7f
#define LIM 17
int n, t;
vi G[MAXN + 5];
int summit[MAXN + 5], f[20][MAXN + 5], fa[MAXN + 5], top[MAXN + 5], sz[MAXN + 5], hson[MAXN + 5], id[MAXN + 5], dfn[MAXN + 5], dfn_clk;
ll d[MAXN + 5], s[MAXN + 5], p[MAXN + 5], q[MAXN + 5], l[MAXN + 5], dp[MAXN + 5];
namespace HLD {
void dfs1(int u) {
sz[u] = 1;
f[0][u] = fa[u];
for (int i = 1; i <= LIM; ++i) f[i][u] = f[i - 1][f[i - 1][u]];
for (auto v : G[u]) {
if (v == fa[u]) continue;
d[v] = d[u] + s[v];
dfs1(v);
sz[u] += sz[v];
if (sz[v] > sz[hson[u]]) hson[u] = v;
}
}
void dfs2(int u, int tp) {
top[u] = tp;
dfn[u] = ++dfn_clk;
id[dfn_clk] = u;
if (hson[u]) dfs2(hson[u], tp);
for (auto v : G[u]) {
if (v == fa[u] || v == hson[u]) continue;
dfs2(v, v);
}
}
}
double slope(int x, int y) {
return static_cast<double>(dp[y] - dp[x])/(d[y] - d[x]);
}
void pre() {
for (int i = 2; i <= n; ++i) {
int u = i;
for (int j = LIM; ~j; --j)
if (d[i] - d[f[j][u]] <= l[i])
u = f[j][u];
summit[i] = !u ? 1 : u;
}
}
namespace SegementTree {
#define mid ((l + r) >> 1)
#define lson (o << 1)
#define rson (o << 1 | 1)
vi ch[4 * MAXN + 5];
void addPoint(vi &v, int x) { // 把点x扔进下凸壳
while (v.size() >= 2 && slope(x, v[v.size() - 2]) < slope(v[v.size() - 1], v[v.size() - 2])) v.pop_back();
v.push_back(x);
}
ll get(vi &v, ll p) { // 在凸壳上二分斜率
if (v.size() == 1) return dp[v[0]] - d[v[0]] * p;
ll ret = INF;
int l = 0, r = v.size() - 1, m;
double s1, s2;
while (l <= r) {
m = (l + r) >> 1;
if (m == v.size() - 1) {
s1 = slope(v[m - 1], v[m]);
ret = min(ret, dp[v[m]] - d[v[m]] * p);
if (s1 <= p) l = m + 1;
else r = m - 1;
}
else if (!m) {
s2 = slope(v[m], v[m + 1]);
ret = min(ret, dp[v[m]] - d[v[m]] * p);
if (s2 <= p) l = m + 1;
else r = m - 1;
}
else {
s1 = slope(v[m - 1], v[m]);
s2 = slope(v[m], v[m + 1]);
ret = min(ret, dp[v[m]] - d[v[m]] * p);
if (s1 <= p && s2 <= p) l = m + 1;
else if(s1 <= p && s2 > p) return min(ret, dp[v[m]] - d[v[m]] * p);
else r = m - 1;
}
}
return ret;
}
void insert(int o, int l, int r, int x, int u) { // 插入一个点
addPoint(ch[o], u);
if (l == r) return ;
if (x <= mid) insert(lson, l, mid, x, u);
else insert(rson, mid + 1, r, x, u);
}
ll query(int o, int l, int r, int L, int R, ll p) { // 在那一堆凸壳中找最小值
if (L <= l && r <= R) return get(ch[o], p);
ll ret = INF;
if (L <= mid) ret = min(ret, query(lson, l, mid, L, R, p));
if (R > mid) ret = min(ret, query(rson, mid + 1, r, L, R, p));
return ret;
}
#undef mid
#undef lson
#undef rson
}
using namespace SegementTree;
void update(int u) { // 求点u的DP值
dp[u] = INF;
int x = fa[u];
while (d[top[x]] >= d[summit[u]]) {
dp[u] = min(dp[u], query(1, 1, n, dfn[top[x]], dfn[x], p[u]) + d[u] * p[u] + q[u]);
x = fa[top[x]];
}
if (d[x] >= d[summit[u]]) dp[u] = min(dp[u], query(1, 1, n, dfn[summit[u]], dfn[x], p[u]) + d[u] * p[u] + q[u]);
}
void work(int u) {
if (u != 1) update(u);
insert(1, 1, n, dfn[u], u);
for (auto v : G[u]) {
if (v == fa[u]) continue;
work(v);
}
}
int main() {
scanf("%d%d", &n, &t);
for (int i = 2; i <= n; ++i) {
scanf("%d%lld%lld%lld%lld", &fa[i], &s[i], &p[i], &q[i], &l[i]);
G[fa[i]].pb(i);
}
HLD::dfs1(1);
HLD::dfs2(1, 1);
d[0] = -1;
pre();
work(1);
for (int i = 2; i <= n; ++i) printf("%lld
", dp[i]);
return 0;
}