离线处理 + dfs序 + 区间修改 + 单点查询

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量98 收藏
点赞数
分类专栏： 算法题 cf 文章标签： 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63432403/article/details/134144255
版权
算法题 同时被 2 个专栏收录
114 篇文章 0 订阅
订阅专栏
cf
39 篇文章 0 订阅
订阅专栏

cfdiv2 #907场的F是牛客原题，过的很多，作为数据结构手竟然没有做过&据说很典，实在是太差劲了，于是第二天就来做这道题。

牛客：华华和月月种树 (nowcoder.com)

cf：Problem - F - Codeforces

牛客题意描述（cf的差不多）：有n个操作：

  • 1 i：表示节点i长出了一个新的儿子节点，权值为0，编号为当前最大编号+1
  • 2 i a：使以i为根的子树中节点加上a
  • 3 i：询问i节点的权值

这一题由于是动态的，不能一遍得到，但是又不能每次加点后来个build。但是发现求的是第i个节点的权值，根据dfs序的性质，我们可以求出最终态的dfs序。由于每个节点都是其中一个已经存在的节点的儿子节点，所以用终态dfs序建好线段树后，在遍历n次操作时：

  • 如果是加点操作那么就需要记录当前这个点的权值，因为这个点在没有加上之前，该点权值一定是0，但是前面可能对终态该点祖先节点进行了操作2，要将之前对该点的加权值给撤销掉，因此需要记录加之前该点权值。之后查询到该点时，答案就是查询到该点的值减去org【该点对应的dfs序下标】（org数组是：添加该点之前，该点有的权值。
  • 区间操作同基础线段树
  • 查询点i：i点权值减去org【i点对应的dfs序下标】

因此代码实现为：

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <ctime>
#include <random>
#include <sstream>
#include <numeric>
#include <stdio.h>
#include <functional>
#include <bitset>
#include <algorithm>
using namespace std;

// #define Multiple_groups_of_examples
#define int_to_long_long
#define IOS std::cout.tie(0);std::cin.tie(0)->sync_with_stdio(false); // 开IOS，需要保证只使用Cpp io流 *
#define dbgnb(a) std::cout << #a << " = " << a << '\n';
#define dbgtt cout<<" !!!test!!! "<<'\n';
#define rep(i,x,n) for(int i = x; i <= n; i++)

#define all(x) (x).begin(),(x).end()
#define pb push_back
#define vf first
#define vs second

typedef long long LL;
#ifdef int_to_long_long
#define int long long
#endif
typedef pair<int,int> PII;

const int INF = 0x3f3f3f3f;
const int N = 2e5 + 21;


