hdu 3966(树链剖分+线段树区间更新)

传送门:Problem 3966

 https://www.cnblogs.com/violet-acmer/p/9711441.html

学习资料：

　　[1]线段树区间更新:https://blog.csdn.net/zhhe0101/article/details/53871453

　　　　　　　　　　 https://yq.aliyun.com/articles/252586

　　[2]树链剖分:http://blog.sina.com.cn/s/blog_7a1746820100wp67.html

　　 　　　　　 https://wenku.baidu.com/view/7548d8706ad97f192279168884868762caaebbfc.html?from=search

题意：

　　敌军有N个营地，这N个营地通过M条边连接；
　　每个营地有且仅有一条边连接（意味着M=N-1，就是一颗含有N个节点的树）
　　要求支持两种操作：
　　1营地u与营地v以及其之间的所有营地增加或减少ai个士兵。
　　2询问营地u当前含有的士兵个数

题解：

　　树链剖分模板题。

　　实质上树链剖分进行了点对点的一次映射，保证了重链上的点在线段树上的位置是连续的。

　　树链剖分的两个性质(转):

　　　　性质1：如果(v,u)为轻边，则siz[u] * 2 < siz[v]；

　　　　性质2：从根到某一点的路径上轻链、重链的个数都不大于logn。

　　保证了一个区间的时间复杂度是log2(n)。

　　要分清3种标号含义（易混） ：树中节点标号，树中节点对应线段树中位置标号，线段树中区间标号。

树链剖分相关数组意义 ：

　　siz[i] : 以i为根的子树的大小

　　fa[i] : i节点的父亲

　　depth[i]  : i节点的深度

　　son[i] : i节点的重儿子（所有儿子中size最大的）

　　tid[i] : i节点在线段树中对应的位置　　　　

　　top[i] : i节点所在重链的顶端节点，若为轻链，则为自身。

　　rid[i] : 线段树中所对应树中节点(作用和tid[ ] 正好相反)。

AC代码：

　　摘抄自大佬博客：

　　分析：典型的树链剖分题目，先进行剖分，然后用线段树去维护即可，注意HDU的OJ采用Windows系统，容易爆栈，所以在代码前面加上：

　　#pragma comment(linker, "/STACK:1024000000,1024000000")进行手动扩栈。

　　（但不加也可以AC）

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define ls(x)((x)<<1)
#define rs(x)((x)<<1 | 1)
const int maxn=5e4+10;

int A[maxn];
//========链式前向星========
struct Node1
{
    int to;
    int next;
}edge[maxn<<1];
int head[maxn];
int cnt;
void addEdge(int u,int v)
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
//==========================
//=========树链剖分=========
int fa[maxn];
int son[maxn];
int tid[maxn];
int rid[maxn];
int siz[maxn];
int top[maxn];
int depth[maxn];
int label;

