hdu3966(树连剖分模板-节点价值建树)

最新推荐文章于 2021-07-22 14:12:53 发布
最新推荐文章于 2021-07-22 14:12:53 发布
阅读量419 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法模板 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxsmile/article/details/48813863
本文详细介绍了裸的树连剖分模板，并以节点价值为切入点，探讨如何构建树形结构。文章提供了AC代码作为示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

裸的树连剖分，做成模板写的

ACcode:

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<sstream>
#include<string>
#include<bitset>
using namespace std;

typedef long long LL;

const LL LINF = (1LL <<63);
const int INF = 1 << 31;


const int NS = 500010;
const int MS = 19;
const int MOD = 1000000007;

typedef int segValueType;
const int TSIZE = NS;
struct segNode{
    int ls, rs;             //左右儿子的节点ID
    int lid, rid, len;      //节点的左右边界及长度
    segValueType minv, maxv;       //记录子树节点的价值最值
    segValueType sumv;             //记录子树节点的价值和
    segValueType addv;             //记录子树节点的增量

    bool isLeaf()
    {
        return (lid == rid);
    }

    void printData()
    {
    //    cout<<"("<<lid<<","<<rid<<") max = "<<maxv<<" min = "<<minv<<" sum = "<<sumv<<" add = "<<addv<<endl;
        printf("(%3d,%3d) max = %3d min = %3d sum = %3d add = %d\n", lid, rid, maxv, minv, sumv, addv);
    }
};

struct SegmentTree{
    #define lson(x) (x << 1)
    #define rson(x) ((x << 1) + 1)
    #define pmid(l, r) ((l + r) >> 1)

    int maxrt;
    segNode wt[TSIZE << 2];
    segValueType val[TSIZE];


    segValueType cmax(segValueType va, segValueType vb)
    {
        return (va > vb? va : vb);
    }

    segValueType cmin(segValueType va, segValueType vb)
    {
        return (va < vb? va : vb);
    }

    void PushUpUpdate(int rt)
    {
        int ls = wt[rt].ls;
        int rs = wt[rt].rs;

        wt[rt].maxv = cmax(wt[ls].maxv, wt[rs].maxv);
        wt[rt].minv = cmin(wt[ls].minv, wt[rs].minv);

        wt[rt].sumv = wt[ls].sumv + wt[rs].sumv;
    }

    void PushDownUpdate(int rt)
    {
        if(0 != wt[rt].addv)
        {
            int ls = wt[rt].ls;
            int rs = wt[rt].rs;

            segValueType addv = wt[rt].addv;

            wt[ls].addv += addv;
            wt[ls].maxv += addv;
            wt[ls].minv += addv;
            wt[ls].sumv += wt[ls].len * addv;

            wt[rs].addv += addv;
            wt[rs].maxv += addv;
            wt[rs].minv += addv;
            wt[rs].sumv += wt[rs].len * addv;

            wt[rt].addv = 0;
        }
    }

    void build(int rt, int l, int r)
    {
        if(rt > maxrt) maxrt = rt;
 //       printf("(%d,%d,%d)\n", rt, l, r);
        wt[rt].len = r - l + 1;
        wt[rt].lid = l;
        wt[rt].rid = r;
        wt[rt].addv = 0;
        if(l == r)
        {
            wt[rt].ls = -1;
            wt[rt].rs = -1;
            wt[rt].maxv = wt[rt].minv = val[r];
            wt[rt].sumv = val[r];
            return ;
        }
        else
        {
            wt[rt].ls = lson(rt);
            wt[rt].rs = rson(rt);
        }
        int mid = pmid(wt[rt].lid, wt[rt].rid);
        build(lson(rt), l, mid);
        build(rson(rt), mid + 1, r);
        PushUpUpdate(rt);
    }

    void update(int rt, int l, int r, int op, segValueType value)
    {
        if(l <= wt[rt].lid && wt[rt].rid <= r)
        {
            //如果操作为区间增加val
            wt[rt].addv += value;
            wt[rt].maxv += value;
            wt[rt].minv += value;
            wt[rt].sumv += value * wt[rt].len;
            return ;
        }

        if(wt[rt].isLeaf())
        {
            //正常情况是不会进入此判断的
            printf("线段树异常询问：rt = %2d l = %2d r = %2d op = %2d val = %2d\n", rt, l, r, op, value);
            return ;
        }
        PushDownUpdate(rt);

        int mid = pmid(wt[rt].lid, wt[rt].rid);

        if(l <= mid)
        {
            update(lson(rt), l, r, op, value);
        }
        if(r > mid)
        {
            update(rson(rt), l, r, op, value);
        }
        PushUpUpdate(rt);
    }

