P10009 [集训队互测 2022] 线段树题解

合集 - 题解散记1(65)

1.P9933 [NFLSPC #6] 9.pop_book(); 题解2024-01-01 2.U390630 分考场题解2024-01-01 3.P9989 [Ynoi Easy Round 2023] TEST_69 题解2024-01-02 4.P9993 [Ynoi Easy Round 2024] TEST_133 题解2024-01-02

5.P10009 [集训队互测 2022] 线段树题解2024-01-02

6.P9474 [yLOI2022] 长安幻世绘题解2024-01-02 7.P8078 [WC2022] 秃子酋长题解2024-01-03 8.P4402 [Cerc2007] robotic sort 机械排序题解2024-01-04 9.P9247 [集训队互测 2018] 完美的队列题解2024-01-04 10.CF1270G Subset with Zero Sum2024-01-05 11.P8575 「DTOI-2」星之河题解2024-01-05 12.P7907 [Ynoi2005] rmscne题解2024-01-07 13.P4149 [IOI2011] Race 题解2024-01-08 14.P5309 [Ynoi2011] 初始化题解2024-01-09 15.P3730 曼哈顿交易题解2024-01-10 16.P4093 [HEOI2016/TJOI2016] 序列题解2024-01-10 17.P9549 「PHOI-1」路虽远题解2024-01-11 18.P4103 [HEOI2014] 大工程题解2024-01-11 19.P5501 [LnOI2019] 来者不拒，去者不追题解2024-01-14 20.P9816 少项式复合幂题解2024-01-14 21.P5047 [Ynoi2019 模拟赛] Yuno loves sqrt technology II 题解2024-01-15 22.P2572 [SCOI2010] 序列操作题解2024-01-16 23.P2216 [HAOI2007] 理想的正方形题解2024-01-17 24.P7167 [eJOI2020 Day1] Fountain 题解2024-01-17 25.P4396 [AHOI2013] 作业题解2024-01-18 26.P3509 [POI2010] ZAB-Frog 题解2024-01-18 27.2022年“腾讯杯”大学生程序设计竞赛死去的 Elo 突然开始攻击我题解2024-01-18 28.P8512 [Ynoi Easy Round 2021] TEST_152 题解2024-01-19 29.P4747 [CERC2017] Intrinsic Interval 题解2024-01-20 30.CF452F Permutation 与 P2757 [国家集训队] 等差子序列题解2024-01-23 31.P8659 [蓝桥杯 2017 国 A] 数组操作题解2024-01-25 32.P10114 [LMXOI Round 1] Size 题解2024-01-29 33.P6824 「EZEC-4」可乐题解2024-01-29 34.P10120 『STA - R4』冰红茶题解2024-02-01 35.P3604 美好的每一天题解2024-02-04 36.U405333 帕鲁大陆迷路的一天题解2024-02-06 37.P5398 [Ynoi2018] GOSICK 题解2024-02-07 38.P5524 [Ynoi2012] NOIP2015 充满了希望题解2024-02-11 39.P4559 [JSOI2018] 列队题解2024-02-12 40.P5350 序列与 P5586 序列 (加强版) 题解2024-02-13 41.P4113 [HEOI2012] 采花题解2024-02-14 42.P3527 [POI2011] MET-Meteors 题解2024-02-16 43.P3157 [CQOI2011] 动态逆序对题解2024-02-16 44.P2042 [NOI2005] 维护数列题解2024-02-17 45.P5344 【XR-1】逛森林题解2024-02-21 46.P6466 分散层叠算法(Fractional Cascading) 题解2024-02-22 47.P4983 忘情题解2024-02-23 48.P1975 [国家集训队] 排队题解2024-02-25 49.P2487 [SDOI2011] 拦截导弹题解2024-02-28 50.P4690 [Ynoi2016] 镜中的昆虫题解2024-03-01 51.P3722 [AH2017/HNOI2017] 影魔题解2024-03-06 52.P3960 [NOIP2017 提高组] 列队题解2024-03-13 53.P2824 [HEOI2016/TJOI2016] 排序与 ABC297_g Range Sort Query 题解2024-03-15 54.P2633 Count on a tree 题解2024-03-17 55.P3302 [SDOI2013] 森林题解2024-03-17 56.P2163 [SHOI2007] 园丁的烦恼题解2024-03-17 57.P2746 [USACO5.3] 校园网Network of Schools 题解2024-03-17 58.P3939 数颜色题解2024-03-17 59.P3863 序列题解2024-03-18 60.P4867 Gty的妹子序列题解2024-03-22 61.P10268 符卡对决题解2024-03-23 62.P4551 最长异或路径题解2024-04-06 63.P4587 [FJOI2016] 神秘数题解2024-04-17 64.P6018 [Ynoi2010] Fusion tree 题解2024-04-19 65.P10604 BZOJ4317 Atm 的树题解2024-07-04

官解链接

前面还看得懂。后面是啥?这不是 ds 题咋和 dp、轮廓线扯上关系了。看了半天，还是这个启发了我：

其手玩下，在 Excel 里写一下，可以理解到这里其实是想表达的一个核心意思是啥：对于一组序列而言，我们对操作 $1$ 进行 $2^{k}$ 次，很容易发现一个性质此时最终的数组和原数组有以下关系：

l a s t_{i} = a_{i} (i < 2^{k}), l a s t_{i} = a_{i} \oplus a_{i - 2^{k}} (i >= 2^{k})

证明可以参照 pdf 里面说的，转化为网格图，然后转变为路径数问题，考虑一个点是否计入最终点的贡献。因为异或两次就为 $0$ ，所以只需要计算从这个点出发到查询点的路径数的数量再模 $2$ ，而路径数：

这点还是很好理解的。而 $d i f f_{y}$ 就是操作数， $d i f f_{x}$ 则是步长。假如操作数为 $2^{k}$ 。温习下 Lucas 定理：

很显然的是由卢卡斯定理我们有：

(\binom{d i f f_{y}}{d i f f_{x}}) \mod 2 = (\binom{2^{k - 1}}{⌊ \frac{d i f f_{x}}{2} ⌋}) \times (\binom{0}{d i f f_{x} mod 2}) \mod 2

= (\binom{1}{⌊ \frac{d i f f_{x}}{2^{k}} ⌋}) \times \prod_{i = 0}^{k - 1} (\binom{0}{⌊ \frac{d i f f_{x}}{2^{i}} ⌋ \mod 2}) \mod 2

= \prod_{i = 0}^{k - 1} (\binom{0}{⌊ \frac{d i f f_{x}}{2^{i}} ⌋ \mod 2}) \mod 2

显然需要有每个 $⌊ \frac{d i f f_{x}}{2^{i}} ⌋ \mod 2 == 0$ 才能使结果为 $1$ 。容易知道 $d i f f_{x} = 2^{t} (t > k - 1)$ 。

接下来只需要证明 $d i f f_{x} = 2^{t} (t > k)$ 都是无贡献的。换句话来说，对于 $a_{i}$ 来说，操作了 $2^{k}$ 次方次以后， $a_{j} (j \in [1, i - 2^{k}))$ 对 $a_{i}$ 无贡献。非常简单，考虑 $a_{1}$ ，第一次操作会影响 $a_{2}$ ，第二次影响 $a_{3}$ ，以此类推每次影响的对象往右平移一位。其实每次操作可以看做整体往右平移一位再异或。

最初始的 $a_{1}$ 会随着每轮操作而影响对象向右移动一位。所以此时此刻的最大的 $a_{j}$ 在进行了 $2^{k}$ 操作以后，最多只会 $a_{j} 影响 a_{i - 1} (j == 2^{k} - 1)$ 。所以上式当且仅当 $d i f f_{x} == 2^{k}$ 时才为 $1$ ，才有贡献。

非 $2^{k}$ 次操作该如何解决。答案是倍增/二进制分解，把它分解为若干个 $2^{t}$ 次操作累计就行了。这样一来我们就解决了“整块操作”。散块暴力即可。结束。

算法框架及其细节

首先，需要注意一点，既然都上分块了，那么显而易见的 $n e w_{i} = a_{i} \oplus a_{i - s t e p}$ 里的 $s t e p$ 最多为 $\sqrt{n}$ 会跨个一整块。实际上是我们可以考虑每次两块两块地处理，这样写较为方便。而什么时候有可能达到这个数字，显然是当修改达到至少 $\sqrt{n}$ 次时才有可能，所以我们可以考虑每出现 $\sqrt{n}$ 次修改再处理查询。

其次，对于查询而言，我们可以遍历每个查询和每个块，记录整块操作数，遇到散块就直接处理完整块的就行了。这一部分外层遍历的复杂度为 $O (\sqrt{n} 个查询 \times \sqrt{n} 块) = O (n)$ ，再套一个处理完整块的操作次数显然最坏应该为：

(\sqrt{n} - 2^{0}) + (\sqrt{n} - 2^{1}) + . . . . + (\sqrt{n} - 2^{\log \sqrt{n}}) = \sqrt{n} \log \sqrt{n} - (2^{\log \sqrt{n} + 1} - 1)

= \sqrt{n} \log \sqrt{n} - (2 \sqrt{n} - 1) = (l o g \sqrt{n} - 2) \sqrt{n} + 1

所以单次查询的最坏复杂度 $O (\sqrt{n} \log \sqrt{n})$

而又因为这 $\sqrt{n}$ 个查询，全是最坏的散块处理，整块处理我们可以累计到下次 $o p == 2$ 时进行统一处理。实际上摊还分析一下，一次处理 $\sqrt{n}$ 个查询的复杂度单个是 $\sqrt{n} \log \sqrt{n}$ ，总复杂度是就是 $O (n \log \sqrt{n})$

又因为最多有 $⌈ \frac{q}{\sqrt{n}} ⌉$ 个这种查询，所以理想复杂度是近似于 $O (n \sqrt{n} \log \sqrt{n})$ ? $n$ 和 $q$ 差不多是一个数量级，把它俩当相等。

参考代码

 #include <bits/stdc++.h>
 
//#pragma GCC optimize("Ofast,unroll-loops")
 
#define isPbdsFile
 
#ifdef isPbdsFile
 
#include <bits/extc++.h>
 
#else
 
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
 
#endif
 
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
 
template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}
 
