【洛谷5398】[Ynoi2018]GOSICK（二次离线莫队）

最新推荐文章于 2022-02-06 17:12:11 发布

weixin_30302609

最新推荐文章于 2022-02-06 17:12:11 发布

阅读量144

点赞数

原文链接：http://www.cnblogs.com/zyt1253679098/p/11055636.html

版权

题目：

洛谷 5398

当我刚学莫队的时候，他们告诉我莫队能解决几乎所有区间问题；

现在，当我发现一个区间问题似乎难以用我所了解的莫队解决的时候，他们就把这题的正解叫做 XXX 莫队。——题记

（以上皆为瞎扯，纯属虚构，请勿当真）

分析：

先转化一下题目：如果允许每次询问都暴力把区间扫一遍，那么每扫到一个数 \(i\) ，就统计已经扫过的部分中有多少个 \(j\) 满足 \(a_j\) 是 \(a_i\) 的因数（即取数对 \((i,j)\) ）或倍数（即取数对 \((j,i)\) ）。注意，因为 \((i,j)\) 和 \((j,i)\) 是不同的，如果 \(a_i=a_j\) ，那么答案要加 \(2\) 。

考虑莫队。每次往当前区间加入或删除一个元素的时候，需要统计当前区间有多少个元素是该元素的因数或倍数（为了和题目中的「询问」区分，我们不妨把这个操作简称为一个数对一个区间「统计」），然后给答案加上或减去这个数量。这样单次修改的复杂度是 \(O(n)\) ，总时间复杂度高达 \(O(n^2\sqrt{n})\) 。 GG

黑科技来了 ：由于每次当前区间两端点的移动是已知的，所以我们把两端点移动时出现的「统计」离线下来处理（是谓「二次离线」）。

如何离线呢？我们发现每次都是一个数 \(a\) 对一个区间 \([l,r]\) 统计，而这个操作又可以拆分为对 \([1,l)\) 和 \([1,r]\) 两个前缀统计。

然后开始大力分类讨论 ……

第一，当左端点从 \(l\) 左移到 \(l'\) 时，是每个 \(i\in[l',l)\) 对 \([i,r]\) 统计，即对 \([1,i)\) 和 \([1,r]\) 统计；

第二，当左端点从 \(l\) 右移到 \(l'\) 时，是每个 \(i\in[l,l')\) 对 \([i,r]\) 统计，即对 \([1,i)\) 和 \([1,r]\) 统计；

第三，当右端点从 \(r\) 左移到 \(r'\) 时，是每个 \(i\in(r',r]\) 对 \([l,i]\) 统计，即对 \([1,l)\) 和 \([1,i]\) 统计；

第四，当右端点从 \(r\) 右移到 \(r'\) 时，是每个 \(i\in(r,r']\) 对 \([l,i]\) 统计，即对 \([1,l)\) 和 \([1,i]\) 统计。