struct SegTree {
    static const int N = 1e6 + 21;
    struct node {
        int l, r, mi;
        LL sum,add;
    }tr[N << 2];
    int w[N];
    // 左子树
    inline int ls(int p) {return p<<1; }
    // 右子树
    inline int rs(int p) {return p<<1|1; }
    // 向上更新
    void pushup(int u) {
        tr[u].sum = tr[ls(u)].sum + tr[rs(u)].sum;
        tr[u].mi = min(tr[ls(u)].mi, tr[rs(u)].mi);
    }
    // 向下回溯时，先进行更新
    void pushdown(int u) { // 懒标记，该节点曾经被修改，但其子节点尚未被更新。
        auto &root = tr[u], &right = tr[rs(u)], &left = tr[ls(u)];
        if(root.add) {
            right.add += root.add; right.sum += (LL)(right.r - right.l + 1)*root.add; right.mi -= root.add;
            left.add += root.add; left.sum += (LL)(left.r - left.l + 1)*root.add; left.mi -= root.add;
            root.add = 0;
        }

    }
    // 建树
    void build(int u, int l, int r) {
        if(l == r) tr[u] = {l, r, w[r], w[r], 0};
        else {
            tr[u] = {l,r}; // 容易忘
            int mid = l + r >> 1;
            build(ls(u), l, mid), build(rs(u), mid + 1, r);
            pushup(u);
        }
    }
    // 修改
    void modify(int u, int l, int r, int d) {
        if(tr[u].l >= l && tr[u].r <= r) {
            tr[u].sum += (LL)(tr[u].r - tr[u].l + 1)*d;
            tr[u].add += d;
        }
        else {
            pushdown(u);
            int mid = tr[u].l + tr[u].r >> 1;
            if(l <= mid) modify(ls(u), l ,r, d);
            if(r > mid) modify(rs(u), l, r, d);
            pushup(u);
        }
    }
    // 查询
    LL query(int u, int l, int r) {
        if(tr[u].l >= l && tr[u].r <= r) {
            return tr[u].sum;
        }
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        LL sum = 0;
        if(l <= mid) sum = query(ls(u), l, r);
        if(r > mid ) sum += query(rs(u), l, r);
        return sum;
    }
}tree;
// 当输入数据大于 1e6 时用快读
inline int fread() // 快读
{
    int x = 0, f = 1; char ch = getchar();
    while(ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar(); }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + (ch - '0');
        ch = getchar();
    }
    return x * f;
}
void inpfile();
void solve() {
    int n = fread();
    vector<int> a(n + 1);
    vector<vector<int>> g(n+1);
    // 离线存储操作
    vector<array<int,3>> ask(n);
    int now = 1; // now加点的编号
    for(int i = 0; i < n; ++i) {
        ask[i][0] = fread(), ask[i][1] = fread();
        ask[i][1]++;
        if(ask[i][0] == 1) {
            int u = ask[i][1];
            // 这里给出顺序了 i是父节点，因此不用建双边
            g[u].push_back(++now);
            // 将加后的点编号存入
            ask[i][2] = now;
        } else if(ask[i][0] == 2) ask[i][2] = fread();
    }

    // dfs序求法
    vector<int> l(n + 1), r(n + 1);
    int cnt = 0;
    auto dfs = [&](auto &&self, int u, int fa) -> void {
        l[u] = ++cnt;
        for(auto y: g[u]) {
            if(y == fa) continue;
            self(self, y,u);
        }
        r[u] = cnt;
    };
    dfs(dfs, 1,-1);

    // 建树
    tree.build(1,1,now);
    vector<int> org(n + 1);
    for(int i = 0; i < n; ++i) {
        // 操作1：获得在v点插入之前，v点权值被加了多少
        if(ask[i][0] == 1) {
            int v = ask[i][2], u = ask[i][1];
            org[l[v]] += tree.query(1, l[u], l[u]);
        } else if(ask[i][0] == 2) { // 正常修改即可
            int x = ask[i][1], y = ask[i][2];
            tree.modify(1,l[x], r[x], y);
        } else {
            int x = ask[i][1];
            // 查询到的值 - x插入之前被加了多少
            cout<<tree.query(1, l[x], l[x]) - org[l[x]]<<'\n';
        }
    }
}
#ifdef int_to_long_long
signed main()
#else
int main()
#endif

{
    #ifdef Multiple_groups_of_examples
    int T; cin>>T;
    while(T--)
    #endif
    solve();
    return 0;
}
void inpfile() {
    #define mytest
    #ifdef mytest
    freopen("ANSWER.txt", "w",stdout);
    #endif
}

cfdiv2 #907F是最后输出所有节点权值，数组需要开大点，不然会wa35。（感觉是牛客数据弱，没有cf第35那个数据，那个数据可能是n个操作全是插入点。

cfdiv2 #907F AC代码：

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <ctime>
#include <random>
#include <sstream>
#include <numeric>
#include <stdio.h>
#include <functional>
#include <bitset>
#include <algorithm>
using namespace std;

#define Multiple_groups_of_examples
#define int_to_long_long
#define IOS std::cout.tie(0);std::cin.tie(0)->sync_with_stdio(false); // 开IOS，需要保证只使用Cpp io流 *
#define dbgnb(a) std::cout << #a << " = " << a << '\n';
#define dbgtt cout<<" !!!test!!! "<<'\n';
#define rep(i,x,n) for(int i = x; i <= n; i++)

#define all(x) (x).begin(),(x).end()
#define pb push_back
#define vf first
#define vs second

typedef long long LL;
#ifdef int_to_long_long
#define int long long
#endif
typedef pair<int,int> PII;

const int INF = 0x3f3f3f3f;
// const int N = 2e5 + 21;


