[BZOJ2157] 旅游 边权树链剖分

最新推荐文章于 2019-06-19 18:32:52 发布
最新推荐文章于 2019-06-19 18:32:52 发布
阅读量631 收藏
点赞数
分类专栏： bzoj 数据结构——树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cabinfever/article/details/53025981
版权

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

查询，修改时，只需要在两点都在一条重链时，序号小的点+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;
}

Cabinfever
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分（边权）
gebixiaofang的博客
10-22 368
#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 197
题目描述毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊爬毛毛虫爬到了一颗小小的“毛景树”下面，发现树上长着他最爱吃的毛毛果~ “毛景树”上有N个节点和N-1条树枝，但节点上是没有毛毛果的，毛毛果都是长在树枝上的。但是这棵“毛景树”有着神奇的魔力，他能改变树枝上毛毛果的个数：Change k w：将第k条树枝...
poj 2763 Housewife Wind 边权的树链剖分
TIMELIMITE的专栏
09-08 569
// poj 2763 Housewife Wind 边权的树链剖分 // // 题目意思很清楚,关于边权的树链剖分,首先 // 肯定是先把链剖分好啦,然后就是将边权转化 // 成离根节点较远的点的权值即可.单点更新, // 区间求和,注意,莫要重复计算哟,这题还有需要 // 研究的地方,继续加油吧~~~ #include #include #include #include #defi
bzoj1984 月下“毛景树”(边权的树链剖分)
Icefox的博客
09-08 409
树链剖分，挺裸的，给的是边权，我们把边权都记在儿子上。用线段树维护单点修改，区间修改，区间加，区间最大值。需要注意的是对路径（x，y）进行操作时，不应算lca(x,y)这一点。因为他所代表的边不在路径上。
【树链剖分】【边权】
Vampire
05-20 1705
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
树链剖分_王天懿.ppt
09-14
1. **POJ 3237**：维护边权的修改和路径上边权的取反操作，可以利用树链剖分和线段树联合解决。 2. **BZOJ 3083**：改变路径上点的权值和查询子树最小值，同样可以通过树链剖分实现。 3. **BZOJ 3531**：改变点的...
wangjunrui666#bzoj-problem##2704. 旅游1
07-25
1. 保证[1,1]格不是障碍 2. 除[1,1]格外不能重复走过同一格 3. [1,1]格的快乐程度只算一次 4. 快
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
树链剖分边权版
maze_illusion的博客
08-30 208
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 431
POJ.2763 Housewife Wind ( 边权树链剖分 线段树维护区间和 )题意分析给出n个点，m个询问，和当前位置pos。 先给出n-1条边，u->v以及边权w。 然后有m个询问，询问分2种： 一是讲第i条边的边权修改为w。 二是询问从当前位置走到点x经过的边权和(下次询问就是从这点开始)。边权的树链剖分，其实和点权的差不多。对于一条边u-v，及其边权w，在建立线段树的时候，将深
树链剖分（spoj375）基于边权
龙崎的专栏
01-10 635
原来以为树链剖分是很高端的数据结构，学习之后才知道，树链剖分思想也不是很难，首先把树分成好多条链，然后结合线段树或者伸展树 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 214
#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 685
题意 给n个点的树，有两种操作 op x y ，第一种操作，将第x条边修改权值为y，第二种操作查询x到y的路径长度。今天刚学，说下我目前的理解，树链剖分就是将树上的边按照一种序排列到线段树上，从而进行快速的查询和更新。 对树的拆分，分为轻链和重链，快速的查询多是在重链上，轻链一般还是要一个个走，所以查询的时候，多是将轻链上的点跳到重链上，从而对多个重链来处理达到查询的目的。 【ps 练
poj 2763 Housewife Wind（树链剖分---边权化点权）
雪的期许
08-13 331
Housewife Wind Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 14220   Accepted: 3935 Description After their royal wedding, Jiajia and Wind ...
树链剖分模板 边权、点权区别
tangzhide123yy的博客
07-29 2442
熟练剖分详解见:https://blog.csdn.net/tangzhide123yy/article/details/77532880 熟练剖分一般有如下几个步骤: 1.dfs1（）求出fa,deep,size,son 2.dfs2（）求出top,p 3.add（）/Query （）树链剖分核心部分 4.updata（）线段树更新操作(如单点修改，区间修改) 5.query（）线段...
树链剖分模板（基于点权，基于边权）
fsdcyr
02-17 2003
树链剖分是数据结构在树上的推广，其实就是把树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 513
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
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值