    segValueType query(int rt, int l, int r, int op)
    {
        if(l <= wt[rt].lid && wt[rt].rid <= r)
        {
            segValueType res;
            if(1 == op)                 //查询最大值
            {
                res = wt[rt].maxv;
            }
            else if(2 == op)            //查询最小值
            {
                res = wt[rt].minv;
            }
            else if(3 == op)            //查询区间和
            {
                res = wt[rt].sumv;
            }
            return res;
        }
        PushDownUpdate(rt);

        int mid = pmid(wt[rt].lid, wt[rt].rid);

        segValueType res;

        if(l > mid)
        {
            res = query(rson(rt), l, r, op);
        }
        else if(r <= mid)
        {
            res = query(lson(rt), l, r, op);
        }
        else
        {
            if(1 == op)                 //查询最大值
            {
                res = cmax(query(lson(rt), l, r, op), query(rson(rt), l, r, op));
            }
            else if(2 == op)            //查询最小值
            {
                res = cmin(query(lson(rt), l, r, op), query(rson(rt), l, r, op));
            }
            else if(3 == op)            //查询区间和
            {
                res = query(lson(rt), l, r, op) + query(rson(rt), l, r, op);
            }
        }
        return res;
    }

    void printNode(int rt)
    {
        printf("rt = %3d", rt);
        wt[rt].printData();
    }

    void printAll()
    {
        for(int i = 1; i <= maxrt; i++)
        {
            if(wt[i].lid > 0)
            {
                printNode(i);
            }
        }
    }
};

const int EDGE_MAX = NS;
struct graphEdge{
    int pst;
    int next;
    int val;
};

struct ForwardStart{
    int top;
    int head[EDGE_MAX];
    graphEdge edge[EDGE_MAX << 1];

    void init()
    {
        top = 0;
        memset(head, -1, sizeof(head));
    }

    //添加一条u->v的边
    void addEdge(int u, int v, int val)
    {
        edge[top].pst = v;
        edge[top].val = val;
        edge[top].next = head[u];
        head[u] = top++;
    }

    void printAll()
    {
        printf("top = %d\n", top);
        for(int i = 1; i < EDGE_MAX; i++)
        {
            if(-1 != head[i])
            {
                printf("head[%2d]'son:%2d", i, edge[head[i]].pst);
                for(int j = edge[head[i]].next; j != -1; j = edge[j].next)
                {
                    printf(",%2d", edge[j].pst);
                }
                puts("");
            }
        }
    }
};

int n, m, q;

struct chainNode{
    int fa;         //父节点ID
    int dep;        //节点深度
    int scnt;       //子树节点总数
    int top;        //重链第一个节点
    int hson;       //重儿子ID
    int tpos;       //节点在线段树中的位置

    void init(int _fa, int _dep)
    {
        fa = _fa;
        dep = _dep;
        scnt = 1;
        hson = -1;

        top = -1;
        tpos = -1;
    }

    void printData()
    {
        printf("fa = %2d dep = %2d scnt = %2d top = %2d hson = %2d tpos = %2d\n", fa, dep, scnt, top, hson, tpos);
    }
};

const int CHAIN_MAX = NS;
struct TreeChain{
    int val[CHAIN_MAX];
    int treeMaxNode;
    SegmentTree sTree;
    ForwardStart cTree;
    chainNode cNode[CHAIN_MAX];

    void buildTreeChain()
    {
        treeMaxNode = 0;
        dfsBase(1, -1, 1);
     //   printAll();
        dfsChain(1, -1, 1);
        sTree.build(1, 1, treeMaxNode);
   //     sTree.printAll();
    }

