【例题】【树链剖分】

最新推荐文章于 2022-04-01 14:24:51 发布
最新推荐文章于 2022-04-01 14:24:51 发布
阅读量720 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y__XV/article/details/53868889
版权

1、
【USACO 2011 Dec Gold 】种草
时间限制 : 10000 MS 空间限制 : 65536 KB

问题描述
农夫约翰有N块贫瘠的牧场(2 <= N <= 100,000)，有N-1条双向道路将这N个牧场连接了起来，每两个牧场间都有且仅有一条路径可相互到达。著名奶牛贝西经常抱怨：为什么连接牧场的道路上没有草可吃呢?
约翰非常喜欢贝西，今天约翰终于决定要在道路上种草了。约翰的种草工作被分成了M(1 <= M <=100,000)步操作。
在每一步中，下列两个事件中的一个会发生：
1.约翰会选择两个牧场，沿着两个牧场间的路径,在路径上的每一条道路上都种植1株牧草；
2.贝西会向约翰提问：在一条指定的道路上，种植了多少株牧草；
请帮助约翰回答贝西的问题。

输入格式
第一行，两个空格间隔的整数N和M
接下来N-1行，每行两个整数x和y，表示牧场x和y之间有道路直接相连
接下来M行，每行描述一步操作：
每行以字母P或Q作为开头，P代表种草操作，Q代表询问操作，接下来两个整数，A_i 和 B_i用于描述该步的操作(1 <= A_i, B_i <= N)。

输出格式
对于每一次询问，输出一行，一个整数，表示询问的答案

样例输入
4 6
1 4
2 4
3 4
P 2 3
P 1 3
Q 3 4
P 1 4
Q 2 4
Q 1 4

样例输出
2
1
2
思路：
树剖步骤：
1、深搜：找重链、找爸爸
2、再深搜：标链祖先、重标id
3、维护加乱搞：拆成多段…

注意：该题将边权值存储在点上，所以每次操作中最后在主链上的操作需要将x++，否则会多算一条，但是可能x++后出现x>y的情况，需特判

#include<cstdio>
#include<iostream>
using namespace std;
const int need=100004;

//............................................
inline void inc(char &c)
{
    c=getchar();
    while(c==' '||c==10) c=getchar();
} 
inline void in_(int &d)
{
    char t=getchar();
    while(t<'0'||t>'9') t=getchar();
    for(d=0;!(t<'0'||t>'9');t=getchar()) d=(d<<1)+(d<<3)+t-'0';
}
inline void out_(int x)
{
    if(x>=10) out_(x/10);
    putchar(x%10+'0');
}
//............................................
int tot;
int fi[need],la[need<<1],en[need<<1];

inline void add()
{
    int a,b;in_(a),in_(b);
    tot++;
    la[tot]=fi[a],en[tot]=b,fi[a]=tot;
    tot++;
    la[tot]=fi[b],en[tot]=a,fi[b]=tot;
}
//............................................
#define ls (s<<1)
#define rs ((s<<1)|1)
int val[need<<3],aa[need<<3],bb[need<<3],lazy[need<<3];

void build(int s,int l,int r)
{
    aa[s]=l,bb[s]=r;
    if(l==r) return ;
    build(ls,l,(l+r)>>1),build(rs,(l+r)/2+1,r);
}

inline void putdown(int s)
{
    int k=lazy[s];
    lazy[s]=0;
    if(aa[s]==bb[s]) return ;
    val[ls]+=k,val[rs]+=k;
    lazy[ls]+=k,lazy[rs]+=k;
}

int x,y;

void ins_(int s)
{
    if(aa[s]>y||bb[s]<x) return ;
    if(x<=aa[s]&&bb[s]<=y) 
    {
        val[s]+=bb[s]-aa[s]+1;
        lazy[s]++;
        return ;
    }
    if(lazy[s]) putdown(s);
    ins_(ls),ins_(rs);
    val[s]=val[ls]+val[rs];
}

int ask_(int s)
{
    if(aa[s]>y||bb[s]<x) return 0;
    if(x<=aa[s]&&bb[s]<=y) return val[s];
    if(lazy[s]) putdown(s);
    return ask_(ls)+ask_(rs);
}
//............................................
int wws[need],fa[need],size[need],dep[need];
int idid,id[need],ancestor[need];