template <typename T>
T lowBit(T x)
{
    return x & -x;
}
 
template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}
 
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}
 
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c)if (b & 1)(ans *= a) %= c;
    return modt(ans, c);
}
 
template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}
 
template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}
 
template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char))return;
    if (x < 0)x = -x, putchar('-');
    if (x > 9)write(x / 10);
    putchar(x % 10 ^ 48);
}
 
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}
 
 
template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;
 
    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow)return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }
 
    T3() { one = tow = three = 0; }
 
    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};
 
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y)x = y;
}
 
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y)x = y;
}
 
constexpr int N = 2.5e5 + 10;
constexpr int SIZE = sqrt(N);
constexpr int CNT = (N + SIZE - 1) / SIZE + 1;
int pos[N];
int s[CNT], e[CNT];
int pre[N]; //上一轮序列
int nxt[N]; //下一轮序列
int tmp[N]; //临时序列
int ans[N]; //答案
int n, q;
int siz, cnt; //块大小,块数量
struct Query
{
    int op, l, r, id;
} qu[N];
 
//整块更新,2^i次方就直接tmp[x]^=tmp[x-2^i],否则二进制拆分倍增
inline void allUpdate(const int id, int updateCnt)
{
    while (updateCnt)
    {
        int t = log2(updateCnt);
        int step = 1 << t; //步长
        //两块两块处理,因为updateCnt最多为sqrt(n)
        forv(i, e[id], s[id-1]+step)tmp[i] ^= tmp[i - step];
        updateCnt -= step;
    }
}
 
