树链剖分初步 spoj 375 hdu 3966 codeforces 191C

这几个题A的好不容易啊！！！留念一下

树链剖分初体验：

 可以解决 询问一棵树上点对间的简单路径的长度  边权的最大值最小值，并支持动态修改边权，注意，树的形态始终没有改变

另外，点权的变化可以转换为边权，即每个点的点权都转移到与父节点的边之间的边权上，根节点特殊判断

 

spoj 375

贴上我巨搓无比的代码，虽然没有别人的短，虽然没有别人的快，但是毕竟它A了 -_-!!!

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn = 20010;
const int inf = ~0u>>2;
int M[maxn<<2];
struct node{
    int s,t,w,next;
}edge[maxn*2];
int E,n;
int size[maxn] , fa[maxn] , heavy[maxn] , head[maxn] , dep[maxn] , rev[maxn] , num[maxn] , cost[maxn];
int Seg_size;
inline void Max(int &x,int y){if(x<y) x=y;}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void add_edge(int s,int t,int w)
{
    edge[E].w=w;
    edge[E].s=s;
    edge[E].t=t;
    edge[E].next=head[s];
    head[s]=E++;
}
void dfs(int u,int f)
{
    int mx=-1,e=-1;
    size[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].t;
        if(v==f) continue;
        dep[v]=dep[u]+1;
        rev[v]=i^1;
        dfs(v,u);
        size[u]+=size[v];
        if(size[v]>mx)
        {
            mx=size[v];
            e=i;
        }
    }
    heavy[u]=e;
    if(e!=-1)  fa[edge[e].t]=u;
}
inline void pushup(int rt){
    M[rt]=max(M[rt<<1],M[rt<<1|1]);
}
void build(int l,int r,int rt){
    M[rt]=inf;
    if(l==r){
        return ;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}
void update(int p,int val,int l,int r,int rt){
    if(l==r){
       M[rt]=val;
       return ;
    }
    int m=(l+r)>>1;
    if(p<=m) update(p,val,lson);
    else update(p,val,rson);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R){
        return M[rt];
    }
    int m=(l+r)>>1;
    int ret=0;
    if(L<=m) ret=max(ret,query(L,R,lson));
    if(R>m) ret=max(ret,query(L,R,rson));
    return ret;
}
void prepare()
{
    build(1,n-1,1);
    memset(num,-1,sizeof(num));
    dep[0]=0;Seg_size=0;
    for(int i=0;i<n;i++) fa[i]=i;
    dfs(0,0);    
    for(int i=0;i<n;i++)
    {
        if(heavy[i]==-1)
        {
            int pos=i;
            while(pos && edge[heavy[edge[rev[pos]].t]].t == pos)
            {
                int t=rev[pos];
                num[t]=num[t^1]=++Seg_size;
                update(Seg_size,edge[t].w,1,n-1,1);
                pos=edge[t].t;
            }
        }
    }
}
void change(int edge_id,int val)
{
    if(num[edge_id]==-1) edge[edge_id].w=edge[edge_id^1].w=val;
    else update(num[edge_id],val,1,n-1,1);
}
int calc(int u,int lca)
{
    int ans=-inf;int vi=0;
    while(u!=lca)
    {
        vi++;
        if(vi==10) break;
        int r=rev[u];
        if(num[r]==-1) Max(ans,edge[r].w),u=edge[r].t;
        else 
        {
            int p=fa[u];
            if(dep[p] < dep[lca]) p=lca;
            int l=num[r];
            int r=num[heavy[p]];
            Max(ans,query(l,r,1,n-1,1));
            u=p;
        }
    }
    return ans;
}
int lca(int u,int v)
{
    while(1)
    {
        int a=find(u),b=find(v);
        if(a==b) return dep[u] < dep[v] ? u : v;//a,b在同一条重链上
        else if(dep[a]>=dep[b]) u=edge[rev[a]].t;
        else v=edge[rev[b]].t;
    }
}
int solve(int u,int v)
{
    int p=lca(u,v);
    return max(calc(u,p),calc(v,p));
}
int main()
{
    int t,i,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        memset(head,-1,sizeof(head));
        E=0;
        scanf("%d",&n);
        for(i=0;i<n-1;i++)
        {
            scanf("%d%d%d",&a,&b,&c);a--;b--;
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        prepare();
        char op[20];
        while(scanf("%s",op)!=EOF && strcmp(op,"DONE"))
        {
            if(op[0]=='C')
            {
                scanf("%d%d",&a,&c);
                change((a-1)*2,c);
            }
            else 
            {
                scanf("%d%d",&a,&b);
                printf("%d\n",solve(a-1,b-1));
            }
        }
    }
    return 0;
}
/*
1
3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE
1
3
1
7
1 2 1
1 3 2
2 4 3
2 5 4
3 6 5
3 7 6
Query 1 7
*/

 