struct SegTree {
    static const int N = 5e5 + 21;
    struct node {
        int l, r, mi;
        LL sum,add;
    }tr[N << 2];
    int w[N];
    // 左子树
    inline int ls(int p) {return p<<1; }
    // 右子树
    inline int rs(int p) {return p<<1|1; }
    // 向上更新
    void pushup(int u) {
        tr[u].sum = tr[ls(u)].sum + tr[rs(u)].sum;
        tr[u].mi = min(tr[ls(u)].mi, tr[rs(u)].mi);
    }
    // 向下回溯时，先进行更新
    void pushdown(int u) { // 懒标记，该节点曾经被修改，但其子节点尚未被更新。
        auto &root = tr[u], &right = tr[rs(u)], &left = tr[ls(u)];
        if(root.add) {
            right.add += root.add; right.sum += (LL)(right.r - right.l + 1)*root.add; right.mi -= root.add;
            left.add += root.add; left.sum += (LL)(left.r - left.l + 1)*root.add; left.mi -= root.add;
            root.add = 0;
        }

    }
    // 建树
    void build(int u, int l, int r) {
        if(l == r) tr[u] = {l, r, w[r], w[r], 0};
        else {
            tr[u] = {l,r}; // 容易忘
            int mid = l + r >> 1;
            build(ls(u), l, mid), build(rs(u), mid + 1, r);
            pushup(u);
        }
    }
    // 修改
    void modify(int u, int l, int r, int d) {
        if(tr[u].l >= l && tr[u].r <= r) {
            tr[u].sum += (LL)(tr[u].r - tr[u].l + 1)*d;
            tr[u].add += d;
        }
        else {
            pushdown(u);
            int mid = tr[u].l + tr[u].r >> 1;
            if(l <= mid) modify(ls(u), l ,r, d);
            if(r > mid) modify(rs(u), l, r, d);
            pushup(u);
        }
    }
    // 查询
    LL query(int u, int l, int r) {
        if(tr[u].l >= l && tr[u].r <= r) {
            return tr[u].sum;
        }
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        LL sum = 0;
        if(l <= mid) sum = query(ls(u), l, r);
        if(r > mid ) sum += query(rs(u), l, r);
        return sum;
    }
}tree;
// 当输入数据大于 1e6 时用快读
inline int fread() // 快读
{
    int x = 0, f = 1; char ch = getchar();
    while(ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar(); }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + (ch - '0');
        ch = getchar();
    }
    return x * f;
}
void inpfile();
void solve() {
    int n = fread();
    vector<int> a(n + 1);
    vector<vector<int>> g(n+21);
    vector<array<int,3>> ask(n);
    int now = 1;
    for(int i = 0; i < n; ++i) {
        ask[i][0] = fread(), ask[i][1] = fread();
        // ask[i][1]++;
        if(ask[i][0] == 1) {
            int u = ask[i][1];
            g[u].push_back(++now);
            ask[i][2] = now;
        } else if(ask[i][0] == 2) ask[i][2] = fread();
    }
    vector<int> l(n + 21), r(n + 21);
    int cnt = 0;
    auto dfs = [&](auto &&self, int u, int fa) -> void {
        l[u] = ++cnt;
        for(auto y: g[u]) {
            if(y == fa) continue;
            self(self, y,u);
        }
        r[u] = cnt;
    };
    dfs(dfs, 1,-1);
    // for(int i = 1; i <= n; ++i) tree.w[l[i]] = 0;
    tree.build(1,1,now);
    vector<int> org(n + 21);
    for(int i = 0; i < n; ++i) {
        if(ask[i][0] == 1) {
            int v = ask[i][2], u = ask[i][1];
            org[l[v]] += tree.query(1, l[u], l[u]);
        } else if(ask[i][0] == 2) {
            int x = ask[i][1], y = ask[i][2];
            tree.modify(1,l[x], r[x], y);
        } else {
            // int x = ask[i][1];
            // cout<<tree.query(1, l[x], l[x]) - org[l[x]]<<' ';
        }
    }
    for(int i = 1; i <= now; ++i) cout<<tree.query(1, l[i], l[i]) - org[l[i]]<<" ";
    puts("");
    for(int i = 0; i <= n; ++i) tree.w[i] = 0;
}
#ifdef int_to_long_long
signed main()
#else
int main()
#endif