//处理操作
inline void update(const int queryCnt)
{
    //遍历每个块进行贡献更新
    forn(idx, 1, cnt)
    {
        int blockCnt = 0; //整块操作次数
        //两块两块进行处理,对于当前块,同时拿到它之前的块进行一并处理方便a[i]^=a[i-step],step=sqrt(n)。
        forn(i, s[idx-1], e[idx])tmp[i] = pre[i];
        forn(curr, 1, queryCnt)
        {
            if (auto [op,l,r,id] = qu[curr]; op == 1)
            {
                const int L1 = s[idx - 1]; //前一块边界
                const int R2 = e[idx]; //当前块边界
                //完全包括
                if (l <= L1 and R2 <= r)
                {
                    ++blockCnt;
                    continue;
                }
                //部分包括,有交集,暴力
                if (l <= R2 and r >= L1)
                {
                    //先把之前的整块更新改了
                    allUpdate(idx, blockCnt);
                    blockCnt = 0;
                    //起点需要+1
                    forv(i, min(r,R2), max(l+1,L1+1))tmp[i] ^= tmp[i - 1];
                }
            }
            else
            {
                //计算当前块的贡献
                if (s[idx] <= l and l <= e[idx])
                {
                    allUpdate(idx, blockCnt);
                    blockCnt = 0;
                    ans[id] = tmp[l];
                }
            }
        }
        allUpdate(idx, blockCnt); //处理还未处理的整块更新
        forn(i, s[idx], e[idx])nxt[i] = tmp[i]; //下一轮的序列
    }
    forn(i, 1, n)pre[i] = nxt[i];
    forn(i, 1, queryCnt)if (qu[i].op == 2)cout << ans[qu[i].id] << endl;
}
 
