（预处理+莫队算法）HDU

题意：

一个长度为n的数列，m次查询L到R之间所有连续子序列的gcd之和。

分析：

很明显的莫队算法。

很明显发现了gcd是单调递减的，并且最多存在32个的性质。

想了很久，脑补了许多种方法来拉伸L和R，但是都有漏洞。

实际上，这道题还是比较复杂的。。

在思考的过程中，我没有充分利用gcd的递减性质。

这题其实这题有共通之处，至少在我的做法上是这样的。

可以发现，在R向右拉伸的过程中，增加的和只是从L到R+1中的每一个后缀的和。

向左则为减，L的移动同理。

那么我们只要提前预处理每个位置的前缀所包含的所有数，以为成段会有相等的值，所以用pair存值和数量。

同理，后缀也要预处理。

那么我们就可以在将L和R拉伸时，用log的复杂度进行增减。

而预处理的复杂度仅为n*logn*logn。

查询的总复杂度为n*sqrt(n)*logn。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <set>
#include <vector>
#include <queue>
#include <map>
#include <list>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdlib>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-8)
#define fi first
#define se second
typedef pair<ll, ll> pll;

int sgn(double a) {
    return a < -eps ? -1 : a < eps ? 0 : 1;
}

const int maxn = 50010;
struct Q {
    int l, r, index;
};
Q query[maxn];
int t, n, q;
int a[maxn];
int b[maxn];
const int bk = 250;
long long res;
long long ans[maxn];
int f[maxn][20];

void rmq_init() {
    for(int i = 1; i <= n; i++)
        f[i][0] = a[i];
    int k = floor(log((double)n) / log(2.0));
    for(int j = 1; j <= k; j++)
        for(int i = n; i >= 1; i--) {
            if(i + (1 << (j - 1)) <= n)
                f[i][j] = __gcd(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
        }
}

int rmq(int i, int j) {
    int k = floor(log((double)(j - i + 1)) / log(2.0));
    return __gcd(f[i][k], f[j - (1 << k) + 1][k]);
}

bool cmp (Q a, Q b) {
    if(a.l / bk == b.l / bk)return a.r < b.r;
    else return a.l / bk < b.l / bk;
}


vector<pll> pre[maxn];
vector<pll> suf[maxn];


int search2(int zl, int l, int b) {
    int left = l, right = n;
    int w = l + 1;
    while(left <= right) {
        int mid = (left + right) >> 1;
        int pp = rmq(zl, mid);
        if(pp == b) {
            left = mid + 1;
            w = mid;
        } else {
            right = mid - 1;
        }
    }
    return w;
}

int search3(int zl, int l, int b) {
    int left = l, right = n;
    int w = l + 1;
    while(left <= right) {
        int mid = (left + right) >> 1;
        int pp = rmq(n - mid + 1, n - zl + 1);
        if(pp == b) {
            left = mid + 1;
            w = mid;
        } else {
            right = mid - 1;
        }
    }
    return w;
}

void Pfinit() {
    for(int i = 1; i <= n; i++) {
        pre[i].clear();
        for(int s = i - 1; s < n;) {
            int d = search2(i, s + 1, rmq(i, s + 1));
            pre[i].push_back(make_pair(d - s, rmq(i, s + 1)));
            s = d;
        }
    }
    for(int i = 1; i <= n; i++) {
        b[i] = a[n - i + 1];
    }
    for(int i = 1; i <= n; i++) {
        suf[n - i + 1].clear();
        for(int s = i - 1; s < n;) {
            int d = search3(i, s + 1, rmq(n - s, n - i + 1));
            suf[n - i + 1].push_back(make_pair(d - s, rmq(n - s, n - i + 1)));
            s = d;
        }
    }

}


void add_left( int s, int x, int v) {
    int num = s - x + 1;
    for(int i = 0; i < pre[x].size(); i++) {
        if(pre[x][i].fi >= num) {
            res += num * pre[x][i].se * v;
            break;
        } else {
            res += pre[x][i].fi * pre[x][i].se * v;
            num -= pre[x][i].fi;
        }
    }
}


void add_right(int s, int x, int v) {
    int num = x - s + 1;
    for(int i = 0; i < suf[x].size(); i++) {
        if(suf[x][i].fi >= num) {
            res += num * suf[x][i].se * v;
            break;
        } else {
            res += suf[x][i].fi * suf[x][i].se * v;
            num -= suf[x][i].fi;
        }
    }
}

int main() {
    scanf("%d", &t);
    while(t--) {
        res = 0;
        scanf("%d", &n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
        }
        rmq_init();
        Pfinit();
        scanf("%d", &q);
        for(int i = 0; i < q; i++) {
            scanf("%d%d", &query[i].l, &query[i].r);
            query[i].index = i;
        }
        sort(query, query + q, cmp);
        int pl = 1, pr = 0;
        for (int i = 0; i < q; i++) {
            int index = query[i].index;
            if (pr < query[i].r) {
                for (int j = pr + 1; j <= query[i].r; j++) {
                    add_right(pl, j, 1);
                }

            } else {
                for (int j = pr; j > query[i].r; j--) {
                    add_right(pl, j, -1);
                }
            }
            pr = query[i].r;
            if (pl < query[i].l) {
                for (int j = pl; j < query[i].l; j++) {
                    add_left(pr, j, -1);
                }
            } else {
                for (int j = pl - 1; j >= query[i].l; j--) {
                    add_left(pr, j, 1);
                }
            }
            pl = query[i].l;
            ans[index] = res;
        }
        for(int i = 0; i < q; i++) {
            printf("%lld
", ans[i]);
        }
    }
    return 0;
}