[HDU 5869] Different GCD Subarray Query （线段树GCD+离线算法） （好题）

链接

HDU 5869

---

题意

2016大连站网赛1002题。
给出一个长度为N的序列和Q个询问，对每个询问[l, r]，输出该区间和其子区间产生的不同gcd个数。

---

题解

一道比较好的线段树gcd离线处理的题目，据说FZU2222是原题。
有个类似的题目，HDU3333，也是线段树加离线处理。

先将Q个区间离线记录，按照右端点排序。然后从左向右枚举区间端点，记录以i为区间右端点的各个子区间产生的不同gcd和产生这个gcd所需的区间左端点，以i为区间右端点所产生的不同gcd可以从以i-1为区间右端点产生的不同gcd推出来（有点dp的思想），以i-1为区间右端点的不同gcd有可能同a[i]产生相同的gcd，这时要更新该gcd的区间左端点为最右侧的那个，这样处理以后，我们就得到了[1, i]区间的所有子区间产生的不同gcd，和产生每个gcd的最右区间左端点（rp[gcd]）。用线段树维护这些左端点的贡献，每个gcd的左端点贡献为1，查询区间[L, i]的总贡献值即可。
整个过程其实就相当于在扫描时将gcd分组，每个分组只记录最右端gcd值，gcd的性质导致其数目很有限，所以在递推的时候能优化大量计算。
而离散化的作用在于，我们始终把持区间右端点，并且对在此之前产生的gcd左端点进行记录和更新，最右左端点保证不漏解，同时消除次右点的贡献值，保证每个gcd只算一次，查询获得正确的答案。
PS：貌似是只有我一个看得懂的题解。。。

---

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int euclid(int a, int b) { return b == 0 ? a : euclid(b, a % b); }
#define maxn 100010
#define maxm 1000010
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
int seg[maxn << 2];
inline int lowbit(int x)
{
    return (x&-x);
}
void add(int x, int value, int n)
{
    for(int i = x; i <= n; i += lowbit(i))
    {
        seg[i] += value;
    }
}
int get(int x)
{
    int sum = 0;
    for(int i = x; i; i -= lowbit(i))
        sum += seg[i];
    return sum;
}
struct _range
{
    int idx, l, r;
} range[maxn];
bool cmp(_range& a, _range& b) { return a.r < b.r; }
struct _gcd
{
    int val[32], lp[32], top;
} gcd[maxn];
int o[maxn], a[maxn], rp[maxm];
int main()
{
    int N, Q;
    while(cin >> N >> Q)
    {
        for(int i = 1; i <= N; i++)
        {
            scanf("%d", &a[i]);
            gcd[i].top = 0;
        }
        memset(rp, 0, sizeof(rp));
        for(int i = 0, l, r; i < Q; i++)
        {
            scanf("%d%d", &l, &r);
            range[i].idx = i;
            range[i].l = l;
            range[i].r = r;
        }
        sort(range, range + Q, cmp);

        memset(seg, 0, sizeof(int) * (N + 1 << 2));
        for(int i = 1, t = 0; i <= N; i++)
        {
            for(int j = 0, g; j < gcd[i-1].top; j++)
            {
                g = euclid(gcd[i-1].val[j], a[i]);
                if(!gcd[i].top || gcd[i].val[gcd[i].top-1] != g)
                {
                    gcd[i].val[gcd[i].top] = g;
                    gcd[i].lp[gcd[i].top++] = gcd[i-1].lp[j];
                }
                else
                    gcd[i].lp[gcd[i].top-1] = gcd[i-1].lp[j];
            }
            if(!gcd[i].top || a[i] != gcd[i].val[gcd[i].top-1])
            {
                gcd[i].val[gcd[i].top] = a[i];
                gcd[i].lp[gcd[i].top++] = i;
            }
            else
                gcd[i].lp[gcd[i].top-1] = i;

/*
            for(int j = 0; j < gcd[i].top; j++)
            {
                printf("[%d:%d] ", gcd[i].val[j], gcd[i].lp[j]);
            } printf("\n");
*/

            for(int j = 0, v, lp; j < gcd[i].top; j++)
            {
                v = gcd[i].val[j], lp = gcd[i].lp[j];
                if(!rp[v]) { add(lp, 1, N << 2); rp[v] = lp; }
                else if(lp > rp[v]) { add(rp[v], -1, N << 2); add(lp, 1, N << 2); rp[v] = lp; }
            }
            while(t < Q && range[t].r == i)
            {
                o[range[t].idx] = get(range[t].r) - get(range[t].l - 1);
                t++;
            }
        }
        for(int i = 0; i < Q; i++)
        {
            printf("%d\n", o[i]);
        }
    }

    return 0;
}