void dfs1(int u,int f,int d)
{
    fa[u]=f;
    siz[u]=1;
    depth[u]=d;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to != f)
        {
            dfs1(to,u,d+1);
            siz[u] += siz[to];
            if(son[u] == -1 || siz[to] > siz[son[u]])
                son[u]=to;
        }
    }
}
void dfs2(int u,int newTop)
{
    top[u]=newTop;
    tid[u]=++label;
    rid[tid[u]]=u;
    if(son[u] == -1)
        return ;
    dfs2(son[u],newTop);
    for(int i=head[u];~i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to != son[u] && to != fa[u])
            dfs2(to,to);
    }
}
//==========================
//==========线段树==========
struct Node2
{
    int l,r;
    int val;
    int lazy;
    int mid(){
        return l+((r-l)>>1);
    }
}segTree[maxn<<2];
void buildTree(int l,int r,int pos)
{
    segTree[pos].l=l,segTree[pos].r=r;
    segTree[pos].lazy=0;
    if(l == r)
    {
        segTree[pos].val=A[rid[l]];
        return ;
    }
    int mid=l+((r-l)>>1);
    buildTree(l,mid,ls(pos));
    buildTree(mid+1,r,rs(pos));
}
void pushDown(int pos)
{

    if(segTree[pos].lazy != 0)
    {
        segTree[ls(pos)].lazy += segTree[pos].lazy;
        segTree[rs(pos)].lazy += segTree[pos].lazy;

        //segTree[ls(pos)].val += segTree[pos].lazy;
        //segTree[rs(pos)].val += segTree[pos].lazy;

        segTree[pos].lazy=0;
    }
}
void update(int a,int b,int val,int pos)
{
    if(a <= segTree[pos].l && b >= segTree[pos].r)
    {
        segTree[pos].lazy += val;
        //segTree[pos].val += val;
        return ;
    }
    pushDown(pos);

    int mid=segTree[pos].mid();
    if(b <= mid)
        update(a,b,val,ls(pos));
    else if(a > mid)
        update(a,b,val,rs(pos));
    else
    {
        update(a,mid,val,ls(pos));
        update(mid+1,b,val,rs(pos));
    }
}
int query(int k,int pos)
{
    if(segTree[pos].l == segTree[pos].r)
        return segTree[pos].val+segTree[pos].lazy;

    pushDown(pos);
    int mid=segTree[pos].mid();

    if(k <= mid)
        return query(k,ls(pos));
    else
        return query(k,rs(pos));
}
//==========================
void Find(int a,int b,int val)
{
    while(top[a] != top[b])
    {
        if(depth[top[a]] > depth[top[b]])
        {
            update(tid[top[a]],tid[a],val,1);
            a=fa[top[a]];
        }
        else
        {
            update(tid[top[b]],tid[b],val,1);
            b=fa[top[b]];
        }
    }
    if(tid[a] > tid[b])
        swap(a,b);
    update(tid[a],tid[b],val,1);
}

void init()
{
    cnt=0;
    memset(head,-1,sizeof(head));
    label=0;
    memset(son,-1,sizeof(son));
}
int main()
{
    int n,m,q;
    while(~scanf("%d%d%d",&n,&m,&q))
    {
        init();
        for(int i=1;i <= n;++i)
            scanf("%d",A+i);
        for(int i=1;i <= m;++i)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addEdge(u,v);
            addEdge(v,u);
        }
        dfs1(1,1,0);
        dfs2(1,1);
        buildTree(1,label,1);
        char op[3];
        for(int i=1;i <= q;++i)
        {
            scanf("%s",op);
            if(op[0] == 'Q')
            {
                int c;
                scanf("%d",&c);
                printf("%d
",query(tid[c],1));
            }
            else
            {
                int c1,c2,k;
                scanf("%d%d%d",&c1,&c2,&k);
                if(op[0] == 'D')
                    k = -k;
                Find(c1,c2,k);
            }
        }
    }
    return 0;
}

---

分割线：2019.5.10

省赛倒计时2天；

重新温习了一下树链剖分，改了改代码风格：

#pragma comment(linker,"/STACK:1024000000,1024000000")///手动扩栈
#include<bits/stdc++.h>
using namespace std;
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=5e4+50;

int n,m,q;///n个点 ，m条边(m=n-1)，q次询问
int a[maxn];///a[i]:初始i营地有a[i]个士兵
int num;
int head[maxn];
struct Edge
{
    int to;
    int next;
}G[maxn<<1];
void addEdge(int u,int v)
{
    G[num]=Edge{v,head[u]};
    head[u]=num++;
}
int fa[maxn];
int tid[maxn];
int rid[maxn];
int siz[maxn];
int son[maxn];
int top[maxn];
int dep[maxn];
struct Seg
{
    int l,r;
    int val;
    int lazy;
    int mid(){return l+((r-l)>>1);}
    int len(){return r-l+1;};
}seg[maxn<<2];

