hdu7107 GCD on Sequence

题意：给你一个排列a，定义v(l,r)表示a[l,r]中任意两者gcd的最大值。现问你在所有n*(n-1)/2对l，r中，有多少对满足v(l,r)=x，输出x=1~n的答案。

解：

对于某一个x，如果把x的所有倍数所在位置提出来，那么任意一对l，r，如果包含了其中某两个点，v就一定大于等于x。

于是我们考虑从大往小枚举x，同时考虑对于每个左端点，右端点可选的取值范围，使得这一个区间的v恰好等于x。

考虑维护一个数组b，其中每一个位置i存的是左端点为i时，右端点最右能选到b[i]，如果选到b[i]+1就会使v大于当前的x。

那么这个b数组有一个性质，就是它单调不减，很容易证明：当b[i]=k时，b[i-1]<=k。

考虑如何利用这个b，并且维护这个b。

对某个特定的x，x的倍数把序列分成了若干段。把每个提出来的位置和它前面那些数一起作为左端点考虑，那么它们的右端点必定不能小于下一个被提出来的数，同时右端点不能大于b数组。满足右端点的这两个限制的话，v就一定等于x。我们现在要求的就是左端点所在这一段中，(每个数的b[i]-下一个提出来的位置+1)，并且对0取max，再求和。这里由于b的单调性我们可以把max化掉，具体来说，找到开始大于等于(下一个位置)的地方，然后从这里到(当前这一个位置)，其中的每个数b[i]都大于等于(下一个位置)。这样就是b求个和，然后减去下一个位置*数量。

维护b时，对于1~当前位置，它们的右端点都不能到达下一个位置了，所以相当于对(下一个位置-1)取一个min。区间取min也可以利用b的单调性改成区间赋值操作，只要找到第一个大于等于要取min的数的位置，然后把它后面都赋值成要取min的数就OK了。注意：如果我们对某个x处理到一半，b仍旧满足单调性。

b需要做的操作是找到第一个大于k的位置，区间求和，区间赋值，显然线段树可以胜任，这题就做完了。

复杂度是首先枚举倍数有个调和级数，然后是线段树的log，一共log²。

/**
 *  There is no end though there is a start in space. ---Infinity.
 *  It has own power, it ruins, and it goes though there is a start also in the star. ---Finite.
 *  Only the person who was wisdom can read the most foolish one from the history.
 *  The fish that lives in the sea doesn't know the world in the land.
 *  It also ruins and goes if they have wisdom.
 *  It is funnier that man exceeds the speed of light than fish start living in the land.
 *  It can be said that this is an final ultimatum from the god to the people who can fight.
 *  
 *  Steins;Gate
**/

#include <bits/stdc++.h>
typedef long long LL;
typedef unsigned long long uLL;
typedef long double LD;
inline char gc() {
    // return getchar();
    static char buf[100000], *p1 = buf, *p2 = buf;
    if(p1 == p2) {
        p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
    }
    return (p1 == p2) ? EOF : *p1++;
}

template <typename T>
inline void read(T& x) {
    x = 0;
    char c(gc());
    int f(1);
    while(c < '0' || c > '9') {
        if(c == '-') {
            f = -1;
        }
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = gc();
    }
    x *= f;
}

template <typename T>
inline T Abs(T x) {
    return x < 0 ? -x : x;
}
template <typename T>
inline T Max(T a, T b) {
    return (a > b) ? a : b;
}
template <typename T>
inline T Min(T a, T b) {
    return (a < b) ? a : b;
}

inline int read(char* s) {
    char c(gc());
    int top(0);
    while(c == ' ' || c == '
') {
        c = gc();
    }
    while(c != ' ' && c != '
' && c != EOF) {
        s[top++] = c;
        c = gc();
    }
    s[top] = 0;
    return top;
}

inline LL read() {
    LL x;
    read(x);
    return x;
}

const int N = 200010;

int n, a[N], pos[N], n2;
std::vector<int> v[N];
LL ans[N], sum[N * 4], tag[N * 4], large[N * 4];