{
    #ifdef Multiple_groups_of_examples
    int T; cin>>T;
    while(T--)
    #endif
    solve();
    return 0;
}
void inpfile() {
    #define mytest
    #ifdef mytest
    freopen("ANSWER.txt", "w",stdout);
    #endif
}
golemon.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
dfs序基本类型 详细
kkkkahlua的博客
08-25 732
参考dfs序七个经典问题 ——weeping本博文又名：手把手教你写树状数组1. 单点修改，子树和查询单点修改，区间查询树状数组维护每个点的权值： 1. 修改xx（增加ww）：单点修改——add(x,w); 2. 查询xx的子树：区间查询——ans=query(le[x])-query(ri[x]-1);2. 单点修改，树链和查询首先将 u−vu-v 树链和查询转化成 u−root,v−
D. Tree and Queries （dfs序+莫队 /树上启发式合并）
矮纸斜行闲作草
10-03 242
传送门 可以离线，子树查询，数据范围是1e5，妥妥的莫队水题。 全局维护num[i]表示颜色i出现的次数,cnt[i]表示出现次数大于等于i次的颜色种类数。 当新加入颜色x,cnt[num[x]+1]+1,num[x]+1 当减去颜色x，cnt[num[x]]-1 ,num[x]-1, 代码略。 如果考虑用树上启发式，我们同样维护num[i],cnt[i]，含义一样。 当然如果用cnt[i]表示出现次数恰好等于i次的颜色种类数，那么每次查询都是区间查询，需要对cnt这个桶，建线段树维护。 #include
树状数组/dfs序/离线（HDU - 5877 Weak Pair）
平凡人Kalzn的博客
08-20 118
题目链接 做过类似的题，是求区间内不超过k的最大值。这个题是做一个dfs序。在区间[l,r]找不超过k/val[l]的值。不过因为%lld读入写成了%d的问题，wa了近3个小时，10+发。菜到想抽自己。 下面是ac代码： #include <iostream> #include <string> #include <cstring> #include <q...
线段树区间修改，区间查询最大值
qq_59144780的博客
10-29 223
分析： 我们可以把树上问题转换为序列问题， 跑一遍dfs得到dfs序, in[], out[]， 然后可以得到每个节点x为根节点的子树在dfs序中的范围 in[x] ~ out[x]. 然后问题就转换为线段树区间修改，区间查询最值。题意：给你一颗树，多次操作，操作一： 给两个数x , k，让以x为根节点的子树(包括它自己) 中所有节点值 + k；操作二： 给一个数x, 问以x为根节点的子树(包括它自己) 中所有节点值的最大值。最开始所有节点值为0；
CodeForces 570D(dfs序 or 离线dfs)
playwfun的专栏
04-06 483
题目意思：     给定一颗root为1的树，节点最多5e5个，每个节点有一个英文字母，要求在指定子树根节点x，和指定深度y，求该子树y深度所有节点的字母能不能组成回文串。 解法1：    利用dfs序，为所有点标上进出两个标记，既可以代表一个区间(dfs序很重要的一个应用)，顺便将每个深度下所有的单个字母出现的标号统计到相应的vector中后， 在计算答案时进行26次二分上下界求
[数仓]七、离线数仓（Presto&Kylin即席查询）
weixin_44428807的博客
07-08 247
第1章 Presto 1.1 Presto简介 1.1.1Presto概念 1.1.2 Presto架构
kylin调优，项目中错误总结，知识点总结，kylin jdbc driver + 数据库连接池druid + Myba
qq_44884269的博客
04-17 800
kylin调优，项目中错误总结，知识点总结，kylin jdbc driver + 数据库连接池druid + Myba
板子总和+
weixin_44224825的博客
09-03 2723
国庆板子 前言 对拍模板bat @echo off :loop D:/LSNU/codeforces/code/MakeData.exe D:/LSNU/codeforces/code/A.exe D:/LSNU/codeforces/code/force.exe fc AC.txt WA.txt if not errorlevel 1 goto loop pause :end 说明 模板 //#pragma comment(linker,"/STACK:1024000000,1024000000")
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5150
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 514
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 601
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1042
动态规划
树状数组记录
最新发布
volcan的博客
09-06 454
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 407
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1068
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
算法训练营|图论第8天 拓扑排序 dijkstra
qq_53125539的博客
09-02 510
拓扑排序。
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 420
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
循环结构程序
BlueBachke的博客
09-03 474
循环结构的基础知识
奇偶性剪枝优化DFS+BFS搜索算法
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的搜索算法，它们在处理这类问题时有着不同的策略。DFS更像树的先根遍历，它会尽可能深地探索一条路径，直到无法继续为止，然后回溯到其他未探索的分支。这在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

golemon.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值