inline void solve()
{
    cin >> n >> q;
    siz = sqrt(n);
    cnt = (n + siz - 1) / siz;
    forn(i, 1, n)cin >> pre[i], pos[i] = (i - 1) / siz + 1;
    s[0] = 1;
    forn(i, 1, cnt)s[i] = (i - 1) * siz + 1, e[i] = i * siz;
    e[cnt] = n;
    int updateCnt = 0; //修改次数
    int queryCnt = 0; //待处理的操作次数
    forn(i, 1, q)
    {
        cin >> qu[++queryCnt].op;
        qu[queryCnt].id = i;
        if (qu[queryCnt].op == 1)
        {
            cin >> qu[queryCnt].l >> qu[queryCnt].r;
            if (++updateCnt == siz)update(queryCnt), updateCnt = 0, queryCnt = 0;
        }
        else cin >> qu[queryCnt].l;
    }
    update(queryCnt);
    forn(i, 1, n)cout << pre[i] << endl;
}
 
signed int main()
{
    Spider
    //------------------------------------------------------
    int test = 1;
    //    read(test);
    cin >> test;
    test = 1;
    forn(i, 1, test)solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
}

附一张手玩时，打表确认规律

PS：复杂度部分可能最终分析的有点乱，但实测下来确实跑得非快。官解剩余的神仙dp确实晦涩，后续如果看懂也会补充做法。文章证明如果有瑕疵或者不正确的地方，欢迎指出。

posted @ 2024-01-02 17:44 Athanasy 阅读(149) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· P10120 『STA - R4』冰红茶题解

· P2572 [SCOI2010] 序列操作题解

· 分块-byx

· 【做题记录】2025刷题计划--线段树

· 2023.1.28~2023.1.30 日寄

公告

昵称： Athanasy
园龄： 1年5个月
粉丝： 34
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

Athanasy

P10009 [集训队互测 2022] 线段树题解

题目链接：P10009 [集训队互测 2022] 线段树

神仙分块题，先给一下出题人的神仙官解：

官解链接

前面还看得懂。后面是啥?这不是 ds 题咋和 dp、轮廓线扯上关系了。看了半天，还是这个启发了我：

非 $2^{k}$ 次操作该如何解决。答案是倍增/二进制分解，把它分解为若干个 $2^{t}$ 次操作累计就行了。这样一来我们就解决了“整块操作”。散块暴力即可。结束。

算法框架及其细节

附一张手玩时，打表确认规律

PS：复杂度部分可能最终分析的有点乱，但实测下来确实跑得非快。官解剩余的神仙dp确实晦涩，后续如果看懂也会补充做法。文章证明如果有瑕疵或者不正确的地方，欢迎指出。

公告

搜索

常用链接

