洛谷P1505 [国家集训队]旅游 （树链剖分+难写的线段树+边权转点权）

最新推荐文章于 2021-11-05 14:51:55 发布
最新推荐文章于 2021-11-05 14:51:55 发布
阅读量174 收藏
点赞数
分类专栏： 模板&裸题 文章标签： dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sancpp/article/details/114006500
版权
本文详细阐述了一种解决树状结构边权操作问题的算法，涉及Ciw操作的特殊处理，以及如何通过树剖和线段树技术实现边权转点权、SUM、MAX和MIN查询。关键在于理解边权到节点权的转换细节和区间处理的边界条件。
摘要由CSDN通过智能技术生成

传送门

题目描述

给定一棵 n 个节点的树，边带权，编号 0∼n−1，需要支持五种操作：

C i w 将输入的第 i 条边权值改为 w
N u v 将 u,v 节点之间的边权都变为相反数
SUM u v 询问 u,v 节点之间边权和
MAX u v 询问 u,v 节点之间边权最大值
MIN u v 询问 u,v 节点之间边权最小值
保证任意时刻所有边的权值都在 [-1000,1000] 内。

分析

树剖裸题。
需要特殊处理的好像只有C操作。
当时实际上，边权转点权的时候细节需要注意！（因为太菜了 在这里被坑了）

树中：边权转点权

如果只有一个点，要特殊处理
假设：1->2 边权为2。
现在将边权放在点2（w[2]=2）上。
当处理[1~2]的时候，没问题，w[2]可以正常使用。
但是在处理[2~2]（2一个点的时候）时，改区间的边权应该是0（没有边）。
普遍的，边权转点权之后，处理l~r区间的时候应该是(l,r]。
所以，在树剖统计的时候需要判断

丑陋的代码

#include <bits/stdc++.h>

using namespace std;
//-----pre_def----
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define fir(i, a, b) for (int i = (a); i <= (b); i++)
#define rif(i, a, b) for (int i = (a); i >= (b); i--)
#define endl '\n'
#define init_h memset(h, -1, sizeof h), idx = 0;
#define lowbit(x) x &(-x)

//---------------
const int N = 2e5 + 10, M = N * 2;
int w[M], h[N], e[M], ne[M], idx;
int nd[N], dep[N], fa[N], son[N], top[N], sz[N], id[N], d[N];
int n, root = 1, cnt;
PII iid[N];
struct node
{
    int l, r, sum, maxx, minn;
    int lz;
} tr[N << 2];