可以看出统计分为两大类。第一类是 \(i\) 对于 \([1,i)\) （或 \([1,i]\) ，但很明显这两个差距很小）统计，第二类是一个区间中的 \(i\) 对一个固定的前缀分别统计（如第一种情况中是所有 \(i\in[l',l)\) 对固定的前缀 \([1,r]\) 统计）。

第一类可以预处理。第二类可以按前缀从小到大排序，暴力扫当前前缀对应的所有统计（根据莫队的复杂度证明，端点移动距离之和是 \(O(n\sqrt{n})\) ）。

事实上这两类统计可以抽象成同一个问题：维护一个结构，支持「插入一个数」和「给定 \(k\) ，查询已经插入的数中有多少个是 \(k\) 的因数或倍数」。插入次数是 \(O(n)\) ，查询次数是 \(O(n\sqrt{n})\) 。

既然查询次数远比插入次数多，自然考虑维护每个数的答案。插入一个数时，因为可以在 \(O(\sqrt{n})\) 时间内遍历一个数的所有因数，所以直接暴力修改所有因数的答案即可。同理，当 \(k\) 大于一个阈值，比如 \(S\) ，倍数也可以暴力修改，单次时间复杂度不超过 \(O(\frac{n}{S})\) ，据说此处选择 \(S=32\) 。

那么当 \(k\leq S\) 怎么办呢？这里有一个很巧妙的做法。预处理出每个数能否被 \([1,S]\) 中的某个数整除（这个结果下称「状态」），并将结果压成一个 \(S\) 位的二进制数，并开一个大小为 \(2^S\) 的桶记录「这个状态的数的答案应该统一加上多少」。当插入 \(k(k\leq S)\) 时，暴力将所有 \(k\) 这一位上是 \(1\) 的状态的答案加 \(1\) 。查询时不光查询前一段话中维护的答案，也要加上这一段话中对应状态的答案。由于 \(2^{32}\) 太大了，因此把因数分成 \(8\) 个一组，每个数对应 \(4\) 个状态。这样插入时只需要修改 \(2^{8-1}\) 个状态，查询时需要查询这个数对应的 \(4\) 个状态。

还有一个小小的细节。由于默认任意两个相同的数会给答案贡献 \(2\) （原因在文首说了），如果 \(i\) 对 \([l,r]\) 统计，而 \(i\in[l,r]\) ，那么 \((i,i)\) 这个数对就被算了两次。没关系，我们只需要放任它算两次，最后给所有询问的答案减去区间长度即可。也由于这个原因，\(i\) 对 \([1,i]\) 统计的答案应该是 \(i\) 对 \([1,i)\) 统计的答案加 \(2\) 。

代码：

注意每次算出的是答案相对于上次的变化量，所以最后要按照处理询问的顺序做一遍前缀和。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <vector>
#include <cmath>
using namespace std;

namespace zyt
{
    template<typename T>
    inline bool read(T &x)
    {
        char c;
        bool f = false;
        x = 0;
        do
            c = getchar();
        while (c != EOF && c != '-' && !isdigit(c));
        if (c == EOF)
            return false;
        if (c == '-')
            f = true, c = getchar();
        do
            x = x * 10 + c - '0', c = getchar();
        while (isdigit(c));
        if (f)
            x = -x;
        return true;
    }
    template<typename T>
    inline void write(T x)
    {
        static char buf[20];
        char *pos = buf;
        if (x < 0)
            putchar('-'), x = -x;
        do
            *pos++ = x % 10 + '0';
        while (x /= 10);
        while (pos > buf)
            putchar(*--pos);
    }
    typedef long long ll;
    const int N = 1e5 + 10, M = 1e5, Q = N, SS = 8, S = 32;
    const bool ADD = true, SUB = false;
    int n, m, block, blnum, belong[N], arr[N], fac[N][4], facnum[4][1 << SS], now[N], f[N];
    ll ans[Q];
    struct _ask
    {
        int l, r, id;
        bool operator < (const _ask &b) const
        {
            return belong[l] == belong[b.l] ? r < b.r : belong[l] < belong[b.l];
        }
    }ask[Q];
    struct node
    {
        int l, r, id;
        bool type;
        node(const int _l, const int _r, const int _id, const bool _t)
            : l(_l), r(_r), id(_id), type(_t) {}
    };
    vector<node> v[N];
    void insert(const int a)
    {
        for (int i = 1; i * i <= a; i++)
            if (a % i == 0)
            {
                ++now[i];
                if (i * i < a)
                    ++now[a / i];
            }
        if (a > S)
        {
            for (int i = a; i <= M; i += a)
                if (i > S)
                    ++now[i];
        }
        else
        {
            int bl = (a - 1) / SS, pos = (a - 1) % SS;
            for (int i = 0; i < (1 << SS); i++)
                if (i & (1 << pos))
                    ++facnum[bl][i];
        }
    }
    int query(const int a)
    {
        int ans = now[a];
        for (int i = 0; i < 4; i++)
            ans += facnum[i][fac[a][i]];
        return ans;
    }
    int work()
    {
        read(n), read(m);
        block = sqrt(n), blnum = ceil(double(n) / double(block));
        for (int i = 1; i <= M; i++)
            for (int j = 0; j < 4; j++)
                for (int k = j * SS + 1; k <= (j + 1) * SS; k++)
                    if (i % k == 0)
                        fac[i][j] |= (1 << (k - j * SS - 1));
        for (int i = 1; i <= n; i++)
            read(arr[i]), belong[i] = (i - 1) / block + 1;
        for (int i = 1; i <= m; i++)
            read(ask[i].l), read(ask[i].r), ask[i].id = i;
        sort(ask + 1, ask + m + 1);
        for (int i = 1; i <= n; i++)
            f[i] = query(arr[i]), insert(arr[i]);
        for (int i = 1, l = 1, r = 1; i <= m; i++)
        {
            if (ask[i].l < l)
            {
                v[r].push_back(node(ask[i].l, l - 1, ask[i].id, ADD));
                while (ask[i].l < l)
                    ans[ask[i].id] -= f[--l];
            }
            if (ask[i].l > l)
            {
                v[r].push_back(node(l, ask[i].l - 1, ask[i].id, SUB));
                while (ask[i].l > l)
                    ans[ask[i].id] += f[l++];
            }
            if (ask[i].r > r)
            {
                v[l - 1].push_back(node(r + 1, ask[i].r, ask[i].id, SUB));
                while (ask[i].r > r)
                    ans[ask[i].id] += f[++r] + 2;
            }
            if (ask[i].r < r)
            {
                v[l - 1].push_back(node(ask[i].r + 1, r, ask[i].id, ADD));
                while (ask[i].r < r)
                    ans[ask[i].id] -= f[r--] + 2;
            }
        }
        memset(facnum, 0, sizeof(facnum));
        memset(now, 0, sizeof(now));
        for (int i = 1; i <= n; i++)
        {
            insert(arr[i]);
            for (vector<node>::iterator it = v[i].begin(); it != v[i].end(); it++)
                for (int j = it->l; j <= it->r; j++)
                    ans[it->id] += query(arr[j]) * (it->type == ADD ? 1 : -1);
        }
        ans[0] = 2;
        for (int i = 1; i <= m; i++)
            ans[ask[i].id] += ans[ask[i - 1].id];
        for (int i = 1; i <= m; i++)
            ans[ask[i].id] -= ask[i].r - ask[i].l + 1;
        for (int i = 1; i <= m; i++)
            write(ans[i]), putchar('\n');
        return 0;
    }
}
int main()
{
#ifdef BlueSpirit
    freopen("5398.in", "r", stdin);
#endif
    return zyt::work();
}

转载于:https://www.cnblogs.com/zyt1253679098/p/11055636.html

weixin_30302609

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【洛谷5398】[Ynoi2018]GOSICK（二次离线莫队）

题目：洛谷 5398当我刚学莫队的时候，他们告诉我莫队能解决几乎所有区间问题；现在，当我发现一个区间问题似乎难以用我所了解的莫队解决的时候，他们就把这题的正解叫做 XXX 莫队。——题记（以上皆为瞎扯，纯属虚构，请勿当真）分析：先转化一下题目：如果允许每次询问都暴力把区间扫一遍，那么每扫到一个数 \(i\) ，就统计已经扫过的部分中有多少个 \(j\) 满足 \(a_j\) 是 \(a...
复制链接

扫一扫