合集

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	#include <bits/stdc++.h>

	//#pragma GCC optimize("Ofast,unroll-loops")

	#define isPbdsFile

	#ifdef isPbdsFile

	#include <bits/extc++.h>

	#else

	#include <ext/pb_ds/priority_queue.hpp>
	#include <ext/pb_ds/hash_policy.hpp>
	#include <ext/pb_ds/tree_policy.hpp>
	#include <ext/pb_ds/trie_policy.hpp>
	#include <ext/pb_ds/tag_and_trait.hpp>
	#include <ext/pb_ds/hash_policy.hpp>
	#include <ext/pb_ds/list_update_policy.hpp>
	#include <ext/pb_ds/assoc_container.hpp>
	#include <ext/pb_ds/exception.hpp>
	#include <ext/rope>

	#endif

	using namespace std;
	using namespace __gnu_cxx;
	using namespace __gnu_pbds;
	typedef long long ll;
	typedef long double ld;
	typedef pair<int, int> pii;
	typedef pair<ll, ll> pll;
	typedef tuple<int, int, int> tii;
	typedef tuple<ll, ll, ll> tll;
	typedef unsigned int ui;
	typedef unsigned long long ull;
	typedef __int128 i128;
	#define hash1 unordered_map
	#define hash2 gp_hash_table
	#define hash3 cc_hash_table
	#define stdHeap std::priority_queue
	#define pbdsHeap __gnu_pbds::priority_queue
	#define sortArr(a, n) sort(a+1,a+n+1)
	#define all(v) v.begin(),v.end()
	#define yes cout<<"YES"
	#define no cout<<"NO"
	#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
	#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
	#define forn(i, a, b) for(int i = a; i <= b; i++)
	#define forv(i, a, b) for(int i=a;i>=b;i--)
	#define ls(x) (x<<1)
	#define rs(x) (x<<1\|1)
	#define endl '\n'
	//用于Miller-Rabin
	[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

	template <typename T>
	int disc(T* a, int n)
	{
	return unique(a + 1, a + n + 1) - (a + 1);
	}

	template <typename T>
	T lowBit(T x)
	{
	return x & -x;
	}

	template <typename T>
	T Rand(T l, T r)
	{
	static mt19937 Rand(time(nullptr));
	uniform_int_distribution<T> dis(l, r);
	return dis(Rand);
	}

	template <typename T1, typename T2>
	T1 modt(T1 a, T2 b)
	{
	return (a % b + b) % b;
	}

	template <typename T1, typename T2, typename T3>
	T1 qPow(T1 a, T2 b, T3 c)
	{
	a %= c;
	T1 ans = 1;
	for (; b; b >>= 1, (a = a) %= c)if (b & 1)(ans = a) %= c;
	return modt(ans, c);
	}

	template <typename T>
	void read(T& x)
	{
	x = 0;
	T sign = 1;
	char ch = getchar();
	while (!isdigit(ch))
	{
	if (ch == '-')sign = -1;
	ch = getchar();
	}
	while (isdigit(ch))
	{
	x = (x << 3) + (x << 1) + (ch ^ 48);
	ch = getchar();
	}
	x *= sign;
	}

	template <typename T, typename... U>
	void read(T& x, U&... y)
	{
	read(x);
	read(y...);
	}

	template <typename T>
	void write(T x)
	{
	if (typeid(x) == typeid(char))return;
	if (x < 0)x = -x, putchar('-');
	if (x > 9)write(x / 10);
	putchar(x % 10 ^ 48);
	}

	template <typename C, typename T, typename... U>
	void write(C c, T x, U... y)
	{
	write(x), putchar(c);
	write(c, y...);
	}


	template <typename T11, typename T22, typename T33>
	struct T3
	{
	T11 one;
	T22 tow;
	T33 three;

	bool operator<(const T3 other) const
	{
	if (one == other.one)
	{
	if (tow == other.tow)return three < other.three;
	return tow < other.tow;
	}
	return one < other.one;
	}

	T3() { one = tow = three = 0; }

	T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
	{
	}
	};

	template <typename T1, typename T2>
	void uMax(T1& x, T2 y)
	{
	if (x < y)x = y;
	}

	template <typename T1, typename T2>
	void uMin(T1& x, T2 y)
	{
	if (x > y)x = y;
	}

	constexpr int N = 2.5e5 + 10;
	constexpr int SIZE = sqrt(N);
	constexpr int CNT = (N + SIZE - 1) / SIZE + 1;
	int pos[N];
	int s[CNT], e[CNT];
	int pre[N]; //上一轮序列
	int nxt[N]; //下一轮序列
	int tmp[N]; //临时序列
	int ans[N]; //答案
	int n, q;
	int siz, cnt; //块大小,块数量
	struct Query
	{
	int op, l, r, id;
	} qu[N];

	//整块更新,2^i次方就直接tmp[x]^=tmp[x-2^i],否则二进制拆分倍增
	inline void allUpdate(const int id, int updateCnt)
	{
	while (updateCnt)
	{
	int t = log2(updateCnt);
	int step = 1 << t; //步长
	//两块两块处理,因为updateCnt最多为sqrt(n)
	forv(i, e[id], s[id-1]+step)tmp[i] ^= tmp[i - step];
	updateCnt -= step;
	}
	}

	//处理操作
	inline void update(const int queryCnt)
	{
	//遍历每个块进行贡献更新
	forn(idx, 1, cnt)
	{
	int blockCnt = 0; //整块操作次数
	//两块两块进行处理,对于当前块,同时拿到它之前的块进行一并处理方便a[i]^=a[i-step],step=sqrt(n)。
	forn(i, s[idx-1], e[idx])tmp[i] = pre[i];
	forn(curr, 1, queryCnt)
	{
	if (auto [op,l,r,id] = qu[curr]; op == 1)
	{
	const int L1 = s[idx - 1]; //前一块边界
	const int R2 = e[idx]; //当前块边界
	//完全包括
	if (l <= L1 and R2 <= r)
	{
	++blockCnt;
	continue;
	}
	//部分包括,有交集,暴力
	if (l <= R2 and r >= L1)
	{
	//先把之前的整块更新改了
	allUpdate(idx, blockCnt);
	blockCnt = 0;
	//起点需要+1
	forv(i, min(r,R2), max(l+1,L1+1))tmp[i] ^= tmp[i - 1];
	}
	}
	else
	{
	//计算当前块的贡献
	if (s[idx] <= l and l <= e[idx])
	{
	allUpdate(idx, blockCnt);
	blockCnt = 0;
	ans[id] = tmp[l];
	}
	}
	}
	allUpdate(idx, blockCnt); //处理还未处理的整块更新
	forn(i, s[idx], e[idx])nxt[i] = tmp[i]; //下一轮的序列
	}
	forn(i, 1, n)pre[i] = nxt[i];
	forn(i, 1, queryCnt)if (qu[i].op == 2)cout << ans[qu[i].id] << endl;
	}

	inline void solve()
	{
	cin >> n >> q;
	siz = sqrt(n);
	cnt = (n + siz - 1) / siz;
	forn(i, 1, n)cin >> pre[i], pos[i] = (i - 1) / siz + 1;
	s[0] = 1;
	forn(i, 1, cnt)s[i] = (i - 1) * siz + 1, e[i] = i * siz;
	e[cnt] = n;
	int updateCnt = 0; //修改次数
	int queryCnt = 0; //待处理的操作次数
	forn(i, 1, q)
	{
	cin >> qu[++queryCnt].op;
	qu[queryCnt].id = i;
	if (qu[queryCnt].op == 1)
	{
	cin >> qu[queryCnt].l >> qu[queryCnt].r;
	if (++updateCnt == siz)update(queryCnt), updateCnt = 0, queryCnt = 0;
	}
	else cin >> qu[queryCnt].l;
	}
	update(queryCnt);
	forn(i, 1, n)cout << pre[i] << endl;
	}

	signed int main()
	{
	Spider
	//------------------------------------------------------
	int test = 1;
	// read(test);
	cin >> test;
	test = 1;
	forn(i, 1, test)solve();
	// while (cin >> n, n)solve();
	// while (cin >> test)solve();
	}

题目链接：P10009 [集训队互测 2022] 线段树

神仙分块题，先给一下出题人的神仙官解：

前面还看得懂。后面是啥?这不是 ds 题咋和 dp、轮廓线扯上关系了。看了半天，还是这个启发了我：

非 2k 次操作该如何解决。答案是倍增/二进制分解，把它分解为若干个 2t 次操作累计就行了。这样一来我们就解决了“整块操作”。散块暴力即可。结束。

算法框架及其细节

附一张手玩时，打表确认规律

PS：复杂度部分可能最终分析的有点乱，但实测下来确实跑得非快。官解剩余的神仙dp确实晦涩，后续如果看懂也会补充做法。文章证明如果有瑕疵或者不正确的地方，欢迎指出。

公告

搜索

常用链接

合集

随笔档案

非 $2^{k}$ 次操作该如何解决。答案是倍增/二进制分解，把它分解为若干个 $2^{t}$ 次操作累计就行了。这样一来我们就解决了“整块操作”。散块暴力即可。结束。