[SDFZOJ]1069:树上统计

神题。。。std丑的不行。

我们可以发现i->i+1的边被覆盖过i×(n-i)次。

因为以1->i为左端点，以i+1->n的为右端点，i->i+1都将被覆盖这么多次。

然后从1->n扫，i->i+1的路径上的边的贡献就是n×(n-i)×边数-路径上的标记和×(n-i)。因为标记的意义就是它最后一次被覆盖是什么时候。如果tag是k，那么之前1->k为左端点就都统计过这个了。所以就要减标记和×(n-i)（由上面的话可知是n-i次），然后在路径上上打大小为i的tag。具体实现就是树剖+线段树。（我的树剖是直接粘的板子。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<stack>
#include<algorithm>
#include<cstdlib>
using namespace std;
const int N=;
int n,m,r,a[N],head[N],ecnt,siz[N],fa[N],dep[N],son[N],dfn1[N],dfn2[N],top[N],ncnt,rnk[N];
struct Segtree {
    int sum,lazy,l,r;
} seg[N<<];
struct Edge {
    int to,nxt;
} e[N<<];
inline void pushup(int x) {
    seg[x].sum=seg[x<<].sum+seg[x<<|].sum;

}
inline void add(int bg,int ed){
    e[++ecnt].nxt=head[bg];
    e[ecnt].to=ed;
    head[bg]=ecnt;
}
void build(int L,int R,int x) {
    seg[x].l=L,seg[x].r=R;
    if(L==R) {
        seg[x].sum=a[rnk[L]];
        return;
    }
    int mid=(L+R)>>;
    build(L,mid,x<<);
    build(mid+,R,x<<|);
    pushup(x);
}

inline void pushdown(int x) {
    if(seg[x].lazy) {
        if(seg[x].l!=seg[x].r) {
            seg[x<<].sum=seg[x].lazy*(seg[x<<].r-seg[x<<].l+);

            seg[x<<|].sum=(seg[x].lazy)*(seg[x<<|].r-seg[x<<|].l+);

            seg[x<<].lazy=seg[x].lazy;

            seg[x<<|].lazy=seg[x].lazy;

        }
        seg[x].lazy=;
    }
}
void update(int L,int R,int x,int c) {
    if(R<seg[x].l||L>seg[x].r)return;
    if(L<=seg[x].l&&seg[x].r<=R) {
        seg[x].lazy=c;
        seg[x].sum=(seg[x].r-seg[x].l+)*c;

        return;
    }
    pushdown(x);
    update(L,R,x<<,c);
    update(L,R,x<<|,c);
    pushup(x);
}
int query(int L,int R,int x){
    if(L>seg[x].r||R<seg[x].l)return ;
    if(L<=seg[x].l&&seg[x].r<=R){
        return seg[x].sum;
    }
    pushdown(x);
    return (query(L,R,x<<)+query(L,R,x<<|));
}
void dfs1(int x){
    siz[x]=;
    for(int i=head[x];i;i=e[i].nxt){
        int v=e[i].to;
        if(fa[x]==v) continue;
        fa[v]=x;
        dep[v]=dep[x]+;
        dfs1(v);
        siz[x]+=siz[v];
        if(siz[v]>siz[son[x]]) son[x]=v;
    }
}
void dfs2(int x,int qtop){
    top[x]=qtop;dfn1[x]=++ncnt;
    rnk[dfn1[x]]=x;
    if(son[x]) dfs2(son[x],qtop);
    for(int i=head[x];i;i=e[i].nxt){
        int v=e[i].to;
        if(v==fa[x]||v==son[x]) continue;
        dfs2(v,v);
    }
    dfn2[x]=ncnt;
}
void add_v(int x,int y,int z){
    int f1=top[x],f2=top[y];
    while(f1!=f2){
        if(dep[f1]<dep[f2]) swap(f1,f2),swap(x,y);
        update(dfn1[f1],dfn1[x],,z);
        x=fa[f1],f1=top[x];
    }
    if(dep[x]>dep[y]) update(dfn1[y],dfn1[x],,z);
    else update(dfn1[x],dfn1[y],,z);
}
inline int query_path(int x,int y){
    int f1=top[x],f2=top[y],ans=;
    while(f1!=f2){
        if(dep[f1]<dep[f2]) swap(f1,f2),swap(x,y);
        ans+=query(dfn1[f1],dfn1[x],);
        x=fa[f1],f1=top[x];
    }
    if(dep[x]>dep[y]) ans+=query(dfn1[y],dfn1[x],);
    else ans+=query(dfn1[x],dfn1[y],);
    return ans;
}
inline 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;
}
signed main() {
    cin>>n;
    int u,v,b,c;
    for(int i=;i<n;i++){
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    dfs1();
    dfs2(,);
    build(,n,);
    long long ans=;
    for(int i=,lca;i<n;i++) {
        lca=LCA(i,i+);
        ans+=(1ll*(dep[i]-dep[lca]+dep[i+]-dep[lca])*(n-i)*i-1ll*(query_path(i,i+)-query_path(lca,lca))*(n-i));
        int tp=query_path(lca,lca);
        add_v(i,i+,i);add_v(lca,lca,tp);
    }
    cout<<ans<<endl;
    return ;
}

树上统计