CF 191C

这题有更简单的 O(n)做法，这里为了锻炼树链剖分

/*
树链剖分，输入边权，p个操作，
给u，v间的简单路径的边权都加上1
最后输出所有边的边权
*/
#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn = 200010;
const int inf = ~0u>>2;
int M[maxn<<2];
int add[maxn<<2];
struct node{
    int s,t,w,next;
}edge[maxn*2];
int E,n;
int size[maxn] , fa[maxn] , heavy[maxn] , head[maxn] , vis[maxn];
int dep[maxn] , rev[maxn] , num[maxn] ;
int Seg_size;
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void add_edge(int s,int t,int w)
{
    edge[E].w=w;
    edge[E].s=s;
    edge[E].t=t;
    edge[E].next=head[s];
    head[s]=E++;
}
void dfs(int u,int f)
{
    int mx=-1,e=-1;
    size[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].t;   
        if(v==f) continue; 
        dep[v]=dep[u]+1;
        rev[v]=i^1;
        dfs(v,u);
        size[u]+=size[v];
        if(size[v]>mx)
        {
            mx=size[v];
            e=i;
        }
    }
    heavy[u]=e;
    if(e!=-1)  fa[edge[e].t]=u;
}
inline void pushup(int rt){
    M[rt]=M[rt<<1]+M[rt<<1|1];
}
void pushdown(int rt,int m){
    if(add[rt]){
        add[rt<<1]+=add[rt];
        add[rt<<1|1]+=add[rt];
        M[rt<<1]+=add[rt]*(m-(m>>1));
        M[rt<<1|1]+=add[rt]*(m>>1);
        add[rt]=0;
    }
}
void build(int l,int r,int rt){
    M[rt]=add[rt]=0;
    if(l==r){
        return ;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}
void update(int L,int R,int val,int l,int r,int rt){
    if(L<=l&&r<=R){
        M[rt]+=val;
        add[rt]+=val;
        return ;
    }
    pushdown(rt,r-l+1);
    int m=(l+r)>>1;
    if(L<=m) update(L,R,val,lson);
    if(R>m) update(L,R,val,rson);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R){
        return M[rt];
    }
    pushdown(rt,r-l+1);
    int m=(l+r)>>1;
    int ret=0;
    if(L<=m) ret+=query(L,R,lson);
    if(R>m) ret+=query(L,R,rson);
    return ret;
}
void prepare()
{
    int i;
    build(1,n,1);
    memset(num,-1,sizeof(num));
    dep[0]=0;Seg_size=0;
    for(i=0;i<n;i++) fa[i]=i;
    dfs(0,0);  
    for(i=0;i<n;i++)
    {
        if(heavy[i]==-1)
        {
            int pos=i;
            while(pos && edge[heavy[edge[rev[pos]].t]].t == pos)
            {
                int t=rev[pos];
                num[t]=num[t^1]=++Seg_size;//printf("pos=%d  val=%d t=%d\n",Seg_size,edge[t].w,t);
                update(Seg_size,Seg_size,edge[t].w,1,n,1);
                pos=edge[t].t;
            }
        }
    }
}
int lca(int u,int v)
{
    while(1)
    {
        int a=find(u),b=find(v);
        if(a==b) return dep[u] < dep[v] ? u : v;//a,b在同一条重链上
        else if(dep[a]>=dep[b]) u=edge[rev[a]].t;
        else v=edge[rev[b]].t;
    }
}
void CH(int u,int lca,int val)
{
    while(u!=lca)
    {
        int r=rev[u];
        if(num[r]==-1) edge[r^1].w+=val,edge[r].w+=val,u=edge[r].t;
        else
        {
            int p=fa[u];
            if(dep[p] < dep[lca]) p=lca;
            int l=num[r];
            r=num[heavy[p]];
            update(l,r,val,1,n,1);
            u=p;
        }
    }
}
void change(int u,int v,int val)
{
    int p=lca(u,v);
    CH(u,p,val);
    CH(v,p,val);
}
int solve(int id)
{
    int r=id;
    if(num[r]==-1) return edge[r].w;
    else return query(num[r],num[r],1,n,1);
}
int main()
{
    int t,i,a,b,c,m,ca=1,p;
    while(scanf("%d",&n)!=EOF)
    {
        memset(head,-1,sizeof(head));
        E=0;
        for(i=0;i<n-1;i++)
        {
            scanf("%d%d",&a,&b);a--;b--;
            add_edge(a,b,0);
            add_edge(b,a,0);
        }
        prepare();
        scanf("%d",&p);
        while(p--)
        {
            scanf("%d%d",&a,&b);a--;b--;
            change(a,b,1);
        }
        for(i=0;i<n-1;i++)
        {
            if(i!=0) printf(" ");
            printf("%d",solve(2*i));
        }
        puts("");
    }
    return 0;
}

 

 FZU 2082过路费

