[BZOJ2157] 旅游 边权树链剖分

最新推荐文章于 2022-07-15 00:11:01 发布
最新推荐文章于 2022-07-15 00:11:01 发布
阅读量691 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： bzoj 数据结构——树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cabinfever/article/details/53025981
本文介绍了一种结合重链剖分与线段树的数据结构优化方案，用于解决涉及树形结构上的区间查询与更新问题。通过将树转化为重链表示，并利用线段树进行区间操作，有效提升了查询效率。

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

对于边权，我们将其赋值到树边的子节点上就好

查询，修改时，只需要在两点都在一条重链时，序号小的点+1即可

（x,y,min,max写混WA了一发，气，另外需要改一改线段树的写法了，又臭又长）

/**************************************************************
    Problem: 2157
    User: cabinfever
    Language: C++
    Result: Accepted
    Time:584 ms
    Memory:3592 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
const int maxn = 20100;
 
int epos[maxn];
int ee[maxn][3];
struct edge
{
    int v,next;
}e[maxn << 1];
int h[maxn],num = 0;
struct node
{
    int l,r;
    int minn,summ,maxx,mark;
}t[maxn << 1];
int tot = 0;
int a[maxn];
bool vis[maxn];
int n,m,u,v,x,y,d,q;
int cnt = 0;
int fa[maxn];
int dep[maxn];
int son[maxn];
int pos[maxn],ppos[maxn];
int top[maxn];
int size[maxn];
 
void build_edge(int u,int v)
{
    num++;
    e[num].v = v;
    e[num].next = h[u];
    h[u] = num;
}
 
void dfs1(int x)
{
    dep[x] = dep[fa[x]] + 1;
    vis[x] = true;
    size[x] = 1;
    son[x] = 0;
    for(int i = h[x]; i; i = e[i].next)
    {
        if(vis[e[i].v])
            continue;
        fa[e[i].v] = x;
        dfs1(e[i].v);
        if(size[e[i].v] > size[son[x]])
            son[x] = e[i].v;
        size[x] += size[e[i].v];
    }
}
 
void dfs2(int x)
{
    vis[x] = true;
    if(son[fa[x]] == x)
        top[x] = top[fa[x]];
    else
    {
        top[x] = x;
        for(int i = x; i; i = son[i])
        {
            pos[i] = ++cnt;
            ppos[cnt] = i;
        }
    }
    for(int i = h[x]; i; i = e[i].next)
        if(!vis[e[i].v])
            dfs2(e[i].v);
}
 
void build(int p,int l,int r)
{
    int mid = l + r >> 1;
    if(l == r)
        return;
    t[p].l = ++tot;
    t[p].r = ++tot;
    build(t[p].l,l,mid);
    build(t[p].r,mid+1,r);
}
 
void change1(int p,int l,int r,int q,int c)
{
    int mid = l + r >> 1;
    if(l == r)
    {
        t[p].maxx = c;
        t[p].minn = c;
        t[p].summ = c;
        return;
    }
    if(t[p].mark)
    {
        t[t[p].l].summ = -t[t[p].l].summ;
        t[t[p].r].summ = -t[t[p].r].summ;
        swap(t[t[p].l].minn,t[t[p].l].maxx);
        swap(t[t[p].r].minn,t[t[p].r].maxx);
        t[t[p].l].minn = -t[t[p].l].minn;
        t[t[p].r].minn = -t[t[p].r].minn;
        t[t[p].l].maxx = -t[t[p].l].maxx;
        t[t[p].r].maxx = -t[t[p].r].maxx;
        t[p].mark ^= 1;
        t[t[p].l].mark ^= 1;
        t[t[p].r].mark ^= 1;
    }
    if(q <= mid)
    {
        change1(t[p].l,l,mid,q,c);
        t[p].maxx = max(t[t[p].l].maxx,t[t[p].r].maxx);
        t[p].minn = min(t[t[p].l].minn,t[t[p].r].minn);
        t[p].summ = t[t[p].r].summ + t[t[p].l].summ;
    }
    else
    {
        change1(t[p].r,mid+1,r,q,c);
        t[p].maxx = max(t[t[p].l].maxx,t[t[p].r].maxx);
        t[p].minn = min(t[t[p].l].minn,t[t[p].r].minn);
        t[p].summ = t[t[p].r].summ + t[t[p].l].summ;
    }
}
 
void change2(int p,int l,int r,int L,int R)
{
    int mid = l + r >> 1;
    if(l == L && r == R)
    {
        t[p].summ = -t[p].summ;
        swap(t[p].minn,t[p].maxx);
        t[p].minn = -t[p].minn;
        t[p].maxx = -t[p].maxx;
        t[p].mark ^= 1;
        return;
    }
    if(t[p].mark)
    {
        t[t[p].l].summ = -t[t[p].l].summ;
        t[t[p].r].summ = -t[t[p].r].summ;
        swap(t[t[p].l].minn,t[t[p].l].maxx);
        swap(t[t[p].r].minn,t[t[p].r].maxx);
        t[t[p].l].minn = -t[t[p].l].minn;
        t[t[p].r].minn = -t[t[p].r].minn;
        t[t[p].l].maxx = -t[t[p].l].maxx;
        t[t[p].r].maxx = -t[t[p].r].maxx;
        t[p].mark ^= 1;
        t[t[p].l].mark ^= 1;
        t[t[p].r].mark ^= 1;
    }
    if(R <= mid)
    {
        change2(t[p].l,l,mid,L,R);
        t[p].minn = min(t[t[p].r].minn,t[t[p].l].minn);
        t[p].maxx = max(t[t[p].r].maxx,t[t[p].l].maxx);
        t[p].summ = t[t[p].r].summ + t[t[p].l].summ;
    }
    else if(L > mid)
    {
        change2(t[p].r,mid+1,r,L,R);
        t[p].minn = min(t[t[p].r].minn,t[t[p].l].minn);
        t[p].maxx = max(t[t[p].r].maxx,t[t[p].l].maxx);
        t[p].summ = t[t[p].r].summ + t[t[p].l].summ;
    }
    else
    {
        change2(t[p].l,l,mid,L,mid);
        change2(t[p].r,mid+1,r,mid+1,R);
        t[p].minn = min(t[t[p].r].minn,t[t[p].l].minn);
        t[p].maxx = max(t[t[p].r].maxx,t[t[p].l].maxx);
        t[p].summ = t[t[p].r].summ + t[t[p].l].summ;
    }
}
 
int getMax(int p,int l,int r,int L,int R)
{
    int mid = l + r >> 1;
    if(l == L && r == R)
        return t[p].maxx;
    if(t[p].mark)
    {
        t[t[p].l].summ = -t[t[p].l].summ;
        t[t[p].r].summ = -t[t[p].r].summ;
        swap(t[t[p].l].minn,t[t[p].l].maxx);
        swap(t[t[p].r].minn,t[t[p].r].maxx);
        t[t[p].l].minn = -t[t[p].l].minn;
        t[t[p].r].minn = -t[t[p].r].minn;
        t[t[p].l].maxx = -t[t[p].l].maxx;
        t[t[p].r].maxx = -t[t[p].r].maxx;
        t[p].mark ^= 1;
        t[t[p].l].mark ^= 1;
        t[t[p].r].mark ^= 1;
    }
    if(R <= mid)
        return getMax(t[p].l,l,mid,L,R);
    else if(L > mid)
        return getMax(t[p].r,mid+1,r,L,R);
    return max(getMax(t[p].l,l,mid,L,mid),getMax(t[p].r,mid+1,r,mid+1,R));
}
 
int getMin(int p,int l,int r,int L,int R)
{
    int mid = l + r >> 1;
    if(l == L && r == R)
        return t[p].minn;
    if(t[p].mark)
    {
        t[t[p].l].summ = -t[t[p].l].summ;
        t[t[p].r].summ = -t[t[p].r].summ;
        swap(t[t[p].l].minn,t[t[p].l].maxx);
        swap(t[t[p].r].minn,t[t[p].r].maxx);
        t[t[p].l].minn = -t[t[p].l].minn;
        t[t[p].r].minn = -t[t[p].r].minn;
        t[t[p].l].maxx = -t[t[p].l].maxx;
        t[t[p].r].maxx = -t[t[p].r].maxx;
        t[p].mark ^= 1;
        t[t[p].l].mark ^= 1;
        t[t[p].r].mark ^= 1;
    }
    if(R <= mid)
        return getMin(t[p].l,l,mid,L,R);
    else if(L > mid)
        return getMin(t[p].r,mid+1,r,L,R);
    return min(getMin(t[p].l,l,mid,L,mid),getMin(t[p].r,mid+1,r,mid+1,R));
}
 
int getSum(int p,int l,int r,int L,int R)
{
    int mid = l + r >> 1;
    if(l == L && r ==  R)
        return t[p].summ;
    if(t[p].mark)
    {
        t[t[p].l].summ = -t[t[p].l].summ;
        t[t[p].r].summ = -t[t[p].r].summ;
        swap(t[t[p].l].minn,t[t[p].l].maxx);
        swap(t[t[p].r].minn,t[t[p].r].maxx);
        t[t[p].l].minn = -t[t[p].l].minn;
        t[t[p].r].minn = -t[t[p].r].minn;
        t[t[p].l].maxx = -t[t[p].l].maxx;
        t[t[p].r].maxx = -t[t[p].r].maxx;
        t[p].mark ^= 1;
        t[t[p].l].mark ^= 1;
        t[t[p].r].mark ^= 1;
    }
    if(R <= mid)
        return getSum(t[p].l,l,mid,L,R);
    else if(L > mid)
        return getSum(t[p].r,mid+1,r,L,R);
    return getSum(t[p].l,l,mid,L,mid) + getSum(t[p].r,mid+1,r,mid+1,R);
}
 
void updata(int x,int y)
{
    int fx = top[x];
    int fy = top[y];
    int l,r;
    while(fx != fy)
    {
        if(dep[fx] > dep[fy])
        {
            change2(0,1,n,pos[fx],pos[x]);
            x = fa[fx];
            fx = top[x];
        }
        else
        {
            change2(0,1,n,pos[fy],pos[y]);
            y = fa[fy];
            fy = top[y];
        }
    }
    if(x == y)
        return;
    if(pos[x] > pos[y])
        l = pos[y]+1, r = pos[x];
    else
        l = pos[x]+1, r = pos[y];
    change2(0,1,n,l,r);
    return;
}
 
int query_max(int x,int y)
{
    int ans = -1000000000;
    int fx = top[x];
    int fy = top[y];
    int l,r;
    while(fx != fy)
    {
        if(dep[fx] > dep[fy])
        {
            ans = max(ans,getMax(0,1,n,pos[fx],pos[x]));
            x = fa[fx];
            fx = top[x];
        }
        else
        {
            ans = max(ans,getMax(0,1,n,pos[fy],pos[y]));
            y = fa[fy];
            fy = top[y];
        }
    }
    if(x == y)
        return ans;
    if(pos[x] > pos[y])
        l = pos[y]+1, r = pos[x];
    else
        l = pos[x]+1, r = pos[y];
    ans = max(ans,getMax(0,1,n,l,r));
    return ans;
}
 
int query_min(int x,int y)
{
    int ans = 1000000000;
    int fx = top[x];
    int fy = top[y];
    int l,r;
    while(fx != fy)
    {
        if(dep[fx] > dep[fy])
        {
            ans = min(ans,getMin(0,1,n,pos[fx],pos[x]));
            x = fa[fx];
            fx = top[x];
        }
        else
        {
            ans = min(ans,getMin(0,1,n,pos[fy],pos[y]));
            y = fa[fy];
            fy = top[y];
        }
    }
    if(x == y)
        return ans;
    if(pos[x] > pos[y])
        l = pos[y]+1, r = pos[x];
    else
        l = pos[x]+1, r = pos[y];
    ans = min(ans,getMin(0,1,n,l,r));
    return ans;
}
 
int query_sum(int x,int y)
{
    int ans = 0;
    int fx = top[x];
    int fy = top[y];
    int l,r;
    while(fx != fy)
    {
        if(dep[fx] > dep[fy])
        {
            ans += getSum(0,1,n,pos[fx],pos[x]);
            x = fa[fx];
            fx = top[x];
        }
        else
        {
            ans += getSum(0,1,n,pos[fy],pos[y]);
            y = fa[fy];
            fy = top[y];
        }
    }
    if(x == y)
        return ans;
    if(pos[x] > pos[y])
        l = pos[y]+1, r = pos[x];
    else
        l = pos[x]+1, r = pos[y];
    ans += getSum(0,1,n,l,r);
    return ans;
}
 
int main()
{
    scanf("%d",&n);
    for(int i = 0; i < n - 1; i++)
    {
        scanf("%d%d%d",&ee[i][0],&ee[i][1],&ee[i][2]);
        ee[i][0]++;
        ee[i][1]++;
        build_edge(ee[i][0],ee[i][1]);
        build_edge(ee[i][1],ee[i][0]);
    }
    memset(vis,0,sizeof(vis));
    dfs1(1);
    memset(vis,0,sizeof(vis));
    dfs2(1);
    for(int i = 0; i < n - 1; i++)
        if(fa[ee[i][0]] == ee[i][1])
            epos[i+1] = ee[i][0];
        else
            epos[i+1] = ee[i][1];
    build(0,1,n);
    for(int i = 1; i < n; i++)
        change1(0,1,n,pos[epos[i]],ee[i-1][2]);
    char q[10];
    scanf("%d",&m);
    while(m--)
    {
        scanf("%s",q);
        scanf("%d%d",&x,&y);
        x++,y++;
        if(!strcmp(q,"C"))
        {
            y--;
            x--;
            change1(0,1,n,pos[epos[x]],y);
        }
        else if(!strcmp(q,"MAX"))
        {
            printf("%d\n",query_max(x,y));
        }
        else if(!strcmp(q,"N"))
        {
            updata(x,y);
        }
        else if(!strcmp(q,"MIN"))
        {
            printf("%d\n",query_min(x,y));
        }
        else
        {
            printf("%d\n",query_sum(x,y));
        }
    }
    return 0;
}

【BZOJ 2243】染色 【树链剖分】
skysys的研究小屋
10-28 838
静态查错能力显著提升233，这次3分钟就查出bug#include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #include<iostream> #include<cctype> using namespace std; #define N 100010 #define g() getchar() #define d
BZOJ 2243 浅谈树链剖分+线段树
BerryKanry的博客
09-29 481
世界真的很大 前几次考试有一次树链剖分当场写挂之后调了一下午 一直耿耿于怀，于是乎找一道树链剖分的题来练手 虽然代码量略大但是调试起来还是比较轻松，一个小错误卡了一会儿 没搞明白root根本没有赋值为什么还能过样例 一直RE加上return就A了看题先：description： 给定一棵有n个节点的无根树和m个操作，操作有2类： 1、将节点a到节点b路径上所有点都染成颜色c；
树链剖分（边权）
gebixiaofang的博客
10-22 427
#include&lt;bits/stdc++.h&gt; #define MAX 123466 #define ll long long using namespace std; struct Front_Link_Star{ int next,to; }edge[MAX&lt;&lt;1]; ll Ma,Mi; ll tree[MAX &lt;&lt; 2],lazy[MAX &l...
洛谷P4315 月下“毛景树”
蒟蒻的博客
03-22 245
题目描述毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊爬毛毛虫爬到了一颗小小的“毛景树”下面，发现树上长着他最爱吃的毛毛果~ “毛景树”上有N个节点和N-1条树枝，但节点上是没有毛毛果的，毛毛果都是长在树枝上的。但是这棵“毛景树”有着神奇的魔力，他能改变树枝上毛毛果的个数：Change k w：将第k条树枝...
poj 2763 Housewife Wind 边权的树链剖分
TIMELIMITE的专栏
09-08 610
// poj 2763 Housewife Wind 边权的树链剖分 // // 题目意思很清楚,关于边权的树链剖分,首先 // 肯定是先把链剖分好啦,然后就是将边权转化 // 成离根节点较远的点的权值即可.单点更新, // 区间求和,注意,莫要重复计算哟,这题还有需要 // 研究的地方,继续加油吧~~~ #include #include #include #include #defi
bzoj1984 月下“毛景树”(边权的树链剖分)
Icefox的博客
09-08 475
树链剖分，挺裸的，给的是边权，我们把边权都记在儿子上。用线段树维护单点修改，区间修改，区间加，区间最大值。需要注意的是对路径（x，y）进行操作时，不应算lca(x,y)这一点。因为他所代表的边不在路径上。
【树链剖分】【边权】
Vampire
05-20 1753
QTREE - Query on a treeno tags You are given a tree (an acyclic undirected connected graph) with N nodes, and edges numbered 1, 2, 3…N-1.We will ask you to perfrom some instructions of the following
BZOJ 2157 「国家集训队」旅游（树链剖分，线段树，边权转点权）【BZOJ计划】
繁凡さん的博客
09-22 1613
【BZOJ修复计划 #20】BZOJ 2157 旅游 【国家集训队2011】
【BZOJ 4127】Abs（树链剖分，线段树）
t14 的博客
07-15 214
目录 题目 Description Input Output Sample Input Sample Output Hint 思路 代码 题目 题目传送门 Description 给定一棵树,设计数据结构支持以下操作 1 \;u\;v\;d1uvd 表示将路径 (u,v)(u,v) 加 dd 2\;u\;v2uv 表示询问路径 (u,v)(u,v) 上点权绝对值的和 Input 第一行两个整数 nn 和 mm，表示结点个数和操作数 接下来一行 nn 个整数 a_ia i ​ ,表示点 ii 的权值
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
热门推荐
路人黑的纸巾
10-18 1万+
一篇从浅到深探究一些树上算法的博客
树链剖分边权版
maze_illusion的博客
08-30 274
int tol,head[maxn]; struct edge { int to,next; }es[maxm]; void addedge( int u , int v ) { es[tol].to = v; es[tol].next = head[u]; head[u] = tol++; } int top[maxn],fa[maxn],dep[maxn],s...
POJ.2763 Housewife Wind ( 边权树链剖分 线段树维护区间和 )
Pengwill's Blog
08-13 468
POJ.2763 Housewife Wind ( 边权树链剖分 线段树维护区间和 )题意分析给出n个点，m个询问，和当前位置pos。 先给出n-1条边，u->v以及边权w。 然后有m个询问，询问分2种： 一是讲第i条边的边权修改为w。 二是询问从当前位置走到点x经过的边权和(下次询问就是从这点开始)。边权的树链剖分，其实和点权的差不多。对于一条边u-v，及其边权w，在建立线段树的时候，将深
树链剖分（spoj375）基于边权
龙崎的专栏
01-10 676
原来以为树链剖分是很高端的数据结构，学习之后才知道，树链剖分思想也不是很难，首先把树分成好多条链，然后结合线段树或者伸展树 SPOJ Problem Set (classical) 375. Query on a tree Problem code: QTREE You are given a tree (an acyclic undirected connected graph)
树链剖分边权 poj 3237
Black__wing的博客
06-19 264
#include <cstdio> #include<string.h> #include<algorithm> #include<iostream> using namespace std; const int M=2e5+100; int f[M]; int d[M]; int siz[M]; int rk[M];//保存树链剖分后，节点编号对...
边权更新 查询路径长度和最大边权 【树链剖分 模板】
lzs_lazy
09-13 774
题意 给n个点的树，有两种操作 op x y ，第一种操作，将第x条边修改权值为y，第二种操作查询x到y的路径长度。今天刚学，说下我目前的理解，树链剖分就是将树上的边按照一种序排列到线段树上，从而进行快速的查询和更新。 对树的拆分，分为轻链和重链，快速的查询多是在重链上，轻链一般还是要一个个走，所以查询的时候，多是将轻链上的点跳到重链上，从而对多个重链来处理达到查询的目的。 【ps 练
poj 2763 Housewife Wind（树链剖分---边权化点权）
雪的期许
08-13 370
Housewife Wind Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 14220   Accepted: 3935 Description After their royal wedding, Jiajia and Wind ...
树链剖分模板 边权、点权区别
tangzhide123yy的博客
07-29 2545
熟练剖分详解见:https://blog.youkuaiyun.com/tangzhide123yy/article/details/77532880 熟练剖分一般有如下几个步骤: 1.dfs1（）求出fa,deep,size,son 2.dfs2（）求出top,p 3.add（）/Query （）树链剖分核心部分 4.updata（）线段树更新操作(如单点修改，区间修改) 5.query（）线段...
树链剖分模板（基于点权，基于边权）
fsdcyr
02-17 2082
树链剖分是数据结构在树上的推广，其实就是把树hash到几段连续的区间 dfs1（）求出fa,deep,size,son dfs2（）求出top,p关键数组： int deep[maxn]; int size[maxn]; int fa[maxn]; int p[maxn]; int son[maxn]; int fp[maxn]; int top[maxn];树链剖分 分为基于点权
poj 3237 Tree（树链剖分---边权化点权）
雪的期许
08-13 573
Tree Time Limit: 5000MS   Memory Limit: 131072K Total Submissions: 11989   Accepted: 3088 Description You are given a tree with N nodes. The tree’s nodes ...
bzoj 1040 zjoi2008 骑士 树形dp
08-08
题目描述 有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求所有满足条件的路径中，所有点的权值和的最小值。 输入格式 第一行一个整数 $n$。 接下来 $n$ 行，每行 $n$ 个整数，表示棋盘上每个点的数字。 输出格式 输出一个整数，表示所有满足条件的路径中，所有点的权值和的最小值。 数据范围 $1\leq n\leq 300$ 输入样例 3 1 2 3 4 5 6 7 8 9 输出样例 25 算法1 (树形dp) $O(n^3)$ 我们可以先将所有点的权值求出来，然后将其看作是一个有权值的图，问题就转化为了在这个图中求从 $(1,1)$ 到 $(n,n)$ 的所有路径中，所有点的权值和的最小值。 我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子都被遍历过了，那么我们就可以计算出从它的左儿子到它的右儿子的路径中，所有点的权值和的最小值，然后再将这个值加上当前节点的权值，就可以得到从根节点到当前节点的路径中，所有点的权值和的最小值。 时间复杂度 树形dp的时间复杂度是 $O(n^3)$。 C++ 代码 算法2 (动态规划) $O(n^3)$ 我们可以使用动态规划来解决这个问题，具体来说，我们可以定义 $f(i,j,s)$ 表示从 $(1,1)$ 到 $(i,j)$ 的所有路径中，所有点的权值和为 $s$ 的最小值，那么我们就可以得到如下的状态转移方程： $$ f(i,j,s)=\min\{f(i-1,j,s-a_{i,j}),f(i,j-1,s-a_{i,j})\} $$ 其中 $a_{i,j}$ 表示点 $(i,j)$ 的权值。 时间复杂度 动态规划的时间复杂度是 $O(n^3)$。 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值