二次离线莫队

二次离线莫队，顾名思义，就是做了两次莫队。第一次莫队是对题目给的询问进行离线（其实就跟普通的莫队是一样的），第二次莫队是对莫队的询问进行离线，也就是本来普通莫队是$O(1)$修改的，但是现在不好$O(1)$修改了，于是尝试对这些修改也进行离散并统一处理

假设我们现在的莫队区间是$[L,R]$，以现在$R$加一为例进行分析（即当前询问$Q_1$的$r$小于下一个询问$Q_2$的$r$）

莫队区间由$[L,R]$变成了$[L,R+1]$，多出来的数为$a_{R+1}$，现在我们需要更新$[L,R]$中有多少数与$a_{R+1}$异或得到的结果有$k$个$1$；尝试将其转化为前缀和相减的形式，$[L,R]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目等于$[1,R]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目减去$[1,L-1]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目；发现第一类询问（$[1,R]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目）非常特殊，于是设$f[i]$表示$1$ ~ $i$中与$a_{i+1}$异或的结果有$k$个$1$的数的数目，设辅助数组$g[x]$表示当前统计到的$1$ ~ $i$中有多少个数与$x$异或起来的结果有$k$个$1$，于是$f[i]=g[a[i+1]]$，对于$g$数组的更新，预处理出有$k$个$1$的所有数（最多有$(\genfrac{}{}{0ex}{}{14}{7})\approx 3500$个，这里时间复杂度为$O(3500n)$，但是没办法）更新$g$即可；对于后者（$[1,L-1]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目）没办法很好的统计，于是将这个询问离线，设动态数组$range[i]$表示离线给$[1,i]$这个前缀的询问，当前这个询问变成三元组$(id,R+1,t=-1)$（其中$id$表示$Q_1$，$t$表示系数，后面会知道系数是啥），然后将这个询问放入$range[L-1]$中即可；最后统一处理的时候，仍然利用$g$数组即可

再以$L$加一为例进行分析（即当前询问$Q_1$的$l$小于下一个询问$Q_2$的$l$）

此时要计算的就是$a_L$与$[L+1,R]$中的数异或出来有多少个数的结果有$k$个$1$，转化成前缀和即$[1,R]$中与$a_L$异或得到的结果有$k$个$1$的数的数目减去$[1,L]$中与$a_L$异或得到的结果有$k$个$1$的数的数目；对于后者，为$f[L-1]+(k==0)$（因为自己异或自己为$0$，所以要加上$(k==0)$）；对于前者，变成三元组$(id,L,t=-1)$放入$range[R]$即可

注意到最后统计到的每个询问的结果是下一个询问与当前这个询问的答案的差值，所以最后要做一个前缀和得到答案；系数的作用：比如当$R$加一的时候，下一个询问的答案减去当前询问的答案等于$[1,R]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目减去$[1,L-1]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目，所以下一个询问的答案等于当前询问的答案加上$[1,R]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目减去$[1,L-1]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目，发现$[1,L-1]$中与$a_{R+1}$异或得到的结果有$k$个$1$的数的数目的系数为$-1$，所以$t=-1$

最后讲一下实现：为了方便，我们将上文的三元组全部变成四元组，比如当$R$加一的时候，我们如果按照上文，最后放入$range[L-1]$的所有三元组为$(id,R+1,-1),(id,R+2,-1),...,(id,r,-1)$（其中$r$是$Q_2$的$r$），所以我们不妨直接放入一个四元组$(id,R+1,r,-1)$

code：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>

using namespace std;

typedef long long LL;
const int N = 100010;

int n, m, k, len;
int w[N];
LL ans[N];
struct Query
{
    int id, l, r;
    LL res;
}q[N];
struct Range
{
    int id, l, r, t;
};
vector<Range> range[N];
int f[N], g[N];

inline int get_count(int x)
{
    int res = 0;
    while (x) res += x & 1, x >>= 1;
    return res;
}

inline int get(int x)
{
    return x / len;
}

bool cmp(const Query& a, const Query& b)
{
    int i = get(a.l), j = get(b.l);
    if (i != j) return i < j;
    return a.r < b.r;
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    vector<int> nums;//预处理所有二进制表示下有k个1的数 
    for (int i = 0; i < 1 << 14; i ++ )
        if (get_count(i) == k)
            nums.push_back(i);
    for (int i = 1; i <= n; i ++ )//预处理f和g数组 
    {
        for (auto y: nums) ++ g[w[i] ^ y];
        f[i] = g[w[i + 1]];
    }
    for (int i = 0; i < m; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        q[i] = {i, l, r};
    }
    len = sqrt(n);
    sort(q, q + m, cmp);//莫队离线 

    for (int i = 0, L = 1, R = 0; i < m; i ++ )
    {
        int l = q[i].l, r = q[i].r;
        //R+1的情况 
        if (R < r) range[L - 1].push_back({i, R + 1, r, -1});
        while (R < r) q[i].res += f[R ++ ];
        //R-1的情况 
        if (R > r) range[L - 1].push_back({i, r + 1, R, 1});
        while (R > r) q[i].res -= f[ -- R];
        //L+1的情况 
        if (L < l) range[R].push_back({i, L, l - 1, -1});
        while (L < l) q[i].res += f[L - 1] + !k, L ++ ;
        //L-1的情况 
        if (L > l) range[R].push_back({i, l, L - 1, 1});
        while (L > l) q[i].res -= f[L - 2] + !k, L -- ;
    }

    memset(g, 0, sizeof g);
    for (int i = 1; i <= n; i ++ )
    {
        for (auto y: nums) ++ g[w[i] ^ y];
        for (auto& rg: range[i])
        {
            int id = rg.id, l = rg.l, r = rg.r, t = rg.t;
            for (int x = l; x <= r; x ++ )
                q[id].res += g[w[x]] * t;
        }
    }
	//记得做前缀和统计答案 
    for (int i = 1; i < m; i ++ ) q[i].res += q[i - 1].res;
    for (int i = 0; i < m; i ++ ) ans[q[i].id] = q[i].res;
    for (int i = 0; i < m; i ++ ) printf("%lld\n", ans[i]);

    return 0;
}