    void dfsBase(int rt, int fa, int dep)
    {
      //  printf("dfsBase:rt = %3d fa = %3d dep = %3d\n", rt, fa, dep);
        cNode[rt].init(fa, dep);

        int maxCnt = -1, hson = -1;
        for(int i = cTree.head[rt]; i != -1; i = cTree.edge[i].next)
        {
            int curson = cTree.edge[i].pst;
            if(curson == fa) continue;

            dfsBase(curson, rt, dep + 1);
            cNode[rt].scnt += cNode[curson].scnt;

            if(maxCnt < cNode[curson].scnt)
            {
                maxCnt = cNode[curson].scnt;
                hson = curson;
            }

        }
        cNode[rt].hson = hson;
    }

    void dfsChain(int rt, int fa, int top)
    {
     //   printf("dfsChain:rt = %3d fa = %3d top = %d\n", rt, fa, top);
        cNode[rt].top = top;
        cNode[rt].tpos = ++treeMaxNode;
        sTree.val[treeMaxNode] = val[rt];

        int hson = cNode[rt].hson;
        if(hson >= 0)
        {
            dfsChain(hson, rt, top);
        }

        for(int i = cTree.head[rt]; i != -1; i = cTree.edge[i].next)
        {
            int curson = cTree.edge[i].pst;
            if(curson == fa || hson == curson) continue;

            dfsChain(curson, rt, curson);
        }
    }

    void update(int u, int v, int value)
    {
     //   printf("##########tChain.update(%2d, %2d, %2d)", u, v, value);
        int topu = cNode[u].top;
        int topv = cNode[v].top;


        int l, r;
        if(topu == topv)
        {
            l = cNode[u].tpos;
            r = cNode[v].tpos;
            if(l > r) swap(l, r);
        //    printf(" a:l = %2d r = %2d\n", l, r);
            if(l <= 0)
            {
                printf("*****(1)树连剖分update异常：u = %d v = %d val = %d\n", u, v, value);
            //    return ;
            }
            sTree.update(1, l, r, 1, value);
        }
        else
        {
            int nextu = u;
            int nextv = v;

            int deptopu = cNode[topu].dep;
            int deptopv = cNode[topv].dep;
        //    printf(" topu = %2d(%2d) topv = %2d(%2d)", topu, deptopu, topv, deptopv);
            if(deptopu > deptopv)
            {
                l = cNode[topu].tpos;
                r = cNode[u].tpos;
                nextu = cNode[topu].fa;
            }
            else
            {
                l = cNode[topv].tpos;
                r = cNode[v].tpos;
                nextv = cNode[topv].fa;
            }
            sTree.update(1, l, r, 1, value);
            if(l <= 0)
            {
                printf("*****(2)树连剖分update异常：u = %d v = %d val = %d\n", u, v, value);
            //    return ;
            }
        //    printf(" b:l = %2d r = %2d\n", l, r);
            update(nextu, nextv, value);
        }
    }

    int query(int u, int v, int op)
    {
     //   printf("tChain.query(%2d, %2d, %2d)", u, v, op);
        int topu = cNode[u].top;
        int topv = cNode[v].top;

        int l, r;
        int ans;
        if(topu == topv)
        {
            l = cNode[u].tpos;
            r = cNode[v].tpos;
            if(l > r) swap(l, r);
            ans = sTree.query(1, l, r, op);
        //    printf(" l = %2d r = %2d\n", l, r, ans);
        }
        else
        {
            int nextu = u;
            int nextv = v;
            int deptopu = cNode[topu].dep;
            int deptopv = cNode[topv].dep;
            if(deptopu > deptopv)
            {
                l = cNode[topu].tpos;
                r = cNode[u].tpos;
                nextu = cNode[topu].fa;
            }
            else
            {
                l = cNode[topv].tpos;
                r = cNode[v].tpos;
                nextv = cNode[topv].fa;
            }
            ans = sTree.query(1, l, r, op);
          //  printf(" l = %2d r = %2d\n", l, r, ans);
            ans = max(ans, query(nextu, nextv, op));
        }
      //  printf(" query(%2d, %2d, %2d) = %d\n", u, v, op, ans);
        return ans;
    }

    void printNode(int rt)
    {
        printf("rt = %2d ", rt);
        cNode[rt].printData();
    }

    void printAll()
    {
        for(int i = 1; i < CHAIN_MAX; i++)
        {
            if(cNode[i].scnt > 0)
            {
                printNode(i);
            }
        }
    }
}tChain;