//线段树部分
void add(int a, int b, int v)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = v, h[a] = idx++;
}
void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
    tr[u].maxx = max(tr[u << 1].maxx, tr[u << 1 | 1].maxx);
    tr[u].minn = min(tr[u << 1].minn, tr[u << 1 | 1].minn);
}
void pushdown(int u)
{
    if (tr[u].lz)
    {
        tr[u << 1].sum *= -1;
        tr[u << 1].maxx *= -1;
        tr[u << 1].minn *= -1;
        swap(tr[u << 1].maxx, tr[u << 1].minn);
        tr[u << 1 | 1].sum *= -1;
        tr[u << 1 | 1].maxx *= -1;
        tr[u << 1 | 1].minn *= -1;
        swap(tr[u << 1 | 1].maxx, tr[u << 1 | 1].minn);
        tr[u << 1].lz ^= 1;
        tr[u << 1 | 1].lz ^= 1;
    }
    tr[u].lz = 0;
}
void build(int u, int l, int r)
{
    tr[u] = {l, r, 0, 0, 0, 0};
    if (l == r)
    {
        tr[u] = {l, r, nd[l], nd[l], nd[l], 0};
        return;
    }
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}
void modify1(int u, int l, int r, int k) //已经不会写单点修改了(ㄒxㄒ)
{
    if (l <= tr[u].l && tr[u].r <= r)
    {
        tr[u].sum = k;
        tr[u].maxx = k;
        tr[u].minn = k;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid)
        modify1(u << 1, l, r, k);
    if (mid < r)
        modify1(u << 1 | 1, l, r, k);
    pushup(u);
}
void modify2(int u, int l, int r) //区间乘-1
{
    if (l <= tr[u].l && tr[u].r <= r)
    {
        tr[u].sum *= -1;
        int tmp1 = tr[u].maxx;
        int tmp2 = tr[u].minn;
        tr[u].maxx = -tmp2;
        tr[u].minn = -tmp1;
        tr[u].lz ^= 1;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid)
        modify2(u << 1, l, r);
    if (mid < r)
        modify2(u << 1 | 1, l, r);
    pushup(u);
}
int query_s(int u, int l, int r) //查询区间和
{
    if (l <= tr[u].l && tr[u].r <= r)
    {
        return tr[u].sum;
    }
    pushdown(u);
    int res = 0;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid)
        res += query_s(u << 1, l, r);
    if (mid < r)
        res += query_s(u << 1 | 1, l, r);
    pushup(u);
    return res;
}
int query_minn(int u, int l, int r) //查询区间最小值
{
    if (l <= tr[u].l && tr[u].r <= r)
    {
        return tr[u].minn;
    }
    pushdown(u);
    int res = INF;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid)
        res = min(res, query_minn(u << 1, l, r));
    if (mid < r)
        res = min(res, query_minn(u << 1 | 1, l, r));
    pushup(u);
    return res;
}
int query_maxx(int u, int l, int r) //查询区间最大值
{
    if (l <= tr[u].l && tr[u].r <= r)
    {
        return tr[u].maxx;
    }
    pushdown(u);
    int res = -INF;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid)
        res = max(res, query_maxx(u << 1, l, r));
    if (mid < r)
        res = max(res, query_maxx(u << 1 | 1, l, r));
    pushup(u);
    return res;
}
//树剖部分
void dfs1(int u, int father, int depth)
{
    dep[u] = depth, fa[u] = father, sz[u] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int t = e[i];
        if (t == father)
            continue;
        dfs1(t, u, depth + 1);
        d[t] = w[i];
        sz[u] += sz[t];
        if (sz[son[u]] < sz[t])
            son[u] = t;
    }
}
void dfs2(int u, int t)
{
    id[u] = ++cnt;
    nd[cnt] = d[u];
    top[u] = t; //u点所在重链的顶端是t
    if (!son[u])
        return;
    dfs2(son[u], t);
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa[u] || j == son[u])
            continue;
        dfs2(j, j);
    }
}
void modify_path(int u, int v)
{
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]])
            swap(u, v);
        modify2(1, id[top[u]], id[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v])
        swap(u, v);
    if (u != v) //要判断！！
        modify2(1, id[v] + 1, id[u]);
}
int query_sum(int u, int v)
{
    int res = 0;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]])
            swap(u, v);
        res += query_s(1, id[top[u]], id[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v])
        swap(u, v);

    if (u != v) //要判断！！
        res += query_s(1, id[v] + 1, id[u]);
    return res;
}
int query_max(int u, int v)
{
    int res = -INF;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]])
            swap(u, v);
        res = max(res, query_maxx(1, id[top[u]], id[u]));
        u = fa[top[u]];
    }
    if (dep[u] < dep[v])
        swap(u, v);
    if (u != v) //要判断！！
        res = max(res, query_maxx(1, id[v] + 1, id[u]));
    return res;
}
int query_min(int u, int v)
{
    int res = INF;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]])
            swap(u, v);
        res = min(res, query_minn(1, id[top[u]], id[u]));
        u = fa[top[u]];
    }
    if (dep[u] < dep[v])
        swap(u, v);
    if (u != v) //要判断！！
        res = min(res, query_minn(1, id[v] + 1, id[u]));
    return res;
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    int StartTime = clock();
#endif
    scanf("%d", &n);
    init_h;
    fir(i, 1, n - 1)
    {
        int a, b, v;
        scanf("%d%d%d", &a, &b, &v);
        add(a + 1, b + 1, v);
        add(b + 1, a + 1, v);
        iid[i] = {a + 1, b + 1};
    }
    dfs1(1, -1, 1);
    dfs2(1, 1);
    build(1, 1, n);
    int m;
    scanf("%d", &m);
    while (m--)
    {
        char op[5];
        int u, v;
        scanf("%s%d%d", op, &u, &v);
        if (!strcmp(op, "SUM"))
        {
            printf("%d\n", query_sum(u + 1, v + 1));
        }
        else if (!strcmp(op, "MAX"))
        {
            printf("%d\n", query_max(u + 1, v + 1));
        }
        else if (!strcmp(op, "MIN"))
        {
            printf("%d\n", query_min(u + 1, v + 1));
        }
        else if (!strcmp(op, "C"))
        {
            int tmp;
            if (dep[iid[u].first] > dep[iid[u].second])
            {
                tmp = id[iid[u].first];
            }
            else
            {
                tmp = id[iid[u].second];
            }
            modify1(1, tmp, tmp, v);
        }
        else
        {
            modify_path(u + 1, v + 1);
        }
    }
#ifndef ONLINE_JUDGE
    printf("Run_Time = %d ms\n", clock() - StartTime);
#endif
    return 0;
}

大佬们的线段树写得好漂亮，下回去学学。。

