BZOJ 5129: [Lydsy1712月赛]树上传送 点分树+Dijkstra

Description

 http://www.lydsy.com/JudgeOnline/upload/201712/prob12.pdf

Input

Output

暑假集训的时候点分树做的比较少，所以做这道题比较吃力，然而现在看这道题就比较简单了.
考虑直接建立点分树，每一个节点只需维护点分子树中 $BFS$ 序.
这样的好处是子树中点的深度是连续的，所以每次能到达的点肯定是连续的区间.
那么，只需按照 $Dijkstra$ 的运行过程，将点加入到优先队列中，并扩展队首.
每次扩展只需边删掉 $BFS$ 序中可以到达的点并加入到堆中，然后一边跳点分树中父亲即可.

#include <bits/stdc++.h>
using namespace std;  
typedef long long ll;      
const int maxn=300005;   
namespace IO {  
    void setIO(string s) {
        string in=s+".in"; 
        string out=s+".out"; 
        freopen(in.c_str(),"r",stdin);
        freopen(out.c_str(),"w",stdout); 
    } 
    char *p1,*p2,buf[100000];
    #define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
    int rd() {
        int x=0; 
        char c=nc(); 
        while(c<48) c=nc(); 
        while(c>47) x=(((x<<2)+x)<<1)+(c^48),c=nc(); 
        return x;
    }
};  
namespace tree{  
    int edges; 
    int hd[maxn],to[maxn<<1],nex[maxn<<1]; 
    int fa[maxn],top[maxn],siz[maxn],son[maxn],dep[maxn];
    void addedge(int u,int v) { 
        nex[++edges]=hd[u],hd[u]=edges,to[edges]=v; 
    }         
    void dfs1(int u,int ff) {
        dep[u]=dep[ff]+1,fa[u]=ff,siz[u]=1; 
        for(int i=hd[u];i;i=nex[i]) {
            int v=to[i]; 
            if(v==ff) continue;      
            dfs1(v,u), siz[u]+=siz[v];  
            if(siz[v]>siz[son[u]]) son[u]=v;    
        }
    } 
    void dfs2(int u,int tp) {                  
        top[u]=tp;
        if(son[u]) dfs2(son[u],tp); 
        for(int i=hd[u];i;i=nex[i]) {
            int v=to[i];             
            if(v==fa[u]||v==son[u])continue; 
            dfs2(v,v); 
        }
    }       
    int LCA(int x,int y) {
        while(top[x]^top[y]) {
            dep[top[x]]>dep[top[y]]?x=fa[top[x]]:y=fa[top[y]];     
        } 
        return dep[x]<dep[y]?x:y;  
    }
    int Dis(int x,int y) {
        return dep[x]+dep[y]-(dep[LCA(x,y)]*2);    
    }
};   
namespace Divide {     
    struct Node {
        int dis,u; 
        Node(int dis=0,int u=0):dis(dis),u(u){} 
    }st[maxn],val[maxn*30];           
    queue<Node>q;  
    int mn,root,tp,edges; 
    int siz[maxn],mx[maxn],mark[maxn],Fa[maxn],in[maxn],hd[maxn],to[maxn*30],nex[maxn*30];           
    void Add(int u,Node e) {                 
        nex[++edges]=hd[u],hd[u]=edges,val[edges]=e;   
    }    
    void getroot(int u,int ff) { 
        mx[u]=0, siz[u]=1;   
        for(int i=tree::hd[u];i;i=tree::nex[i]) {
            int v=tree::to[i];     
            if(v==ff||mark[v]) continue;   
            getroot(v,u), siz[u]+=siz[v];   
            mx[u]=max(mx[u],siz[v]);                      
        }   
        mx[u]=max(mx[u], mn-siz[u]);  
        if(mx[u] < mx[root]) root=u;    
    } 
    void bfs(int u) { 
        tp=0;
        q.push(Node(0,u));
        in[u]=u;   
        while(!q.empty()) {
            Node e=q.front(); q.pop();        
            st[++tp]=e;                            
            int x=e.u;     
            for(int i=tree::hd[x];i;i=tree::nex[i]) {
                int v=tree::to[i];   
                if(mark[v]||in[v]==u) continue;  
                in[v]=u;
                q.push(Node(e.dis+1,v));              
            }
        }      
        for(int i=tp;i>=1;--i) Add(u, st[i]);        
    }
    void divide(int u) {
        mark[u]=1;   
        bfs(u);  
        for(int i=tree::hd[u];i;i=tree::nex[i]) {
            int v=tree::to[i];   
            if(mark[v]) continue;                     
            root=0,mn=siz[v],getroot(v,u); 
            Fa[root]=u;       
            divide(root);    
        }       
    }
    void pre(int n) {
        mx[0]=1000000000,mn=n,root=0,getroot(1,0);   
        divide(root);                
    }     
}; 
int n,S; 
int L[maxn];
ll C[maxn];     
namespace Dijkstra {  
    ll d[maxn]; 
    int flag[maxn];     
    struct Node { 
        ll dis;  
        int u;         
        Node(ll dis=0,int u=0):dis(dis),u(u){}    
        bool operator<(Node b) const {
            return dis>b.dis;         
        }
    };     
    priority_queue<Node>q;         
    void del(int x,int limit,ll ge,int u) {   
        if(limit<0) return;               
        while(Divide::hd[x] && Divide::val[Divide::hd[x]].dis<=limit) {   
            int v=Divide::val[Divide::hd[x]].u;               
            Divide::hd[x]=Divide::nex[Divide::hd[x]];          
            if(flag[v]) continue;    
            d[v]=ge, flag[v]=1, q.push(Node(d[v] + C[v], v));               
        }    
        if(Divide::Fa[x]) del(Divide::Fa[x],L[u]-tree::Dis(u,Divide::Fa[x]),ge,u);         
    }
    void solve() {    
        d[S]=0,flag[S]=1;                                       
        q.push(Node(C[S],S));     
        while(!q.empty()) {
            Node e=q.top(); q.pop();         
            del(e.u, L[e.u], e.dis, e.u);                                          
        }
    }
};                   
int main() {
    using namespace IO;
    // setIO("input");                    
    n=rd(),S=rd(); 
    for(int i=1;i<n;++i) {       
        int u=rd(),v=rd();      
        tree::addedge(u,v); 
        tree::addedge(v,u);    
    }          
    tree::dfs1(1,0);
    tree::dfs2(1,1); 
    for(int i=1;i<=n;++i) L[i]=rd(), C[i]=(ll)rd(); 
    Divide::pre(n);
    Dijkstra::solve();                   
    for(int i=1;i<=n;++i) printf("%lld\n",Dijkstra::d[i]);                   
    return 0; 
}