HDU 5869 Different GCD Subarray Query

Different GCD Subarray Query

http://acm.hdu.edu.cn/showproblem.php?pid=5869

分析：

　　st表+gcd+二分+树状数组。

　　调的心累。

　　从一个点为右端点，往左扩展，gcd是单调下降的。而且下降次数不超过log次。于是可以用st表预处理，做到O(1)求区间的gcd。然后二分断点处即可。

　　求区间的不同gcd的个数：离线，枚举右端点，考虑计算所有以这个点为右端点的答案，树状数组维护。注意到相同的gcd只会算一次，用last维护上一个出现的位置，这个gcd最右边的位置会替代了左边的所有的位置，只在最右边的gcd的位置加入一个1即可。

　　后来在看了几篇博客，发现其实不需要二分！！！直接往左扫过去，如果gcd=1了，就break，而且比二分还快！！！（gcd减少次数本来就不超过log次，可能是数据比较随机的情况下，很快就变成1了。。。)

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
#include<cctype>
#include<set>
#include<vector>
#include<queue>
#include<map>
#define fi(s) freopen(s,"r",stdin);
#define fo(s) freopen(s,"w",stdout);
using namespace std;
typedef long long LL;

inline int read() {
    int x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;
    for(;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;
}

const int N = 100005;

struct Que{
    int l, r, id;
    bool operator < (const Que &A) const {
        return r < A.r;
    }
}q[N];
struct Bit{
    int n;LL sum[N];
    void Clear() { memset(sum, 0, sizeof(sum)); }
    void update(int p,int v) {
        for (; p<=n; p+=(p&(-p))) sum[p] += v;
    }
    LL query(int p) {
        LL ans = 0;
        for (; p; p-=(p&(-p))) ans += sum[p];
        return ans;
    }
}bit;
int a[N], f[N][20], last[N * 10], Log[N]; // a[i]的范围1e6!!! 
LL ans[N];
int n, Q;

int gcd(int a,int b) {
    return b == 0 ? a : gcd(b, a % b);
}
void init() {
    memset(ans, 0, sizeof(ans));
    memset(last, 0, sizeof(last));
    bit.Clear(); bit.n = n;
    for (int i=1; i<=n; ++i) f[i][0] = a[i];
    for (int j=1; j<=Log[n]; ++j) 
        for (int i=1; (i+(1<<j)-1)<=n; ++i) 
            f[i][j] = gcd(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
int Gcd(int l,int r) {
    int t = Log[r - l + 1];
    return gcd(f[l][t], f[r - (1 << t) + 1][t]);
}
int find(int l,int r,int d,int R) { // R! R! R! not r! r! r!
    int ans = 0;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (Gcd(mid, R) == d) ans = mid, r = mid - 1;
        else l = mid + 1;
    }
    return ans - 1;
}
void solve() {
    sort(q + 1, q + Q + 1);
    int now = 1;
    for (int i=1; i<=n; ++i) {
        int p = i, d = a[i];
        while (p) {
            if (!last[d]) bit.update(p, 1);
            else if (last[d] < p) bit.update(last[d], -1), bit.update(p, 1);
            last[d] = p;
            p = find(1, p, d, i);
            if (p) d = Gcd(p, i);
        }
//        for (int j=i; j; --j,d=Gcd(j,i)) {
//            if (j > last[d]) {
//                if (last[d]) bit.update(last[d], -1);
//                bit.update(j, 1);
//                last[d] = j;
//            }
//            if (d == 1) break;
//        }
        while (now <= Q && q[now].r == i) {
            ans[q[now].id] = bit.query(q[now].r) - bit.query(q[now].l - 1);
            now ++;
        }
    }
    for (int i=1; i<=Q; ++i) printf("%lld
",ans[i]);
}
int main() { 
    Log[0] = -1;
    for (int i=1; i<=100000; ++i) Log[i] = Log[i >> 1] + 1;
    while (~scanf("%d%d", &n, &Q)) {
        for (int i=1; i<=n; ++i) a[i] = read();
        init();
        for (int i=1; i<=Q; ++i) 
            q[i].l = read(), q[i].r = read(), q[i].id = i;
        solve();
    }
    return 0;
}