sancpp
关注
专栏目录
洛谷P1505 [国家集训队]旅游（树链剖分）
苟为蒟蒻又何妨
06-29 337
旅游 题目描述 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w，也就是说，Ray 经过...
洛谷P1505 [国家集训队]旅游（BZOJ2157）
forezxl的博客
06-06 349
树链剖分 洛谷题目传送门 BZOJ题目传送门 操作有点多的裸树剖。套路下放边权后就是打板子。注意操作的时候不要包括LCA。 代码： #include&lt;cctype&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #define N 20005 #define F inline ...
2018.06.29 洛谷P1505 [国家集训队]旅游（树链剖分）
weixin_30437481的博客
06-29 128
旅游 题目描述 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座...
洛谷 P1505 旅游 【树链剖分+线段树】
HungTeen的博客
08-30 264
题目来源：https://www.luogu.org/problem/P1505 ★这题debug了一下午，最后终于AC了~ 代码： #include<iostream> #include<algorithm> #include<cmath> #include<cstdio> #include<cstring> #include&l...
洛谷P1505 [国家集训队]旅游 树剖+边权化点权+线段树
danzh
07-15 159
洛谷P1505 [国家集训队]旅游 标签 树链剖分 边权化点权 线段树 简明题意 给一棵树及边权，需要支持5种操作： 修改：将第i条边权改为c 修改：将u–v路径的所有边权全部取相反数 查询：查询u–v路径中的边权和 查询：查询u–v路径中边权最大值 查询：查询u–v路径中边权最小值 思路 果断边权化点权，然后剖，剖完用tag线段树维护。于是就成了板子题，很简单了 注意...
LUOGU P1505 [国家集训队]旅游 (树链剖分+线段树)
weixin_30565327的博客
10-01 124
传送门 解题思路 快被调死的码农题，，，其实就是一个边权下放到点权的线段树+树剖。 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<cstdlib> using namespace ...
洛谷 P1505 [国家集训队]旅游 树链剖分
weixin_30347335的博客
09-26 165
目录 题面 题目链接 题目描述 输入输出格式 输入格式 输出格式 输入输出样例 输入样例： 输出样例： 说明 思路...
洛谷P1505 [国家集训队]旅游 (树链剖分)
weixin_43519763的博客
10-25 227
洛谷P1505 [国家集训队]旅游 题目描述 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w...
P1505 [国家集训队]旅游 (树链剖分)
Fau的博客
11-05 193
题目链接: P1505 [国家集训队]旅游 大致题意 给定一棵nnn个节点的树, 边带权, 编号 000 ~ n−1n - 1n−1, 需要支持五种操作： C i w 将输入的第iii条边权值改为www N u v 将u,vu, vu,v节点之间的边权都变为相反数 SUM u v 询问u,vu, vu,v节点之间边权和 MAX u v 询问u,vu, vu,v节点之间边权最大值 MIN u v 询问u,vu, vu,v节点之间边权最小值 保证任意时刻所有边的权值都在 [−1000,1000][-1000,
树链剖分及进阶 边权化点权 luogu4315 luogu1505
WWL0702的博客
11-04 357
树链剖分模板 点权 2遍dfs+线段树 #include <bits/stdc++.h> using namespace std; #define rep(i,a,n) for(int i=a;i<n;i++) #define per(i,a,n) for(int i=n-1;i>=a;i--) typedef long long ll; typedef double db; typedef pair<int,int> P; typedef vector<int&g
树链剖分瞎入门
Venus的博客
01-09 455
本文旨在让读者背代码 前言 在做题时，我们可能会遇到这样一类问题： 给定一棵 nnn 个结点的树和 mmm 次操作，操作有两种，一种是给定两个结点，让连接两个结点的路径上的所有点权值加上一个值，另一种是查询路径上所有点的权值和。n≤1e5n\le 1e5n≤1e5，m≤2e5m\le 2e5m≤2e5。 如果是最后统一输出结点权值，用树上差分+DFS\text{DFS}DFS 就能轻松水过，而...
【贪心】洛谷 P1505 苹果摘陶陶
。。。。
05-12 717
题目背景根据2005年的Noip普及组第一题衍生出的一题。但是有一点点的恶搞成分在里面…..题目描述话说去年苹果们被陶陶摘下来后都很生气，于是就用最先进的克隆技术把陶陶克隆了好多份>.<然后把他们挂在树上，准备摘取。摘取的规则是，一个苹果只能摘一个陶陶，且只能在它所能摘到的高度以下的[b]最高的[/b]陶陶，如果摘不到的话只能灰溜溜的走开了>.<给出苹果数目及每个苹果可以够到的高度和各个陶陶的高度，
【学习笔记】重链剖分
Fight_for_NOIP的博客
12-19 590
树链剖分，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构来维护每一条链。 树链剖分其实分三种：重链剖分，长链剖分，实虚链剖分。 所以，为了使整体显得更有条理（其实是我还没学完 ），我就分开写了。...
2021牛客寒假算法基础集训营6 G.机器人 （状压dp+__int128）
sancpp的博客
02-25 1525
传送门 题意 有 n 个机器人，每个机器人会读入一个 x ，并返回 ax+b 。 现在银临姐姐手里有一个数 x ，她想将机器人按某种顺序排列，使得最终返回得到的 x 尽可能大。 对于所有的数据，1≤n,x,ai,bi≤20\le n,x,a_i,b_i\le20≤n,x,ai​,bi​≤20 。 分析 区间dp裸题，但是动手算算上界会超longlong。 调了好久的高精都有问题（板子是很久之前写的，现在看起来当时写的并不好），最后__int128水过去了。 关于__int128 仔细整理一下__int128
NC201891 采蘑菇的克拉莉丝（树链剖分）
sancpp的博客
03-06 1076
传送门 分析 先处理出重链，再用线段树维护区间和（单点更新） 查询核心代码 LL ans = 0; for (int i = h[root]; ~i; i = ne[i])//便利当前root所连的所有边 { int t = e[i];//与root直接相连的点 if (t == fa[root])//如果是父节点 { ans += (query_tree(1) - query_tree(root)) * w[i]; } else//如果是儿子节点 {
Acwing_920. 最优乘车（最短路问题经典建图+细节处理）
sancpp的博客
08-03 811
920. 最优乘车问题链接分析具体代码 问题链接 link. 分析 虽然是道20年前的noip老题，难度不大。但是有许多细节点还是值得一说。 要点： 1.sstream库。 2.边权为1的最短路问题可以直接bfs求解。 3.经典建图方式。 建图方式：对于上游车站，向所有下游车站连一条边。答案就是从1号点到n号点的最短路-1。 处理输入：sstream库函数（随便看了看，还没怎么搞懂）。。 具体代码 #include <bits/stdc++.h> using namespace std;
点分治模板、例题整理
sancpp的博客
05-02 646
传送门 1.题意 求一个树中距离小于等于k的点对的个数。 1≤N≤1041≤N≤10^41≤N≤104 2.分析 点分治算法： 树的重心 树的重心是指：删除该点后，最大子树（的点数）最小的点。 关于重心的结论：删除重心之后，最大子树的点数小于等于总点数/2。 于是：我们可以将一个树上问题删去重心点之后分解成若干个子树内部的问题和子树之间的问题。这样可以保证是log级的时间复杂度。（边分治则不行，会被菊花图卡成n） 关于本题 我们先将重心找出来，然后路径小于等于k的点对可以分成如下： 1.两点在同一颗子树中。
[Acwing.291] 蒙德里安的梦想（状态压缩DP复习+总结）
sancpp的博客
08-10 438
个人总结!!（棋盘式状态压缩DP） 0.状态压缩dp的缺点&标志 毫无疑问，指数级时间复杂度——导致棋盘的大小一般为二位数，才能用状态压缩dp求解。 1.求解此类问题 棋盘式状态压缩DP本质上是在一个棋盘内填奇奇怪怪的不同形状的块，（然后求方案数？） 2.思维难度 要能看出这是动态规划的题目，并建立状态表示，思考出状态转移。 一般来说求解该问题可以用以下几点 0.一列一列转移， 1.遍历一遍所有状态，找出所有合法状态（具体题目具体分析）。 2.二维遍历所有状态，建立状态与状态之间的转移关系（具体题目
P1005 [NOIP2007 提高组] 矩阵取数游戏（区间dp+__int128）
sancpp的博客
02-25 388
传送门 思路不解释了：大佬的题解 看到这题__int128也能过，想拿__int128试试。 遇到的小坑： f[i][j] = max(f[i - 1][j] + (1 << (m - j + i - 1)) * d[i - 1], f[i][j]); f[i][j] = max(f[i][j + 1] + (1 << (m - j + i - 1)) * d[j + 1], f[i][j]); 上面的写法是错的（不知道怎么解释 ） f[i][j] = max(f[i - 1][j
HP LaserJet P1007/1008/P1505/P1505N 打印机用户手册
"HP1007,1008,P1505,P1505N打印机用户指南" 这份用户指南详细介绍了HP LaserJet系列的四款打印机——HP 1007、1008、P1505以及P1505N的使用方法和技术细节。指南由Hewlett-Packard Development Company, L.P.在2007...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值