【洛谷3822】[NOI2017] 整数（线段树压位）

最新推荐文章于 2022-05-28 21:19:49 发布
转载 最新推荐文章于 2022-05-28 21:19:49 发布 · 136 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zyt1253679098/p/10993308.html

本文详细解析洛谷3822题目的解题思路，采用线段树优化算法，通过压缩位数减少复杂度，实现高效处理二进制位运算。文章深入讲解了加法和减法的位操作细节，以及如何利用线段树进行快速查找和修改。

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

题目：

洛谷 3822

分析：

直接按题意模拟，完了。

将每次加 / 减拆成不超过 \(32\) 个对单独一位的加 / 减。

考虑给一个二进制位（下称「当前位」）加 \(1\) 时，如果这一位本来就是 \(0\) ，那么直接变成 \(1\) 。否则要考虑进位：向左（以后默认从右向左为低位至高位，与书写顺序相同）找到第一个为 \(0\) 的位 \(p\) ，将其变成 \(1\) ，并把从 \(p\) 到当前位中间所有的 \(1\) 变成 \(0\) 。

减法是类似的。退位操作就是向左找到第一个 \(1\) ，将其变成 \(0\) ，并把中间所有 \(0\) 变成 \(1\) 。

以上找第一个 \(1\) 或者 \(0\) 和区间修改均可用线段树完成，只需要维护每个结点对应的区间是否全 \(0\) 或全 \(1\) 即可。

但是将一个询问拆成 \(32\) 次常数太大，\(3.2\times 10^7\) 次修改再带上线段树的 \(\log 3\times 10^7\) 根本过不去。考虑压位，线段树每个叶子表示连续多个（我的代码中使用的是 \(60\) 个）二进制位，找第一个 \(1\) / \(0\) 改为找第一个非 \(0\) （全 \(0\) ） / 非 \(2^{60}\) （全 \(1\) ）的数。这样，每次修改只需要拆成最多对两个位置的加 / 减。复杂度 \(O(n\log m)\) 其中 \(m\) 是最大位数。

代码：

注意线段树上二分找第一个非全 \(0\) / 非全 \(1\) 的数的做法。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;