单边修改，点对求和，如果对应到线段树就是单点更新（如果是重边）  区间求和

#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef __int64 lld;
const int maxn = 200010;
const int inf = ~0u>>2;
lld M[maxn<<2];
struct node{
    int s,t,w,next;
}edge[maxn*2];
int E,n;
int size[maxn] , fa[maxn] , heavy[maxn] , head[maxn] , vis[maxn];
int dep[maxn] , rev[maxn] , num[maxn] ;
int Seg_size;
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void add_edge(int s,int t,int w){
    edge[E].w=w;
    edge[E].s=s;
    edge[E].t=t;
    edge[E].next=head[s];
    head[s]=E++;
}
void dfs(int u,int f){
    int mx=-1,e=-1;
    size[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].t;   
        if(v==f) continue; 
        dep[v]=dep[u]+1;
        rev[v]=i^1;
        dfs(v,u);
        size[u]+=size[v];
        if(size[v]>mx){
            mx=size[v];
            e=i;
        }
    }
    heavy[u]=e;
    if(e!=-1)  fa[edge[e].t]=u;
}
inline void pushup(int rt){
    M[rt]=M[rt<<1]+M[rt<<1|1];
}
void build(int l,int r,int rt){
    M[rt]=0;
    if(l==r) return ;
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}
void update(int p,int val,int l,int r,int rt){
    if(l==r){
       M[rt]=val;
       return ;
    }
    int m=(l+r)>>1;
    if(p<=m) update(p,val,lson);
    else update(p,val,rson);
    pushup(rt);
}
lld query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R)  return M[rt];
    int m=(l+r)>>1;
    lld ret=0;
    if(L<=m) ret+=query(L,R,lson);
    if(R>m) ret+=query(L,R,rson);
    return ret;
}
void prepare(){
    build(1,n-1,1);
    memset(num,-1,sizeof(num));
    dep[0]=0;Seg_size=0;
    for(int i=0;i<n;i++) fa[i]=i;
    dfs(0,0);  
    for(int i=0;i<n;i++){
        if(heavy[i]==-1){
            int pos=i;
            while(pos && edge[heavy[edge[rev[pos]].t]].t == pos){
                int t=rev[pos];
                num[t]=num[t^1]=++Seg_size;//printf("pos=%d  val=%d t=%d\n",Seg_size,edge[t].w,t);
                update(Seg_size,edge[t].w,1,n-1,1);
                pos=edge[t].t;
            }
        }
    }
}
void change(int edge_id,int val){
    if(num[edge_id]==-1) edge[edge_id].w=edge[edge_id^1].w=val;
    else update(num[edge_id],val,1,n-1,1);
}
lld calc(int u,int lca){
    lld ans=0;
    while(u!=lca){
        int r=rev[u];
        if(num[r]==-1) ans+=edge[r].w,u=edge[r].t;
        else{
            int p=fa[u];
            if(dep[p] < dep[lca]) p=lca;
            int l=num[r];
            int r=num[heavy[p]];
            ans+=query(l,r,1,n-1,1);
            u=p;
        }
    }
    return ans;
}
int lca(int u,int v){
    while(1){
        int a=find(u),b=find(v);
        if(a==b) return dep[u] < dep[v] ? u : v;//a,b在同一条重链上
        else if(dep[a]>=dep[b]) u=edge[rev[a]].t;
        else v=edge[rev[b]].t;
    }
}
lld solve(int u,int v){
    int p=lca(u,v);
    return  calc(u,p)+calc(v,p);
}
int main(){
    int t,i,a,b,c,m,ca=1,p,w;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(head,-1,sizeof(head));
        E=0;
        for(i=0;i<n-1;i++) {
            scanf("%d%d%d",&a,&b,&w);a--;b--;
            add_edge(a,b,w);
            add_edge(b,a,w);
        }
        prepare();
        int op;
        while(m--){
            scanf("%d%d%d",&op,&a,&b);
            if(op==0){
                change((a-1)*2,b);
            }
            else {
                a--;b--;
                printf("%I64d\n",solve(a,b));
            }
        }    
    }
    return 0;
}

 

 

 

