P10602 做题记录

\(n^2\) 的树形 DP 做法是比较显然的,我们设 \(dp_i\) 表示从 \(i\) 走到根节点所需要的最少的时间。

对于转移,考虑枚举走到哪一个节点,也就是枚举所有的父节点。设当前节点为 \(u\),祖先为 \(fa\),则:

\[dp_{fa}+w_u+v_u \times S_{u,fa} \to dp_u \]

其中 \(S_{u,fa}\) 表示 \(u,fa\) 两点的距离,可以使用树上前缀和 \(O(1)\) 得到。再设 \(dis_u\) 表示 \(1\) 到 \(u\) 的距离,则公式变为:

\[dp_{fa}+w_u+v_u \times (dis_u - dis_{fa}) \to dp_u \]

发现这个转移方程可以变成一次函数的形式:

\[dp_u=\min(-dis_{fa} \times v_u + dp_{fa}) + w_u + v_u \times dis_u \]

这显然可以用李超线段树优化为 \(O(\log n)\) 查询。由于我们的动态规划是从上往下的,所以递归完一个节点的子树时需要从李超线段树里删除掉。这也很简单,考虑使用可撤销李超线段树即可。

可撤销李超线段树

看似高级,实则非常简单,只需要用栈记录一下插入一条线段时修改了哪些节点,以及原来的节点编号。在 DP 时记录一下开始时栈的大小,回溯时一直将修改的节点复原直至回到了原来栈的大小。


#include<bits/stdc++.h>
#define int long long
#define f(id,x) (!id ? inf : xd[id].k*lsh[x]+xd[id].b)
#define ls id<<1
#define rs ls|1
using namespace std;
const int N=100005,inf=1e18;
int dp[N];
int n;
int W[N],V[N];
int lsh[N];
int dis[N];
struct edge{
    int v,w;
};
vector<edge>g[N];
struct cx{
    int id,old;
};
stack<cx>st;
struct no{
    int k,b;
}xd[N];
struct SegmentTree{
    int t[N<<2];
    void update(int l,int r,int id,int now){
        if(f(now,l)>f(t[id],l) && f(now,r)>f(t[id],r))return;
        if(f(now,l)<f(t[id],l) && f(now,r)<f(t[id],r)){
            st.push({id,t[id]});//发生改变,入栈
            t[id]=now;
            return;
        }
        int mid=(l+r)>>1;
        if(f(now,mid)<f(t[id],mid)){
            st.push({id,t[id]});//同理
            swap(now,t[id]);
        }
        if(f(now,l)<f(t[id],l))update(l,mid,ls,now);
        if(f(now,r)<f(t[id],r))update(mid+1,r,rs,now);
        return;
    }
    int query(int l,int r,int id,int x){
        if(l==r)return f(t[id],x);
        int mid=(l+r)>>1;
        return min(f(t[id],x),(x<=mid ? query(l,mid,ls,x) : query(mid+1,r,rs,x)));
    }
    void back(int las){//回溯操作
        while(st.size()>las){
            cx u=st.top();st.pop();
            t[u.id]=u.old;
        }
        return;
    }
}seg;
void insert(int u){
    xd[u]={-dis[u],dp[u]};
    seg.update(1,n,1,u);
    return;
}
void DFS(int u,int fa){
    for(auto i:g[u]){
        if(i.v==fa)continue;
        dis[i.v]=dis[u]+i.w;
        DFS(i.v,u);
    }
    return;
}
void dfs(int u,int fa){
    int now=st.size();
    int pos=lower_bound(lsh+1,lsh+n+1,V[u])-lsh;
    dp[u]=seg.query(1,n,1,pos)+W[u]+V[u]*dis[u];
    insert(u);
    for(auto i:g[u]){
        if(i.v==fa)continue;
        dfs(i.v,u);
    }
    seg.back(now);
    return;
}
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v,w;cin>>u>>v>>w;
        g[u].push_back({v,w});
        g[v].push_back({u,w});
    }
    for(int i=2;i<=n;i++)cin>>W[i]>>V[i];
    for(int i=2;i<=n;i++)lsh[i]=V[i];
    sort(lsh+1,lsh+n+1);
    DFS(1,0);
    insert(1);
    dfs(1,0);
    for(int i=2;i<=n;i++)cout<<dp[i]<<' ';
    return 0;
}
/*
dp[i]=dp[fa]+w[i]+v[i]*(dis[i]-dis[fa])
     =dp[fa]+w[i]+v[i]*dis[i]-v[i]*dis[fa]
     =min(-dis[fa]*v[i]+dp[fa])+w[i]+v[i]*dis[i]
*/
posted @ 2026-11-05 22:30  tangkaiming  阅读(12)  评论(0)    收藏  举报