namespace zyt
{
    template<typename T>
    inline bool read(T &x)
    {
        char c;
        bool f = false;
        x = 0;
        do
            c = getchar();
        while (c != EOF && c != '-' && !isdigit(c));
        if (c == EOF)
            return false;
        if (c == '-')
            f = true, c = getchar();
        do
            x = x * 10 + c - '0', c = getchar();
        while (isdigit(c));
        if (f)
            x = -x;
        return true;
    }
    template<typename T>
    inline void write(T x)
    {
        static char buf[20];
        char *pos = buf;
        if (x < 0)
            putchar('-'), x = -x;
        do
            *pos++ = x % 10 + '0';
        while (x /= 10);
        while (pos > buf)
            putchar(*--pos);
    }
    typedef unsigned long long ull;
    const int N = 1e6 + 10, DIGIT = 60;
    const ull BASE = 1ULL << DIGIT;
    namespace Segment_Tree
    {
        struct node
        {
            ull val;
            bool all0, all1, tag0, tag1;
        }tree[N << 2];
        void cov0(const int rot)
        {
            tree[rot].val = 0;
            tree[rot].all0 = tree[rot].tag0 = true;
            tree[rot].all1 = tree[rot].tag1 = false;
        }
        void cov1(const int rot)
        {
            tree[rot].val = BASE - 1ULL;
            tree[rot].all1 = tree[rot].tag1 = true;
            tree[rot].all0 = tree[rot].tag0 = false;
        }
        void update(const int rot)
        {
            tree[rot].all0 = (tree[rot << 1].all0 && tree[rot << 1 | 1].all0);
            tree[rot].all1 = (tree[rot << 1].all1 && tree[rot << 1 | 1].all1);
        }
        void pushdown(const int rot)
        {
            if (tree[rot].tag0)
            {
                cov0(rot << 1), cov0(rot << 1 | 1);
                tree[rot].tag0 = false;
            }
            else if (tree[rot].tag1)
            {
                cov1(rot << 1), cov1(rot << 1 | 1);
                tree[rot].tag1 = false;
            }
        }
        void cover0(const int rot, const int lt, const int rt, const int ls, const int rs)
        {
            if (ls <= lt && rt <= rs)
            {
                cov0(rot);
                return;
            }
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (ls <= mid)
                cover0(rot << 1, lt, mid, ls, rs);
            if (rs > mid)
                cover0(rot << 1 | 1, mid + 1, rt, ls, rs);
            update(rot);
        }
        void cover1(const int rot, const int lt, const int rt, const int ls, const int rs)
        {
            if (ls <= lt && rt <= rs)
            {
                cov1(rot);
                return;
            }
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (ls <= mid)
                cover1(rot << 1, lt, mid, ls, rs);
            if (rs > mid)
                cover1(rot << 1 | 1, mid + 1, rt, ls, rs);
            update(rot);
        }
        void change(const int rot, const int lt, const int rt, const int pos, const ull x)
        {
            if (pos > rt)
                return;
            if (lt == rt)
            {
                tree[rot].val = x;
                tree[rot].all0 = (x == 0);
                tree[rot].all1 = (x == (BASE - 1ULL));
                return;
            }
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (pos <= mid)
                change(rot << 1, lt, mid, pos, x);
            else
                change(rot << 1 | 1, mid + 1, rt, pos, x);
            update(rot);
        }
        ull query(const int rot, const int lt, const int rt, const int pos)
        {
            if (lt == rt)
                return tree[rot].val;
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (pos <= mid)
                return query(rot << 1, lt, mid, pos);
            else
                return query(rot << 1 | 1, mid + 1, rt, pos);
        }
        int find0(const int rot, const int lt, const int rt, const int pos)
        {
            if (lt == rt)
                return lt;
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (pos <= mid && !tree[rot << 1].all1)
            {
                int ans = find0(rot << 1, lt, mid, pos);
                if (ans <= N)
                    return ans;
            }
            if (!tree[rot << 1 | 1].all1)
                return find0(rot << 1 | 1, mid + 1, rt, pos);
            else
                return N + 1;
        }
        int find1(const int rot, const int lt, const int rt, const int pos)
        {
            if (lt == rt)
                return lt;
            int mid = (lt + rt) >> 1;
            pushdown(rot);
            if (pos <= mid && !tree[rot << 1].all0)
            {
                int ans = find1(rot << 1, lt, mid, pos);
                if (ans <= N)
                    return ans;
            }
            if (!tree[rot << 1 | 1].all0)
                return find1(rot << 1 | 1, mid + 1, rt, pos);
            else
                return N + 1;
        }
        void init()
        {
            cov0(1);
        }
    }
    ull extract(const ull a, const int l, const int r)
    {
        return (a & ((1ULL << r) - 1ULL)) >> l;
    }
    bool check(const ull a, const int p)
    {
        return a & (1ULL << p);
    }
    void add(const ull a, const int p)
    {
        using namespace Segment_Tree;
        ull now = query(1, 0, N, p);
        if (now + a >= BASE)
        {
            int pos = find0(1, 0, N, p + 1);
            ull tmp = query(1, 0, N, pos);
            change(1, 0, N, pos, tmp + 1ULL);
            if (pos > p + 1)
                cover0(1, 0, N, p + 1, pos - 1);
        }
        change(1, 0, N, p, (now + a) % BASE);
    }
    void sub(const ull a, const int p)
    {
        using namespace Segment_Tree;
        ull now = query(1, 0, N, p);
        if (now < a)
        {
            int pos = find1(1, 0, N, p + 1);
            ull tmp = query(1, 0, N, pos);
            change(1, 0, N, pos, tmp - 1ULL);
            if (pos > p + 1)
                cover1(1, 0, N, p + 1, pos - 1);
        }
        change(1, 0, N, p, (now - a + BASE) % BASE);
    }
    int work()
    {
        using namespace Segment_Tree;
        int n, t1, t2, t3;
        read(n), read(t1), read(t2), read(t3);
        init();
        while (n--)
        {
            int opt;
            read(opt);
            if (opt == 1)
            {
                int a, b;
                read(a), read(b);
                if (a > 0) //ADD
                {
                    add(extract(a, 0, DIGIT - b % DIGIT) << (b % DIGIT), b / DIGIT);
                    add(extract(a, DIGIT - b % DIGIT, DIGIT), b / DIGIT + 1);
                }
                else if (a < 0)
                {
                    a = -a;
                    sub(extract(a, 0, DIGIT - b % DIGIT) << (b % DIGIT), b / DIGIT);
                    sub(extract(a, DIGIT - b % DIGIT, DIGIT), b / DIGIT + 1);
                }
            }
            else
            {
                int k;
                read(k);
                write(check(query(1, 0, N, k / DIGIT), k % DIGIT) ? 1 : 0), putchar('\n');
            }
        }
        return 0;
    }
}
int main()
{
#ifdef BlueSpirit
    freopen("3822.in", "r", stdin);
    freopen("3822.out", "w", stdout);
#endif
    return zyt::work();
}