void find_w(int x)
{
    int t,y,msize=0;
    size[x]=1;
    for(t=fi[x];t;t=la[t])
    {
        y=en[t];
        if(fa[x]==y) continue;
        fa[y]=x;
        dep[y]=dep[x]+1;
        find_w(y);
        size[x]+=size[y];
        if(size[y]>msize) msize=size[y],wws[x]=y;
    }
}
void find_a(int x)
{
    id[x]=++idid;
    if(wws[x]) find_a((ancestor[wws[x]]=ancestor[x],wws[x]));
    for(int t=fi[x],y;t;t=la[t])
    {
        y=en[t];
        if(y==fa[x]||y==wws[x]) continue;
        find_a(ancestor[y]=y);
    }
}

void tree(){find_w(1),find_a(ancestor[1]=1);}
//............................................
void change(int u,int v)
{
    while(ancestor[u]!=ancestor[v]) 
    {
        if(dep[ancestor[u]]<dep[ancestor[v]]) swap(u,v);//深度大的往上 
        x=id[ancestor[u]],y=id[u];
        ins_(1);
        u=fa[ancestor[u]];
    }
    if(dep[u]>dep[v]) swap(u,v);//深度大的在后 
    x=id[u]+1,y=id[v];
    if(x<=y) ins_(1);
}

int ask(int u,int v)
{
    int ans=0;
    while(ancestor[u]!=ancestor[v])
    {
        if(dep[ancestor[u]]<dep[ancestor[v]]) swap(u,v);
        x=id[ancestor[u]],y=id[u];
        ans+=ask_(1);
        u=fa[ancestor[u]];
    }
    if(dep[u]>dep[v]) swap(u,v);
    x=id[u]+1,y=id[v];
    if(x<=y) ans+=ask_(1);
    return ans;
}
//............................................

int main()
{
    int n,m;in_(n),in_(m);
    for(int i=1;i<n;i++) add();
    tree();
    build(1,1,n);
    char c;
    for(int i=1,a,b;i<=m;i++)
    {
        inc(c),in_(a),in_(b);
        if(c=='P') change(a,b);
        else out_(ask(a,b)),putchar(10);
    } 
}

2、
NKOJ2145【SDOI2011 第1轮 DAY1】染色
时间限制 : 40000 MS 空间限制 : 565536 KB

问题描述
给定一棵有个节点的无根树和m个操作，操作有2类：
1、将节点a到节点b路径上所有点都染成颜色c；
2、询问节点a到节点b路径上的颜色段数量（连续相同颜色被认为是同一段），如“112221”由3段组成：“11”、“222”和“1”。
请你写一个程序依次完成这m个操作。

输入格式
第一行包含2个整数n和m，分别表示节点数和操作数；
第二行包含n个正整数表示n个节点的初始颜色
下面n-1行每行包含两个整数x和y，表示x和y之间有一条无向边。
下面m行每行描述一个操作：
“C a b c”表示这是一个染色操作，把节点a到节点b路径上所有点（包括a和b）都染成颜色；
“Q a b”表示这是一个询问操作，询问节点a到节点b（包括a和b）路径上的颜色段数量。

输出格式
对于每个询问操作，输出一行答案。

样例输入
6 5
2 2 1 2 1 1
1 2
1 3
2 4
2 5
2 6
Q 3 5
C 2 1 1
Q 3 5
C 5 1 2
Q 3 5

样例输出
3
1
2

思路：
维护区间内段数、左端颜色、右端颜色，每次询问若相邻两段相邻颜色相同ans–

#include<cstdio>
#include<iostream>
using namespace std;
const int need=100004;

int n,m;
int a[need],aaa[need];
//............................................
inline void inc(char &c)
{
    c=getchar();
    while(c==' '||c==10) c=getchar();
} 
inline void in_(int &d)
{
    char t=getchar();
    while(t<'0'||t>'9') t=getchar();
    for(d=0;!(t<'0'||t>'9');t=getchar()) d=(d<<1)+(d<<3)+t-'0';
}
inline void out_(int x)
{
    if(x>=10) out_(x/10);
    putchar(x%10+'0');
}
//............................................
int tot,fi[need],la[need<<1],en[need<<1];
inline void add()
{
    int a,b;in_(a),in_(b);
    tot++;
    la[tot]=fi[a],fi[a]=tot,en[tot]=b;
    tot++;
    la[tot]=fi[b],fi[b]=tot,en[tot]=a;
}
//............................................
int fa[need],ww[need],si[need],dep[need];
int idid,id[need],anc[need];

