Hdu 4777 Rabbit Kingdom (树状数组)

题目链接：

　　Hdu 4777  Rabbit Kingdom

题目描述:

　　有一个含有n个数的序列，m个询问。问 [l, r] 区间内与所有数都互质的数有几个？

解题思路：

　　先预处理出来每个数的贡献区间，每个数的贡献区间是 [左边最近不互质数的位置，右边最近不互质数的位置] ，现在问题就转化为了求区间 [L, R] 中有几个数的贡献区间能完整覆盖 [L, R] 区间。但是数据范围挺大的，可以考虑用树状数组离线处理来达到优化的目的。先对所有的查询进行排序 (按照L升序排列) ，然后从左到右依次处理。我们用树状数组区间和sum [L, R] 表示区间[L, R]中符合题意的有多少个数。假设现在需要查询 [L, R] 区间，我们可以考虑贡献区间L[i]<L的数，可以在i位置加 1，然后在R[i]位置减1。这样处理的话必须要保证L[i]小于查询区间L的值，以及i要在查询区间内。所以我们每次向后移动的时候，要在树状数组中减去当前位置的数对树状数组的影响，也就是进行操作 i 位置减1，R[i]位置加1. 分析到这里这个题目就变成了一个比较水的利用树状数组进行点更新，区间查询的题目了，也可以用线段树搞的。

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

const int maxn = 200010;
struct node
{
    int l, r, num;
}q[maxn];
int tree[maxn], a[maxn], vis[maxn];
int ans[maxn], L[maxn], R[maxn];

vector <int> vec[maxn];
vector <int> p[maxn];
bool cmp (node a, node b)
{
    return a.l < b.l;
}
//预处理每个数的因子
void init ()
{
    for (int i=0; i<maxn; i++)
        p[i].clear();
    for (int i=2; i<maxn; i++)
        for (int j=i; j<maxn; j+=i)
            p[j].push_back(i);
}
//树状数组
int lowbit (int x)
{
    return x & (-x);
}
void add (int x, int val)
{
    for (int i=x; i<maxn; i+=lowbit(i))
        tree[i] += val;
}
int Sum (int x)
{
    int sum = 0;
    while (x)
    {
        sum += tree[x];
        x -= lowbit(x);
    }
    return sum;
}

int main ()
{
    int n, Q;
    init ();
    while (scanf ("%d %d", &n, &Q), n + Q)
    {
        for (int i=1; i<=n; i++)
            scanf ("%d", &a[i]);
        for (int i=0; i<Q; i++)
        {
            scanf ("%d %d", &q[i].l, &q[i].r);
            q[i].num = i;
        }

        sort (q, q+Q, cmp);
        memset (vis, 0, sizeof(vis));
        //预处理每个数的左边界
        for (int i=1; i<=n; i++)
        {
            L[i] = 0;
            for (int j=0; j<p[a[i]].size(); j++)
            {
                int x = p[a[i]][j];
                L[i] = max (L[i], vis[x]);
                vis[x] = i;
            }
        }
        //预处理每个数的右边界
        for (int i=0; i<=maxn; i++)
        {
            vec[i].clear();
            vis[i] = n + 1;
        }
        for (int i=n; i>0; i--)
        {
            R[i] = n + 1;
            for (int j=0; j<p[a[i]].size(); j++)
            {
                int x = p[a[i]][j];
                R[i] = min (R[i], vis[x]);
                vis[x] = i;
            }
        }

        memset (tree, 0, sizeof(tree));
        for (int i=1; i<=n; i++)
        {
            if (L[i])
                vec[L[i]].push_back(i);
            else
            {
                add (i, 1);
                if (R[i] <= n)
                    add (R[i], -1);
            }
        }
        for (int i=1, j=0; i<=n; i++)
        {
            while (q[j].l == i && j < Q)
            {
                ans[q[j].num] = Sum(q[j].r) - Sum(q[j].l-1);
                j ++;
            }
            add (i, -1);
            if (R[i] <= n)
                add (R[i], 1);
            for (int k=0; k<vec[i].size(); k++)
            {
                int x = vec[i][k];
                add (x, 1);
                add (R[x], -1);
            }
        }
        for (int i=0; i<Q; i++)
            printf ("%d
", ans[i]);
    }
    return 0;
}