int main()
{

//    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);

    while(~scanf("%d %d %d", &n, &m, &q))
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &tChain.val[i]);
        }

        tChain.cTree.init();
        int u, v;
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &u, &v);
            tChain.cTree.addEdge(u, v, 1);
            tChain.cTree.addEdge(v, u, 1);
        }
      //  printf("input compelete!!!\n");
     //   tChain.cTree.printAll();

        tChain.buildTreeChain();

        int a,b,c;
        char ch[10];
        for(int i = 1; i <= q; i++)
        {
            scanf("%s", ch);
            if('I' == ch[0])
            {
                scanf("%d %d %d", &a, &b, &c);
                tChain.update(a, b, c);
            }
            else if('D' == ch[0])
            {
                scanf("%d %d %d", &a, &b, &c);
                tChain.update(a, b, -c);
            }
            else
            {
                scanf("%d", &a);
                int ans = tChain.query(a, a, 1);
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}


树形DP <简单树形DP 对我来说重点在建树> hlg 1474
Fighting..
07-19 891
受挫了.. 主要是题做的还太少了..而且我基础不踏实..建树都建不好.. 加油吧~ 题意： 给出 n 个节点和 m 个关系.. 保证是一棵树..父子节点不能同时出现..根节点一定要有..求节点出现最多值.. 思路： 叶节点的值是可以肯定的..从下往上DP就好.. 对我来说难点还是不会建树.. Tips: 初始条件： dp[ leaf ][
HDU 5293 树链剖分 + 树形DP
新熊君的博客
02-03 459
题目链接题意： 给定有nn个节点的树和mm条链(链连接两个顶点，且有权值)，要求选出一部分链，使连接以后图的每个圈没有公共节点，问能够选出的链的权值和最大为多少？考虑树形DP。对于当前顶点uu，假设dp[u]dp[u]为以uu为根节点的子树所能够达到的最大目标值。 另外定义： 1.ww为当前考虑的链权值。 2.sum[u]=∑dp[k]sum[u] = \sum dp[k](kk为uu的子节
建树/图的方法
不忘初心
02-14 5504
建树： 二叉树： 法一：题目按照节点顺序给出树的值和左右子树的编号，可以把信息直接存在结构体数组，不用再建树，不过得找出树根 法二：题目按照节点顺序给出树的值和左右子树的编号，先找到树根，再层序建树。建成的树可以是指针型或者数组型(堆的结构)（这里的数组型得是结构体数组，因为要存当前结点在源数据中的编号），具体由数据规模和方便程度决定 二叉搜索树： 法一：题目给出数据，直接按照二叉树建树
hdu3966树链剖分 分析
weixin_50904510的博客
07-22 307
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=5e4+5; int m,n,p,size[maxn],deep[maxn],f[maxn],son[maxn]; int cnt,head[maxn],nid[maxn],oid[maxn],ncnt,top[maxn]; ll a[maxn]; struct stree{ ll value,lazy; }t[maxn<&.
hdu3966 树链剖分+线段树 裸题
weixin_30662539的博客
07-28 108
HDU - 3966 题意：给一颗树，3种操作，Q u 查询u节点的权值，I a b c 对a到b的路径上每个点的点权增加c，D a b c 对a b 路径上所有点的点权减少c 思路：树链剖分+线段树，2个问题，第一，如果是先建树再输入点的点权，记录tip（点映射到线段树后的位置），如果先输入点权，再建树，不仅要记录tip还要记录ran（线段树上某个位置上的点对应的树上点的序号，与tip是相...
hdu3966 树链剖分模板(点权，修改区间查询点)
weixin_34194379的博客
10-01 143
1 #pragma comment(linker, "/STACK:1024000000,1024000000") 2 #include<stdio.h> 3 #include<string.h> 4 int now,cnt,n,a[50005]; 5 int next[100005],head[50005],point[100005]; ...
树链剖分+线段树 hdu3966 Aragorn's Story
qwb的博客
12-02 913
传送门：点击打开链接 题意：路径更新，单点查询 思路：线段树+树链剖分，这里其实不需要懒惰标记也是可以做的 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define fuck(x) c
hdu5029 树链剖分
creater_X
10-04 837
这题绝对好题。
hdu 5044 Tree(树链剖分）
铅笔头的博客
09-02 320
题意：给一个简单图，在图上进行n此操作，最后按顺序输出点权和边权的值。T组数据，每组数据第一行两个数n，m分别代表树的点数，操作的次数，接下来n-1行每行两个数表示一条边。接下来m行表示m次操作，每次操作有一一个字符串add1，或add2，接下来是三个数u，v，c。add1表示在修改点权u->v的路径上的点加c，add2表示修改边权u->v的路径上的边权加c。解题思路：知道题虽然是比较经典的树链剖分
树链剖分之HLD
RBS的专栏
01-02 2748
树链剖分的原理对于数组这样的线性结构，要在其上实现区间查询（和与最值）、区间修改甚至是区间增删都是有办法的。例如Sparse Table算法、树状数组、线段树以及伸展树等。而树是一种非线性结构，为了高效的实现在树上的路径查询、路径修改操作，基本做法是将树按照某种方式剖成若干条链，再将这些链按照顺序组成数组，最后在数组上采用线段树等手段实现操作。 考虑如下一棵树： 可以把它剖成6条链，分别是A
HDU-1269（Tarjan模板-求强连通分量）
01-03
 Tarjan模板题 补习： AC code: /* Tarjan求有向图的强连通分量， */ #include #include #include #include #include using namespace std; const int MAXN = 1e5 + 10; struct Edge{ int to, next, dis; }edge...
hdu网安计网实验1.0-4.4
最新发布
07-02
本系列实验集hdu网安计网实验1.0-4.4，涵盖了计算机网络的基础知识和一些进阶的应用技能。实验内容可能包括但不限于网络模型的理解，如OSI七层模型和TCP/IP模型，以及它们在数据传输过程中的作用和特点；网络协议的...
hi3861-hdu-iot-application-master.zip
02-13
随着技术的不断发展，物联网（IoT）成为了一个热门的研究领域，其核心在于通过网络技术将物理设备连接起来，实现智能化管理和控制。OpenHarmony作为一款开源操作系统，为物联网设备的开发提供了强大的支持。...
树的重心
丿Ｓmilē 丶晨星灬
04-13 2019
看了几天树的重心的题目，也做了几个题，总结一下。 首先，定义一下重心，网上还有一种定义，效果一样，纯属个人理解。 节点重心的定义是：以这个点为根，那么所有的子树（不算整个树自身）的节点权值大小都不超过整个树大小的一半。 边权重心的定义是：以这个点为根，那么所有的子树（不算整个树自身）的边权值大小都不超过整个树大小的一半。 树的重心主要解决树中点对之间路径最短的问题。
hdu4630 线段树||树状数组离线处理
丿Ｓmilē 丶晨星灬
07-30 1567
比赛时候没想到，感觉弱爆了，做了两个月线段树白做了。。。。白做了。。。。 ACcode： #include #include #include #include using namespace std; const int NS=50050; struct node{ int l,r,id; bool operator < (const node cmp) const
uva11983 线段树之k次面积交
丿Ｓmilē 丶晨星灬
11-14 1079
之前做过一个类似的，加个循环就好了 ACcode： #include #include #include #define LL long long using std::sort; const int nsize=33333; struct Line { int lx,rx,y,f; Line(){} Line(int a,int b,int c,i
CF286D 扫描线+STL
丿Ｓmilē 丶晨星灬
04-07 1045
看到题目很容易想到用线段树写，不过为了挑战一下自己的思维，看了别人的代码，纠结的将思路理清楚了，磨蹭了一天才搞定。 首先将线段离散化，求出每个预处理的线段的刚好通过和刚好通不过的时间边界，最后按时间顺序扫描。 ps：用结构体内部排序比外部排序开了将近3倍。 ACcode： #include #include #include #include using nam
hdu3016 线段树+简单DP
丿Ｓmilē 丶晨星灬
11-06 933
看题目都看了半天，各种小条件，看了网上的思路才算把题目理解清楚了，主要是先按高度排序，再用线段树从下到上记录每块木板左右两边能跳到的id。然后从上到下作DP。中途能量不能小于1. ACcode： #include #include #include using std::sort; const int nsize=111111; const int INF=100000000; i
hdu4426 manacher算法+Hash
丿Ｓmilē 丶晨星灬
11-07 925
参考了网上的思路，第一次写hash， 写得很纠结 ，结果因为统计的时候超int了，调到想死。。。 ACcode： #include #include #include #include #include using namespace std; typedef long long LL; const int PR=37; const int NS=111110; const in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值