void find_w(int x)
{
    int t,y,msi=0;
    si[x]=1;
    for(t=fi[x];t;t=la[t])
    {
        y=en[t];
        if(fa[x]==y) continue;
        fa[y]=x;
        dep[y]=dep[x]+1;
        find_w(y);
        si[x]+=si[y];
        if(si[y]>msi) {msi=si[y];ww[x]=y;}
    }
}
void find_a(int x)
{
    id[x]=++idid; 
    if(ww[x]) find_a((anc[ww[x]]=anc[x],ww[x]));
    for(int t=fi[x],y;t;t=la[t])
    {
        y=en[t];
        if(y==fa[x]||y==ww[x]) continue;
        find_a(anc[y]=y);
    }
}
void tree(){find_w(1),find_a(anc[1]=1);}
//............................................
#define ls (s<<1)
#define rs ((s<<1)|1)
int aa[need<<3],bb[need<<3],as[need<<3],bs[need<<3],tt[need<<3],lazy[need<<3];

inline void NBHB(int s)
{
    if(aa[s]==bb[s]) return ;
    as[s]=as[ls],bs[s]=bs[rs];
    tt[s]=tt[ls]+tt[rs];
    if(bs[ls]==as[rs]) tt[s]--;
}

void build(int s,int l,int r)
{
    aa[s]=l,bb[s]=r;
    if(l==r) 
    {
        tt[s]=1;
        as[s]=bs[s]=aaa[l];
        return ;
    }
    build(ls,l,(l+r)>>1),build(rs,(l+r)/2+1,r);
    NBHB(s);
}

inline void putdown(int s)
{
    int k=lazy[s];
    lazy[s]=0;
    if(aa[s]==bb[s]) return;
    lazy[ls]=lazy[rs]=k;
    as[ls]=bs[ls]=as[rs]=bs[rs]=k,tt[ls]=tt[rs]=1;
}

int x,y,d;

int getc(int s)
{
    if(aa[s]==bb[s]) return as[s];
    if(lazy[s]) return lazy[s];//该区间内所有点颜色都为lazy 
    int mid=(aa[s]+bb[s])/2;
    if(d<=mid) return getc(ls);
    else return getc(rs);
}

void change_(int s)
{
    if(aa[s]>y||bb[s]<x) return ;
    if(x<=aa[s]&&bb[s]<=y)
    {
        tt[s]=1;
        as[s]=bs[s]=d;
        if(aa[s]!=bb[s]) lazy[s]=d;
        return ;
    }
    if(lazy[s]!=0) putdown(s);
    change_(ls),change_(rs);
    NBHB(s);
}
int ask_(int s)
{
    if(aa[s]>y||bb[s]<x) return 0;
    if(x<=aa[s]&&bb[s]<=y) return tt[s];
    if(lazy[s]!=0) putdown(s);
    int mid=(aa[s]+bb[s])>>1;
    if(y<=mid) return ask_(ls);
    if(x>mid) return ask_(rs);
    return ask_(ls)+ask_(rs)-(bs[ls]==as[rs]);
}

//............................................
void change(int u,int v)
{
    while(anc[u]!=anc[v])
    {
        if(dep[anc[v]]>dep[anc[u]]) swap(u,v);
        x=id[anc[u]],y=id[u];
        change_(1);
        u=fa[anc[u]];
    }
    if(dep[v]>dep[u]) swap(u,v);
    x=id[v],y=id[u];
    change_(1);
}
int ask(int u,int v)
{
    int ans=0;
    while(anc[v]!=anc[u])
    {
        if(dep[anc[v]]>dep[anc[u]]) swap(u,v);
        x=id[anc[u]],y=id[u];
        ans+=ask_(1);
        int c,cf=0;
        if(fa[anc[u]]) d=id[fa[anc[u]]],cf=getc(1);
        d=id[anc[u]],c=getc(1);
        if(c==cf) ans--;
        u=fa[anc[u]];
    }
    if(dep[u]>dep[v]) swap(u,v);
    x=id[u],y=id[v];
    ans+=ask_(1);
    return ans; 
}
//............................................