void pushDown(int pos)
{
    int &lazy=seg[pos].lazy;
    if(lazy)
    {
        seg[ls(pos)].lazy += lazy;
        seg[rs(pos)].lazy += lazy;
    }
    lazy=0;
}
void buildSegTree(int l,int r,int pos)
{
    seg[pos].l=l;
    seg[pos].r=r;
    seg[pos].lazy=0;
    seg[pos].val=0;
    if(l == r)
    {
        seg[pos].val=a[rid[l]];///l点在树中对应的编号rid[l]
        return ;
    }
    int mid=l+((r-l)>>1);
    buildSegTree(l,mid,ls(pos));
    buildSegTree(mid+1,r,rs(pos));
}
int Query(int l,int pos)
{
    if(seg[pos].l == seg[pos].r)
        return seg[pos].val+seg[pos].lazy;

    pushDown(pos);

    int mid=seg[pos].mid();
    if(l <= mid)
        return Query(l,ls(pos));
    else
        return Query(l,rs(pos));
}
void Update(int l,int r,int pos,int val)
{
    if(seg[pos].l == l && seg[pos].r == r)
    {
        seg[pos].lazy += val;
        return ;
    }
    pushDown(pos);

    int mid=seg[pos].mid();
    if(r <= mid)
        Update(l,r,ls(pos),val);
    else if(l > mid)
        Update(l,r,rs(pos),val);
    else
    {
        Update(l,mid,ls(pos),val);
        Update(mid+1,r,rs(pos),val);
    }
}
void Find(int u,int v,int val)
{
    while(top[u] != top[v])///u,v不在同一条重链上
    {
        if(dep[top[u]] > dep[top[v]])
            swap(u,v);

        Update(tid[top[v]],tid[v],1,val);///让u,v一步一步靠到同一条重链上
        v=fa[top[v]];
    }
    ///return 语句根据题意而定
    ///再此题中，u==v时就是单点更新
//    if(u == v)
//        return ;
    if(dep[u] > dep[v])
        swap(u,v);
    ///这次不是tid[son[u]],因为上次是边权存在了儿子节点里
    Update(tid[u],tid[v],1,val);
}
void DFS1(int u,int f,int depth)
{
    fa[u]=f;
    siz[u]=1;
    dep[u]=depth;
    for(int i=head[u];~i;i=G[i].next)
    {
        int v=G[i].to;
        if(v == f)
            continue;

        DFS1(v,u,depth+1);

        siz[u] += siz[v];
        if(son[u] == -1 || siz[v] > siz[son[u]])
            son[u]=v;
    }
}
void DFS2(int u,int anc,int &k)
{
    tid[u]=++k;
    rid[k]=u;
    top[u]=anc;
    if(son[u] == -1)
        return ;
    DFS2(son[u],anc,k);

    for(int i=head[u];~i;i=G[i].next)
    {
        int v=G[i].to;
        if(v != fa[u] && v != son[u])
            DFS2(v,v,k);
    }
}
void Solve()
{
    DFS1(1,0,0);
    int k=0;
    DFS2(1,1,k);
    buildSegTree(1,k,1);

    char order[10];
    while(q--)
    {
        scanf("%s",order);
        if(order[0] == 'Q')
        {
            int u;
            scanf("%d",&u);
            printf("%d
",Query(tid[u],1));///单点查询，查询u营地当前的人数
        }
        else
        {
            int u,v,val;
            scanf("%d%d%d",&u,&v,&val);///区间更新，更新营地[u,v]人数 +val
            if(order[0] == 'D')
                val=-val;///人数减少
            Find(u,v,val);
        }
    }
}
void Init()
{
    num=0;
    mem(head,-1);
    mem(son,-1);
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&q))
    {
        Init();
        for(int i=1;i <= n;++i)
            scanf("%d",a+i);
        for(int i=1;i <= m;++i)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addEdge(u,v);
            addEdge(v,u);
        }
        Solve();
    }
    return 0;
}