转载于:https://www.cnblogs.com/zyt1253679098/p/10993308.html

P4770 [NOI2018] 你的名字 洛谷黑题题解详解
yaosichengalpha的博客
01-24 1176
P4770 [NOI2018] 你的名字 题解详解
【算法题解】部分洛谷题解(上)
最新发布
m0_72845244的博客
05-03 1480
在数据结构并查集中，种类并查集属于扩展域并查集一类。食物链（比本题难一些，有三个种类存在）首先讲一下本题的贪心，这个是必须要懂的。我们假设最后Z 市长看到的那个冲突事件的影响力为 x （也就是有一对仇恨值为 x 的罪犯在同一监狱）那么比 x 仇恨值更高的每一对罪犯必须分配到不同的监狱（不然，最终答案就不是 x ，而是这一对罪犯的仇恨值了）；所以本题是存在单调性的，只需要从大到小枚举仇恨值，到那一对与前面出现矛盾了，直接输出即可；
2018.10.30 bzoj4942: [Noi2017]整数（线段树压位）
weixin_30722589的博客
10-30 114
传送门 直接把修改的数拆成logloglog个二进制位一个一个修改是会TLETLETLE的。 因此我们把303030个二进制位压成一位储存在线段树里面。 然后维护区间中最靠左二进制位不为0/1的下标。 手动模拟一波进/退位就行了。 代码： #include<bits/stdc++.h> #define lc (p<<1) #d...
LOJ#2302. 「NOI2017」整数 线段树+压位
EM LGH
07-27 136
裸做的话是 $O(n \log^2 n)$ 的，即将 $a$ 进行二进制拆分，然后暴力更新. 考虑进行压位，即线段树的每一个叶节点维护长度为 $30$ 的状态. 加法操作如果需要进位的话就找到其后面的块中第一个 0 所在位置. 减法操作如果需要借位的话就找第一个 1. 第一个 0 与第一个 1 都可以用线段树维护，即 $f0,f1$ 分别表示前缀 0/1 的...
POJ 2155 二维线段树（压位水过）
drj
12-07 1251
题目就不贴了。0 - 1 矩阵，修改 + 询问。 看 ccl 写了一个二维线段树，好像时间被暴虐了 （1100 ms 吧）。。。于是无聊写了一下。。。 看到 0 - 1 矩阵，马上想到压位。。。然后对于每一位建树状数组。。。相当于分块树状数组了。。。 然后用树状数组做差分前缀和。。。每次都是 O(lgn) 的。。。 相当于我的回答是 O(lgn) 的，而修改是 O(n * lgn * 10
bzoj4942: [Noi2017]整数【线段树+压位】
cdsszjj的博客
04-08 366
解题思路： 比较容易想到线段树维护二进制数的进退位，然后把加的操作也拆成二进制分log次加减，但这样是O(n∗log230n∗log21e9)O(n∗log230n∗log21e9)O(n*log_230n*log_21e9)，显然过不了。 考虑压位，用一个int表示连续30位的01状态，加减也最多会涉及两个int，而且进退位除了这两个，其余只会加减1，也只用记录区间内是否全为230−1230...
【BZOJ4942】整数（NOI2017）-线段树+压位
Maxwei_wzj的OI世界
05-17 322
测试地址：整数 做法：本题需要用到线段树+压位。 首先考虑在某一位加111或减111的情况。在加111时，我们要从当前位开始，找到最低的为000的位，然后把这一位加111，路上经过的所有位都清零。在减111时，我们要从当前位开始，找到最低的为111的位，然后把这一位减111，路上经过的所有位都修改成111。这些操作显然可以在线段树上完成。 但是我们发现，操作的数位的范围可能特别大，达到3×1...
洛谷千题复习计划（一）（Codeforces + AtCoder）
繁凡さん的博客
03-05 6445
整理的算法模板合集： ACM模板 点我看算法全家桶系列！！！ 实际上是一个全新的精炼模板整合计划 每天花一个小时简单复习一下我写过的洛谷的题目！ 虽然还没有到千题，但是快了（等我复习完这些以后我 luogu 刷的题目就够千题了hhh 尽管因为太菜了写的都是水题呜呜呜 红橙黄绿蓝紫黑 [AT2271 黄]：思维，组合计数 若有奇数个人，一定有一个人左右差值为0否则不合法，从中间往两边拓展，一定均存在两个人的差值为 2，4，6，8…偶数没有为0的，往两边拓展一定为2，4，6，8，每个位置有两种选择，
洛谷 - 试炼场（全部题目备份）
繁凡さん的博客
10-06 3465
新手村 任何一个伟大的目标，都有一个微不足道的开始。 洛谷的第一个任务 勇敢的迈出第一步，了解下语言和洛谷。跟着书本和老师走，不会难的。 P1000 P1001 P1421 P1425 顺序与分支 计算机的智能性开始得以体现，因为计算机能够根据不同的条件选择了。 P1422 P1085 P1089 P1909 循环！循环！循环！ 计算机最不怕的就是重复。你让它做10000次同样的事它也不怕啦，但是让他做1亿亿次的话…… P1008 P1035 P1423 P1424 P1980 数组 跟数组有关
洛谷P3939 cdqz多校联训 数颜色
Amuseir的博客
08-11 402
题目描述 小 C 的兔子不是雪白的，而是五彩缤纷的。每只兔子都有一种颜色，不同的兔子可能有 相同的颜色。小 C 把她标号从 1 到 nn 的 nn 只兔子排成长长的一排，来给他们喂胡萝卜吃。 排列完成后，第 ii 只兔子的颜色是 a_iai​。 俗话说得好，“萝卜青菜，各有所爱”。小 C 发现，不同颜色的兔子可能有对胡萝卜的 不同偏好。比如，银色的兔子最喜欢吃金色的胡萝卜，金色的兔子更喜欢吃胡...
P3822 [NOI2017]整数
weixin_34123613的博客
11-30 102
传送门 shadowice大佬已经写的非常详细了我就不再写一遍了…… //minamoto #include<bits/stdc++.h> #define u unsigned int #define fp(i,a,b) for(register int i=a,I=b+1;i<I;++i) #define fd(i,a,b) for(register int i=a,I=b-1...
3813: 奇数国 线段树+线性筛素数+欧拉函数+乘法逆元+压位
ws_fqk
02-15 583
感觉就是几个算法的叠加。。没什么思维的难度。。无脑码代码呗。 首先维护区间乘法线段树就好，然后那个存在ax+by=1的限制条件，根据裴蜀定理其实据说gcd(x,y)=1即x,y互质，那么这个可以用欧拉函数解决。然后根据欧拉函数的通式算的时候需要用到乘法逆元，范围很小这个随便求了。。至于质因子的存在情况因为不超过60个所以开一个longlong压位就好了，依旧线段树维护。= =无脑题好无聊#incl
poj 2777 Count Color(线段树、状态压缩、位运算)
hahahaha
07-27 991
Count Color Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 38921   Accepted: 11696 Description Chosen Problem Solving and Program design as an optional course
线段树专题
LYXin's Blog
09-26 469
线段树的坑终于填完了
【NOI2017】 整数（二进制计数器）
DD(XYX)的硫氰化氘博客
05-28 285
摘要（选填）：rt
NOI 2017 整数
lleozhang的博客
09-06 482
好玄学的线段树啊... 调了半天的题，最后发现是传参的数据类型传错了（long long 传成了int），结果RE3小时... 说下思路吧... 其实主题思想很简单，就是把一个二进制数作为一个序列建立一棵线段树，然后各种维护即可 当然这样会TLE或MLE之类的 所以我们采用其他的策略：压位！！！ 这里我选择压60位。 然后我们考虑：对一次修改操作，我们如何处理？ 首先，我们看一下这...
LibreOJ2302 - 「NOI2017」整数
ayw1069的博客
04-04 310
Portal Description 有一个整数\(x=0\)，对其进行\(n(n\leq10^6)\)次操作： 给出\(a(|a|\leq10^9),b(b\leq30n)\)，将\(x\)加上\(a\cdot 2^b\)。 询问\(x\)在二进制下位权为\(2^k(k\leq30n)\)的位的值。 保证任意时刻\(x\geq0\)。 Solution 用线段树来模拟二进制下的加减...
[NOI2017]整数
Free Cat~~~ 跳动的喵
04-21 417
Description 　　P 博士将他的计算任务抽象为对一个整数的操作。 　　具体来说，有一个整数 xxx ，一开始为000。 　　接下来有 nnn 个操作，每个操作都是以下两种类型中的一种： 　　111 aaa bbb ：将 xxx 加上整数 a⋅2ba⋅2ba⋅2^b ，其中 aaa 为一个整数，bbb 为一个非负整数 　　222 kkk ：询问 xxx 在用二进制表示时，位权为 ...
线段树详解：数据结构与RMQ问题
线段树是一种经典的数据结构，尤其在算法竞赛如ACM和NOI（全国青少年信息学奥林匹克竞赛）中被广泛使用。它的设计目标是为了高效地处理区间上的查询和修改操作，例如在数组中找到一段连续子数组的最小值或求和等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值