hdu  3966

这一题要模拟栈的，hdu可以设置栈的大小，为了测试我代码的正确性，我猥琐了一下（不然连对不对都不知道，增加debug的难度）

突然我的代码在长度上压过很多人 -_-

截个图

#pragma comment(linker,"/STACK:100000000,100000000")
#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef int lld;
stack<int> ss;
const int maxn = 200010;
const int inf = ~0u>>2;
int M[maxn<<2];
int add[maxn<<2];
struct node{
    int s,t,w,next;
}edge[maxn*2];
int E,n;
int size[maxn] , fa[maxn] , heavy[maxn] , head[maxn] , vis[maxn];
int dep[maxn] , rev[maxn] , num[maxn] , cost[maxn] ,w[maxn];
int Seg_size;
inline void Max(int &x,int y){if(x<y) x=y;}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void add_edge(int s,int t,int w)
{
    edge[E].w=w;
    edge[E].s=s;
    edge[E].t=t;
    edge[E].next=head[s];
    head[s]=E++;
}
void dfs(int u,int f)
{
    int mx=-1,e=-1;
    size[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].t;   
        if(v==f) continue; 
        edge[i].w=edge[i^1].w=w[v];
        dep[v]=dep[u]+1;
        rev[v]=i^1;
        dfs(v,u);
        size[u]+=size[v];
        if(size[v]>mx)
        {
            mx=size[v];
            e=i;
        }
    }
    heavy[u]=e;
    if(e!=-1)  fa[edge[e].t]=u;
}
inline void pushup(int rt){
    M[rt]=M[rt<<1]+M[rt<<1|1];
}
void pushdown(int rt,int m){
    if(add[rt]){
        add[rt<<1]+=add[rt];
        add[rt<<1|1]+=add[rt];
        M[rt<<1]+=add[rt]*(m-(m>>1));
        M[rt<<1|1]+=add[rt]*(m>>1);
        add[rt]=0;
    }
}
void build(int l,int r,int rt){
    M[rt]=add[rt]=0;
    if(l==r){
        return ;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}
void update(int L,int R,int val,int l,int r,int rt){
    if(L<=l&&r<=R){
        M[rt]+=val;
        add[rt]+=val;
        return ;
    }
    pushdown(rt,r-l+1);
    int m=(l+r)>>1;
    if(L<=m) update(L,R,val,lson);
    if(R>m) update(L,R,val,rson);
    pushup(rt);
}
lld query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R){
        return M[rt];
    }
    pushdown(rt,r-l+1);
    int m=(l+r)>>1;
    lld ret=0;
    if(L<=m) ret+=query(L,R,lson);
    if(R>m) ret+=query(L,R,rson);
    return ret;
}
void prepare()
{
    int i;
    build(1,n,1);
    memset(num,-1,sizeof(num));
    dep[0]=0;Seg_size=0;
    for(i=0;i<n;i++) fa[i]=i;
    dfs(0,0);  
    for(i=0;i<n;i++)
    {
        if(heavy[i]==-1)
        {
            int pos=i;
            while(pos && edge[heavy[edge[rev[pos]].t]].t == pos)
            {
                int t=rev[pos];
                num[t]=num[t^1]=++Seg_size;//printf("pos=%d  val=%d t=%d\n",Seg_size,edge[t].w,t);
                update(Seg_size,Seg_size,edge[t].w,1,n,1);
                pos=edge[t].t;
            }
        }
    }
}
int lca(int u,int v)
{
    while(1)
    {
        int a=find(u),b=find(v);
        if(a==b) return dep[u] < dep[v] ? u : v;//a,b在同一条重链上
        else if(dep[a]>=dep[b]) u=edge[rev[a]].t;
        else v=edge[rev[b]].t;
    }
}
void CH(int u,int lca,int val)
{
    while(u!=lca)
    {
        int r=rev[u];//printf("r=%d\n",r);
        if(num[r]==-1) edge[r].w+=val,u=edge[r].t;
        else
        {
            int p=fa[u];
            if(dep[p] < dep[lca]) p=lca;
            int l=num[r];
            r=num[heavy[p]];
            update(l,r,val,1,n,1);
            u=p;
        }
    }
}
void change(int u,int v,int val)
{
    int p=lca(u,v);//    printf("p=%d\n",p);
    CH(u,p,val);
    CH(v,p,val);
    if(p){
        int r=rev[p];
       if(num[r]==-1) {
           edge[r^1].w+=val;//在此处发现了我代码的重大bug
           edge[r].w+=val;
       }
      else  update(num[r],num[r],val,1,n,1);
    }//根节点，特判 
    else w[p]+=val;
}
lld solve(int u)
{
    if(!u) return w[u];//根节点，特判 
    else
    {
        int r=rev[u];
        if(num[r]==-1) return edge[r].w;
        else return query(num[r],num[r],1,n,1);
    }
}
int main()
{
    int t,i,a,b,c,m,ca=1,p;
    while(scanf("%d%d%d",&n,&m,&p)!=EOF)
    {
        memset(head,-1,sizeof(head));
        E=0;
        for(i=0;i<n;i++) scanf("%d",&w[i]);
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&a,&b);a--;b--;
            add_edge(a,b,0);
            add_edge(b,a,0);
        }
        prepare();
        char op[10];
        while(p--)
        {
            scanf("%s",&op);
            if(op[0]=='I')
            {
                scanf("%d%d%d",&a,&b,&c);a--;b--;
                change(a,b,c);
            }
            else if(op[0]=='D')
            {
                scanf("%d%d%d",&a,&b,&c);a--;b--;
                change(a,b,-c);
            }
            else
            {
                scanf("%d",&a);a--;
                printf("%d\n",solve(a));
            }
        }
    }
    return 0;
}
/*
3 2 5
1 2 3
2 1
2 3
I 1 3 5
Q 2
D 1 2 2
Q 1 
Q 3
*/