inline void pushdown(int l, int r, int o) {
    if(tag[o]) {
        int mid = (l + r) >> 1;
        tag[o << 1 | 1] = tag[o << 1] = tag[o];
        large[o << 1] = large[o << 1 | 1] = tag[o];
        sum[o << 1] = tag[o] * (mid - l + 1);
        sum[o << 1 | 1] = tag[o] * (r - mid);
        tag[o] = 0;
    }
}

inline void pushup(int o) {
    sum[o] = sum[o << 1] + sum[o << 1 | 1];
    large[o] = Max(large[o << 1], large[o << 1 | 1]);
}

LL getSum(int L, int R, int l, int r, int o) {
    if(L <= l && r <= R) {
        return sum[o];
    }
    pushdown(l, r, o);
    int mid = (l + r) >> 1;
    LL ans = 0;
    if(L <= mid)
        ans = getSum(L, R, l, mid, o << 1);
    if(mid < R)
        ans += getSum(L, R, mid + 1, r, o << 1 | 1);
    return ans;
}

void change(int L, int R, LL v, int l, int r, int o) {
    if(L <= l && r <= R) {
        sum[o] = v * (r - l + 1);
        tag[o] = v;
        large[o] = v;
        return;
    }
    pushdown(l, r, o);
    int mid = (l + r) >> 1;
    if(L <= mid)
        change(L, R, v, l, mid, o << 1);
    if(mid < R)
        change(L, R, v, mid + 1, r, o << 1 | 1);
    pushup(o);
    return;
}

int getPos(int k, int l, int r, int o) {
    if(l == r) {
        return (sum[o] >= k) ? r : (r + 1);
    }
    int mid = (l + r) >> 1;
    pushdown(l, r, o);
    if(large[o << 1] >= k)
        return getPos(k, l, mid, o << 1);
    else
        return getPos(k, mid + 1, r, o << 1 | 1);
}

void build(int l, int r, int o) {
    tag[o] = 0;
    if(l == r) {
        sum[o] = large[o] = n;
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, o << 1);
    build(mid + 1, r, o << 1 | 1);
    pushup(o);
    return;
}

inline void solve() {
    read(n);
    for(int i = 1; i <= n; i++) {
        read(a[i]);
        pos[a[i]] = i;
    }
    n2 = n >> 1;
    for(int i = 2; i <= (n2); i++) {
        for(int j = i; j <= (n); j += i) {
            v[i].push_back(pos[j]);
        }
        std::sort(v[i].begin(), v[i].end());
    }
    build(1, n, 1);
    ans[1] = n * 1ll * (n - 1) / 2;
    for(int x = n2; x > 1; x--) {
        // printf("x = %d  siz = %d 
", x, v[x].size());
        for(int i = 0; i < v[x].size() - 1; i++) {
            int p = v[x][i], last = (i ? (v[x][i - 1] + 1) : 1), nex = v[x][i + 1];
            // [last, p] [nex, ...]
            int poi = getPos(nex, 1, n, 1);
            // printf("getpos : %d -> %d 
", nex, poi);
            poi = Max(poi, last);
            if(poi <= p) {
                // [poi, p]
                ans[x] += getSum(poi, p, 1, n, 1) - 1ll * (p - poi + 1) * (nex - 1);
            }
            poi = getPos(nex - 1, 1, n, 1);
            if(poi <= p) {
                // [poi, p]
                change(poi, p, nex - 1, 1, n, 1);
            }
        }
        ans[1] -= ans[x];
    }

    for(int i = 1; i <= n; i++) {
        printf("%lld
", ans[i]);
    }
    return;
}

inline void clear() {
    for(int i = 1; i <= n2; i++) {
        v[i].clear();
        v[i].resize(0);
        ans[i] = 0;
    }
    for(int i = 1; i <= n; i++) {
        pos[i] = a[i] = 0;
    }
    return;
}

int main() {
    int T = read();
    while(T--) {
        solve();
        if(T) {
            clear();
        }
    }
    return 0;
}
/*
1
5
1 4 3 5 2

*/