思路
容易想到把区间建成满二叉树, 太 \(\rm{trick}\) 了
考虑把翻转操作搞到树上去
最初的想法是显然的, 对于 \(q_i\) 的询问, 显然要把从 \(2 \sim q_i + 1\) 层的左右儿子全部翻转, \(1\) 层是叶子节点
具体的, 可以把对于 \(u\) 的大区间这样处理
- 翻转 \(ls\)
- 翻转 \(rs\)
- 把 \(ls, rs\) 交换
前两个显然是递归下去的, 我们只需要对于每个节点, 维护第三个操作对答案的影响
块内处理
块内相当于原来的贡献是 \(\sum [a_i>a_j,i\in left,j\in right]\)
之后变成了 \(\sum [a_i>a_j,i\in right,j\in left]\)
考虑这个东西可以在归并排序的时候 \(\mathcal{O} (L \log L)\) 计算, 其中 \(L = 2^n\)
颓了一上午继续学, 以后手机放音乐就可以忍住不玩手机
这几天就是正常学就行了, 不要太颓
手机肯定是放外面的, 然后就是该怎么学怎么学, 可以考虑挂个什么音乐之类的就不颓了
具体的, 我们考虑归并排序的实质, 就是对于一个序列先分成这样的一颗满二叉树, 然后合并
在这个过程中, 我们显然是可以顺带求出逆序对个数的
当然如果你没有意识到, 在满二叉树上进行一个权值线段树的合并也是可以的
具体的, 你注意到线段树合并的复杂度大概是小的那一棵树的复杂度, 容易发现最劣 \((\)即每次两棵树大小相当\()\) 都是 \(\log\) 级别的
这个好像是一个 \(\rm{trick}\)
解决完这个问题, 如何处理每次答案呢
显然暴力枚举或者仅和上面一样模拟都是纯神经, 所以考虑一个传统 \(\rm{trick}\) , 即每次操作对答案的影响
首先我们知道这些信息
- 二叉树中每个节点对应的区间的顺逆序对个数
- 每次操作需要对那些层进行翻转
考虑这个问题的子问题, 即每一层进行翻转产生的贡献
不难发现, 我们可以直接计算出每一层的顺逆序对交换之后的贡献, 块内部分轻松解决
块间处理
你使用脑子, 发现交换前后块间逆序对个数不受影响, 那直接不管这个就行了
最终处理
首先归并处理每个节点的顺逆序对个数
然后每次询问查询 \(2 \sim q_i\) 层的节点的顺逆序对之差 \((\)注意这个顺逆序对的定义是会变的\()\)
如果你提前统计每一层的顺逆序对之差, 那么诗人能做
实现
框架
首先归并两次求层内逆序对个数, 标记一下
然后处理的时候一次处理一层即可
代码
#include <bits/stdc++.h>
#define int long long
typedef unsigned long long ull;const int MAXN = 2e6 + 20;
const int MAXLOGN = 25;namespace Fast_IO {char buf[1 << 20], *p1, *p2;#define getchar() (p1 == p2 and (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? 0 : *p1++)void read() {}template <class T, class ...T1>void read(T &x, T1 &...y) {x = 0;char ch = getchar(); bool f = 1;for (; ch < '0' or ch > '9'; ch = getchar()) if (ch == '-') f = 0;for (; ch >= '0' and ch <= '9'; x = x * 10 + (ch & 15), ch = getchar());x = (f ? x : -x);read(y...);}void print(int x) {if (x < 0) putchar('-'), x = -x;if (x > 9) print(x / 10);putchar(x % 10 + '0');}void print(int x, char c) { print(x), putchar(c); }
} using namespace Fast_IO;int n, m;
int inver[2][MAXLOGN];
int val[MAXN], bin[MAXN], q[MAXN];ull k1, k2, threshold;
ull xorShift128Plus() {ull k3 = k1, k4 = k2;k1 = k4;k3 ^= (k3 << 23);k2 = k3 ^ k4 ^ (k3 >> 17) ^ (k4 >> 26);return k2 + k4;
}
void gen(int n, int m, int threshold, ull _k1, ull _k2) {k1 = _k1, k2 =_k2;for (int i = 1; i <= (1 << n); i++) bin[i] = val[i] = xorShift128Plus() % threshold + 1;for (int i = 1; i <= m; i++) q[i] = xorShift128Plus() % (n + 1);
}/*归并排序计算每个节点的逆序对个数*/
class mergesort
{
private:public:/*合并*/int merge(const int *a, size_t asize, const int *b, size_t bsize, int *c) {size_t i = 1, j = 1, k = 1;int res = 0; // 逆序对个数while (i <= asize && j <= bsize) if (b[j] < a[i]) res += asize - i + 1, c[k++] = b[j++]; else c[k++] = a[i++];for (; i <= asize; i++) c[k++] = a[i];for (; j <= bsize; j++) c[k++] = b[j];return res;}int tmp[MAXN];/*倍增法处理逆序对数量*/void solve(int *val, size_t n, int type) {memset(tmp, 0, sizeof tmp);for (size_t seg = 1, res = 2; seg < n; seg <<= 1, res++) for (size_t left1 = 0; left1 < n - seg; left1 += seg + seg) {size_t right1 = left1 + seg, left2 = right1, right2 = std::min(left2 + seg, n);inver[type][res] += merge(val + left1, right1 - left1, val + left2, right2 - left2, tmp + left1);for (size_t i = left1 + 1; i <= right2; i++) val[i] = tmp[i];}}
} ms;signed main()
{read(n, m, threshold, k1, k2);gen(n, m, threshold, k1, k2);int logn = n;n = (1 << n);ms.solve(bin, n, 0);int sum = inver[0][logn];std::reverse(val + 1, val + n + 1); for (int i = 1; i <= n; i++) bin[i] = val[i];ms.solve(bin, n, 1);int tot = 0;for (int i = 1; i <= m; i++) {for (int j = 2; j <= q[i] + 1; j++) std::swap(inver[0][j], inver[1][j]);int ans = 0; for (int j = 1; j <= logn; j++) ans += inver[0][j + 1];tot ^= (ans * i);}print(tot);return 0;
}
总结
常用的树上 \(\rm{trick}\)
然后就是善于把这类问题转化成对答案的 \(\Delta\) 的处理, 会方便很多
对归并的理解是一坨, 赛时根本想不到
常用的优化办法: 把一定一起操作的绑定到一起
