HDU 4630 No Pain No Game

题意： 有N个数， 是 1~N的一个排列。有M个询问， 每次询问一个区间， 问从这个区间中，取两个数的最大的最大公约数。

思路： 离线处理 + 线段树（点更新）

在一个区间内， 如果一个因子出现两次，该因子就肯定是该区间的一个解。 而出现两次并且是最大。 就是该区间的最优解。

首先要求出每个数对应的因子存起来。

然后对每次询问存起来。（离线处理）并按右区间从小到大排序。

Last[V] 数组是表示的是 因子V在上次出现的位置。

然后对每个数因子对线段树进行更新。 

更新的位置是更新在上次出现该因子的位置上。 因为是以该数的因子为第二次出现的。

4

8 2 4 9

3

2 3

1 3

2 4

i = 1时， 线段树的叶子节点[0, 0, 0, 0];

i = 2时， 线段树的叶子节点[2, 0, 0, 0];

i = 3时， 线段树的叶子节点[4, 2, 0, 0]; 遇到两个询问， 输出区间的最大值 Query(2, 3)  = 2  Query(1, 3) = 4;

i = 4时， 线段树的叶子节点[4, 2, 1, 0]; 遇到一个询问， Query(2, 4) = 2;

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

#define lson(x) (x<<1)
#define rson(x) ((x<<1)|1)
const int maxn = 50000;

int lc[maxn<<2], rc[maxn<<2], s[maxn<<2];

void pushup(int u) { s[u] = max(s[lson(u)], s[rson(u)]); }

void build(int u, int l, int r) {
    lc[u] = l, rc[u] = r, s[u] = 0;

    if (l == r) return;
    int mid = (l + r) >> 1;
    build(lson(u), l, mid);
    build(rson(u), mid+1 , r);
    pushup(u);
}

void modify(int u, int p, int v) {
    if (lc[u] == rc[u]) {
        s[u] = max(s[u], v);
        return;
    }

    int mid = (lc[u] + rc[u]) >> 1;
    if (p <= mid) modify(lson(u), p, v);
    else modify(rson(u), p, v);
    pushup(u);
}

int query(int u, int l, int r) {
    if (l <= lc[u] && rc[u] <= r)
        return s[u];

    int mid = (lc[u] + rc[u]) >> 1, ret = 0;
    if (l <= mid) ret = max(ret, query(lson(u), l, r));
    if (r > mid) ret = max(ret, query(rson(u), l, r));
    return ret;
}

struct State {
    int l, r, id;
    State(int l = 0, int r = 0, int id = 0):l(l), r(r), id(id) {}
    bool operator < (const State& u) const { return r < u.r; }
}Q[maxn + 5];

int N, M, A[maxn + 5], P[maxn + 5], ans[maxn + 5];
vector<int> G[maxn + 5];

void init () {
    scanf("%d", &N);
    memset(P, 0, sizeof(P));
    for (int i = 1; i <= N; i++) scanf("%d", &A[i]);

    scanf("%d", &M);
    for (int i = 0; i < M; i++) {
        scanf("%d%d", &Q[i].l, &Q[i].r);
        Q[i].id = i;
    }
    sort(Q, Q + M);
    build(1, 0, N);
}

int main () {
    for (int i = 1; i <= maxn; i++)
        for (int j = i; j <= maxn; j += i)
            G[j].push_back(i);

    int cas;
    scanf("%d", &cas);
    while (cas--) {
        init();

        int p = 0;
        for (int i = 1; i <= N; i++) {
            int u = A[i];

            for (int j = 0; j < G[u].size(); j++) {
                int v = G[u][j];
                modify(1, P[v], v);
                P[v] = i;
            }
            while (p < M && Q[p].r == i) {
                ans[Q[p].id] = query(1, Q[p].l, Q[p].r);
                p++;
            }
        }
        for (int i = 0; i < M; i++)
            printf("%d\n", ans[i]);
    }
    return 0;
}