【YBT2023寒假Day4 C】樱桃莓莓（交互）（四毛子分块）（线段树）

樱桃莓莓

题目链接：YBT2023寒假Day4 C

题目大意

有一个黑盒操作满足交换律和结合律，有 n 个数，q 次询问，每次选 m 个下标，你要计算所有不包含那 m 个下标的数进行黑盒操作之后的结果。
预处理不超过 4n 次，每次询问不超过 4(m+1) 次。（这里的一次是指使用一次黑盒操作）

思路

第一步想到的应该是前缀后缀，但是中间的要怎么办呢。
考虑分块（有点四毛子的感觉），求出每一块的前缀后缀。
但是发现怎么都还是会超 $4n$，那这个时候考虑不要了整个的前缀后缀，思考超 $4n$ 的原因。

就是一个块 $[x,y]$ 内如果 $[x+1,y-1]$ 问这个就寄了。
（块长小的话要拼的也太多了）
那考虑每个块中间你在弄一个点，从这个点往前和往后在处理一遍。
（那现在是 $3n$）

先看看够不够，发现当 $B=8$ 的时候，如果小块的询问没有跨越中间的部分，那它长度至多是 $4$，我们就可以暴力一个一个点并起来查询。
那小块就可以了，接着搞大块，考虑怎么办。

试着能不能用线段树的结构，会发现好像如果要这样的话，你合并的时候时间又超了。
考虑分摊一下，分摊到预处理那里，于是考虑线段树每个位置你都处理一个前缀后缀。
然后到询问第一次裂成两半的时候，你就可以直接分别用那两半的后缀和前缀直接拼出来。

于是数一数行不行。
如果整个询问是小块，至多是 $4$ 可以。
如果询问分成两个小块和大段，每个小块由于分出来的一定是前缀或者后缀，大段我们用线段树的的方法至多 $2$ 次，也是 $4$。
然后看初始化，前面的是 $3n$，考虑给线段树那个部分是多少。
注意线段树是把段分线段树的，所以总的是 $2n/8\log n/8$，会发现超了。

不过其实这个 $2$ 可以去掉，因为一个线段树上的点要么是只用前缀，要么是只用后缀（根据它下标的奇偶，$1$ 就不会有）
所以就是 $n/8\log n/8$，大概是 $1901$ 左右当 $n=2000$，就 $<n$，所以是可以的。

代码

#include <algorithm>
#include <vector>
#include <cstdio>
#include <set>
#include "blackbox.h"
#define ull unsigned long long

using namespace std;

const int N = 10000;
int n, m, B = 8, blo[N], bl[N], br[N];
ull pre[N], suf[N], Mid[N], b[N];

struct XD_tree {
	ull f[N][N];
	
	void build(int now, int l, int r) {
	    if (now != 1) {
	        if (now & 1) {
	            f[now][l] = pre[br[l]];
	            for (int j = l + 1; j <= r; j++) f[now][j] = magic(f[now][j - 1], pre[br[j]]);
	        } else {
	            f[now][r] = pre[br[r]];
	            for (int j = r - 1; j >= l; j--) f[now][j] = magic(f[now][j + 1], pre[br[j]]);
	        }
	    }
	    if (l == r) return;
	    int mid = (l + r) >> 1;
	    build(now << 1, l, mid);
	    build(now << 1 | 1, mid + 1, r);
	}
	
	ull query(int now, int l, int r, int L, int R) {
	    if (L <= l && r <= R) {
	        if (now & 1) return f[now][r];
	        	else return f[now][l];
	    }
	    int mid = (l + r) >> 1;
	    if (L <= mid && mid < R) return magic(f[now << 1][L], f[now << 1 | 1][R]);
	    if (L <= mid) return query(now << 1, l, mid, L, R);
	    if (mid < R) return query(now << 1 | 1, mid + 1, r, L, R);
	}
}T;

void init(vector <ull> a, int M) {
    n = a.size(); m = M;
    for (int i = 1; i <= n; i++) b[i] = a[i - 1], blo[i] = (i - 1) / B + 1;
    for (int i = 1; i <= blo[n]; i++) {
    	bl[i] = (i - 1) * B + 1; br[i] = min(n, i * B); int l = bl[i], r = br[i];
        pre[l] = b[l]; for (int j = l + 1; j <= r; j++) pre[j] = magic(pre[j - 1], b[j]);
        suf[r] = b[r]; for (int j = r - 1; j >= l; j--) suf[j] = magic(suf[j + 1], b[j]);
        int mid = min(n, l + 3);
        Mid[mid] = b[mid]; for (int j = mid - 1; j >= l; j--) Mid[j] = magic(Mid[j + 1], b[j]);
        if (mid != r) {
            Mid[mid + 1] = b[mid + 1]; for (int j = mid + 2; j <= r; j++) Mid[j] = magic(Mid[j - 1], b[j]);
        }
    }
	T.build(1, 1, blo[n]);
}

ull slove(int l, int r) {
    if (blo[l] == blo[r]) {
        int mid = blo[l] + 3;
        if (r - l + 1 > 4) return magic(Mid[l], Mid[r]);
        ull re = b[l];
        for (int i = l + 1; i <= r; i++) re = magic(re, b[i]);
        return re;
    }
    ull re = magic(suf[l], pre[r]);
    if (blo[l] != blo[r] - 1) re = magic(re, T.query(1, 1, blo[n], blo[l] + 1, blo[r] - 1));
    return re;
}

ull query(vector <int> u) {
    sort(u.begin(), u.end());
    ull ans = 0;
    int las = 0, nof = 0;
    for (int i = 0; i < m; i++) {
        int l = las + 1, r = u[i];
        if (l <= r) {
            if (!nof) nof = 1, ans = slove(l, r);
            	else ans = magic(ans, slove(l, r));
        }
        las = u[i] + 1;
    }
    if (las != n) {
        if (!nof) ans = slove(las + 1, n);
        	else ans = magic(ans, slove(las + 1, n));
    }
    return ans;
}