int main_()
{
     int n,m;in_(n),in_(m);
     for(int i=1;i<=n;i++) in_(a[i]);
     for(int i=1;i<n;i++) add();
     tree();
     for(int i=1;i<=n;i++) aaa[id[i]]=a[i];
     build(1,1,n);
     char b;
     for(int i=1,c,e;i<=m;i++) 
     {
        inc(b);
        if(b!='Q')
        {
            in_(c),in_(e),in_(d);
            change(c,e);
        }
        else 
        {
            in_(c),in_(e);
            out_(ask(c,e)),putchar(10);
        }
     } 
}

const int main_stack=16;
char my_stack[128<<20];

int main(){
     __asm__("movl %%esp, (%%eax);\n"::"a"(my_stack):"memory");
     __asm__("movl %%eax, %%esp;\n"::"a"(my_stack+sizeof(my_stack)-main_stack):"%esp");
     main_();
     __asm__("movl (%%eax), %%esp;\n"::"a"(my_stack):"%esp");
     return 0;
}
Y__XV
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分（含例题）
zyc_____的博客
05-04 420
树链剖分介绍： 模板题：【模板】最近公共祖先（LCA） - 洛谷 图片来自：通俗易懂的树链剖分详解 - 一剑缥缈的洛咕博客 - 洛谷博客 树链剖分的优点： 求LCA中的优化无非就是减少无效搜索的次数，树链剖分把树拆成不同的链（保证不重不漏），因为两个点的LCA一定在一条链上（同一个点），所以如果搜索到的点不在同一条链上，那么不是倍增跳或是······，而是跳过一整条链，这样搜索的速度会大幅提高。 注释代码： #include<bits/stdc++.h> using names.
树链剖分例题
hutwuguangrong的博客
05-14 316
非常好的一个博客http://www.cnblogs.com/chinhhh/p/7965433.html 权值在边，将权值映射在边的儿子节点就ok了 以下题目来自 kuangbin 这些题目套上树链剖分的模板，感觉考的就是线段树的知识 P3384 【模板】树链剖分 （点） 题意： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 2 x y 表示求树从x到y结点...
树链剖分 讲解+模板+习题
Hacheylight
08-08 445
今天我们来讲一下树链剖分 树链剖分是什么？ 树链剖分是一种用来维护树上路径信息的在线方法，可以处理在线。 通常通过一种方法，将一棵树剖分成若干条链，然后通过数据结构（线段树，BIT等）去维护。 我们通常所说的树链剖分，基本都是轻重链剖分。 下面我们介绍一下这一种剖分。 学习树链剖分的基础知识有lca，dfs序，线段树等。 首先，我们来明确即可变量。 sizeisizeisize_i...
树链剖分习题
tangzhide123yy的博客
10-17 283
树链剖分习题
树链剖分例题（老师文档）
xby_fx的博客
03-30 303
我们的主角是来自魔界，英俊的人类王子阿拉贡。有一天，阿拉贡发现许多想侵入他王国的敌人。正如阿拉贡所知道的那样，敌人有N个营地离开他的王国，M条边连接他们。这是保证，对于任何两个阵营，有一条，只有一条路径连接它们。起初，阿拉贡人知道每个阵营的敌人数量。但敌人是狡猾的，他们会增加或减少营地中的士兵数量。每当敌人改变士兵数量时，他们将设置两个阵营C1和C2。然后，对于C1，C2和C1至C2路径上的所有阵...
NOIP 树链剖分 NOIP 树链剖分
10-30
针对树链剖分的应用问题，可以通过具体的例题来进行实践练习。比如，题目可能涉及求解两个节点之间的路径最小值、最大值或者路径上的其他统计信息。 综上所述，树链剖分是一种非常有效的算法技术，能够帮助我们在树...
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
树链剖分
09-22
### 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了有效地处理树结构中的路径查询和更新问题。通过将树分解为一系列的链（即重链），可以显著提高算法的效率。这样做的...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
浅谈树链剖分
cdy1206473601的博客
01-28 4396
什么是树链剖分？ 指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、SBT、SPLAY、线段树等）来维护每一条链,主要用来维护树上每条链的极值或和之类的。 类似 首先把树上倍增摆在前面，如果不会树上倍增就不必来看树链剖分。 为什么要学树链剖分？ 有的人说：“我会树上倍增，我怕谁？”，没错，你怕的就是树链...
[练习]: 树链剖分练习题
Edt!
06-07 337
这些是一些树剖的基础题 难度从低到高 初学者一定要做一做。。 1.洛谷p3384树链剖分模板 //一定记得任何算值的地方取模。。还有注意add和query时候深度小的在前面！不然线段树会卡死 #include #include #include #include #include #include #define ll long long #define N 100005 #define l
树链剖分题集
帅比王的博客
10-12 1463
树链剖分常用于处理静态树上操作，效率很高，写起来也就是固定的轻重边拆分+线段树，但是代码一般都是100行+，容易出错。 本题集中的树链剖分练习题，在解决思路上没什么难点，主要是如何设计线段树以及如何更新+询问，也就是说要想好怎么维护线段树，其它地方没什么太难的，但是代码长就容易出bug，多写写就好了。最后一题是线段树动态开点，这和可持久化权值线段树（动态主席树）一样的思想，只需要将普通的线段树给稍...
几个树链剖分例题
热门推荐
Fuko_Ibuki的博客
04-18 1万+
Codeforces 343D Water Tree Luogu P4315 月下”毛景树” Luogu P3979 遥远的国度 Luogu P2486 染色 树链剖分把我写吐了.为了研究这个东西花费了我4天的时间. 后面我的代码是对的,然后用来对拍的所谓”题解”是错的,害得我把随机的数据手膜了好几遍. 一开始有写完过样例,提交直接A.后来越写调的时间越长,用来对拍的别人的...
[LNOI2014]LCA--树链剖分例练习
weixin_45772744的博客
04-01 917
题目链接: A-[LNOI2014]LCA_牛客竞赛数据结构专题班树链剖分 (nowcoder.com) 题意: 1≤n≤50000,1≤m≤50000 样例: 输入 5 2 0 0 1 1 1 4 3 1 4 2 输出 8 5 思路: 本题的关键在于深度的一个巧妙转化，我们假设树上所有点的初始权值为0，对于点x，我们将从根节点到x路径上所有点的点权加1，对于x和z的最近公共祖先的深度就是从根节点到z的路径上的点权之和，自己也可以在纸上画画。 明确了这个转化之后，对于[l.
树链剖分题目大集
TheWayForDream
07-11 437
树链剖分题目大集如果还没学树链剖分的伙伴可以跳转到下面的博客1.模板题 P3384 【模板】轻重链剖分/树链剖分2.洛谷-P3379 【模板】最近公共祖先（LCA）（强行用树剖写LCA）3.洛谷-P2590 [ZJOI2008]树的统计4.P3038 [USACO11DEC]Grass Planting G5.P3178 [HAOI2015]树上操作6.树链剖分+线段树 2019ICPC西安邀请赛E7.HDU - 5052 树链剖分主要是解决对于树上路径的修改和查询操作，常常结合线段树来出题，使用线段树维护
树链剖分 入门题（洛谷）
KXL5180的博客
01-09 407
最近学习了树链剖分。 发现这个东西其实并不是很难，而是因为代码量比较长，在码的过程中容易出错。 但不过其中还是用套路可循的，如果要学习树链剖分必须要知道DFS序和线段树。 这里就不详细讲了，只给出一些入门题，供个人参考。 https://www.luogu.com.cn/problem/P3384 这是一个模板题 首先树链剖分有两个dfs其中一个dfs是处理轻重儿子的，另外一个dfs是维护重链上的...
树链剖分-入门题目
CodeDream
11-12 1359
Query on a tree 题目链接: http://vjudge.net/problem/SPOJ-QTREE 题目大致意思就是: 给你一棵树,有连个操作:       ● 第一个是查询任意两个不同节点上的最短路径上的最大权边!       ● 第二个操作修改某一条边的权值; 对于一棵树,数的深度如果很大,那么每次查询两个叶子节点,时间复杂度还是很高的。所以我们就把树分成一
树链剖分原理、实现及例题
岂曰无衣，与子同袍
08-09 282
参考博文： http://www.cnblogs.com/George1994/p/7821357.html 知识点 重结点：子树结点数目最多的结点； 轻节点：父亲节点中除了重结点以外的结点； 重边：父亲结点和重结点连成的边； 轻边：父亲节点和轻节点连成的边； 重链：由多条重边连接而成的路径； 轻链：由多条轻边连接而成的路径； dfs1用来计算出一些上述的值 而df...
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值