莫队 最长区间和为0

之前看到过一个经典问题, 可能能对理解这个题为什么可以转化为求前缀和的问题有所帮助.
k倍区间: 给出一个数组, 问多少个区间的和是k的倍数.
不妨设a为原数组, sum前缀和数组, 设$\sum _{i=l}^{r}a\%k=0$, 实际上相当于$sum[r]\%k-sum[l-1]\%k=0$. 那么对于前缀和sum%k中出现的每个数x, 统计其出现次数cnt[x], 那么这cnt[x]个x任取两个作为l-1和r构成的区间的和就一定是k的倍数, 即$C_{cnt[x]}^2$.

回到本题, 给出一个长度为5e4的数组, 5e4次查询, 查询l到r之间区间和为0的最长区间长度.
l到r的区间和为0其实就是l-1和r前缀和相等, 那么这个题就转化为:在前缀和数组中, l-1到r之间两个相同数的最远距离.
求出前缀和, 之后的操作都在前缀和上完成.
对于前缀和离散化, 把负数搬到正数区间(其实我们并不关心这个数到底是什么).
每个数最后一次出现位置-第一次出现位置就是这个数的贡献. 对于所有的数取最大值就是答案.
但是这样的过程一次询问就是O(n), 考虑用莫队写这个暴力的过程.
对于每个数, 开双端队列维护l-1到r之间这个数的所有位置信息, 那么这个数的贡献就是队尾-队首. L左移就要从相应deque的头放入, 并更新答案, 其他操作类似.
另外, 因为答案不连续, 注意要用map维护每个长度出现的次数.
例如4当前贡献是10, del后变成了5, 但是3的贡献是8, 虽然在4是10的时候不能作为答案, 但在4 del后更加优秀的显然是3的8而不是4的5. 所以要用map维护最大的贡献(map.rbegin就是最大的).
因为我们对于每个询问要查询[l-1~r], 所以l从0,r从-1开始做莫队.
代码:

int a[M], n, q,answer,blo[M], bloSZ,ans[M];
struct query {
    int l, r, id;
} queries[M];

bool cmp(query x, query y) {
    return (blo[x.l] ^ blo[y.l]) ? blo[x.l] < blo[y.l] : ((blo[x.l] & 1) ? x.r < y.r : x.r > y.r);
}

void divide() {
    bloSZ = sqrt(n);
    for (int i = 1; i <= n; ++i) {
        blo[i] = (i - 1) / bloSZ + 1;
    }
}

deque<int> dq[M];
map<int, int> mp;

void addL(int pos) {
    int tmp = a[pos];
    if (dq[tmp].size() >= 2) {
        int tmp2 = dq[tmp].back() - dq[tmp].front();
        mp[tmp2]--;
        if (mp[tmp2] == 0)mp.erase(tmp2);
    }
    dq[tmp].push_front(pos);
    if (dq[tmp].size() >= 2) {
        int tmp2 = dq[tmp].back() - dq[tmp].front();
        mp[tmp2]++;
    }
    if (mp.empty())answer = 0;
    else answer = (*mp.rbegin()).first;
}

void delL(int pos) {...}
void addR(int pos) {...}
void delR(int pos) {...}
//都差不多, 不写了

vector<int> ls;

void Mo() {
    sort(queries + 1, queries + 1 + q, cmp);
    int l = 0, r = -1;
    for (int i = 1; i <= q; ++i) {queries[i].l--;
        while (l > queries[i].l)addL(--l);
        while (r < queries[i].r)addR(++r);
        while (l < queries[i].l)delL(l++);
        while (r > queries[i].r)delR(r--);
        ans[queries[i].id] = answer ;
    }
    for (int i = 1; i <= q; ++i)write(ans[i]), enter;
}

void init() {
    n = read(), q = read();
    for (int i = 1; i <= n; ++i) {
        a[i] = read();
        a[i] = a[i] + a[i - 1];
        ls.emplace_back(a[i]);
    }
    ls.emplace_back(0);
    sort(all(ls));
    ls.erase(unique(all(ls)), ls.end());
    for (int i = 0; i <= n; ++i)
        a[i] = lower_bound(all(ls), a[i]) - ls.begin();
    divide();
    for (int i = 1; i <= q; ++i) {
        int l = read(), r = read();
        queries[i] = (query) {l, r, i};
    }
    Mo();
}