gcd（线段树离线处理）——HDU 4630

对应HDU题目：点击打开链接

No Pain No Game

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1801    Accepted Submission(s): 770

Problem Description

Life is a game,and you lose it,so you suicide.
But you can not kill yourself before you solve this problem:
Given you a sequence of number a ₁, a ₂, ..., a _n.They are also a permutation of 1...n.
You need to answer some queries,each with the following format:
If we chose two number a,b (shouldn't be the same) from interval [l, r],what is the maximum gcd(a, b)? If there's no way to choose two distinct number(l=r) then the answer is zero.

 

Input

First line contains a number T(T <= 5),denote the number of test cases.
Then follow T test cases.
For each test cases,the first line contains a number n(1 <= n <= 50000).
The second line contains n number a ₁, a ₂, ..., a _n.
The third line contains a number Q(1 <= Q <= 50000) denoting the number of queries.
Then Q lines follows,each lines contains two integer l, r(1 <= l <= r <= n),denote a query.

 

Output

For each test cases,for each query print the answer in one line.

 

Sample Input

  
  

   
   1
10
8 2 4 9 5 7 10 6 1 3
5
2 10
2 4
6 9
1 4
7 10
  
  

 

Sample Output

  
  

   
   5
2
2
4
3
  
  

 

题意：

有n（n最大为50000）个数，有m（m最大为50000）个询问，每个询问的两个数l，r表示求[l, r]内的数中任意两个数能得到的最大公约数

思路：

线段树离线处理：以下内容为转载（原文：点击打开链接）

        询问【L,R,max_gcd(x,y)】，区间内任意两个值的最大gcd。这样的话，如果每来一个查询我就处理的话那就很难降低复杂度，是采用离线处理的思想，我们首先将所有的查询全部读入，然后将查询按右端点排序（为什么按照右端点排序呢，前往下看）。   
        要求区间内任意两个点的gcd的最大值，对于这个问题，如果不做一些预处理，我们是不能有效的进行操作的，因为这个问题不是像区间极值哪些问题具有合并性的。所以我们要考虑gcd的特征，两个数的gcd一定是这两个数的因子，这样的话我们就能处理出每个数的因子，通过判断这两个数是否有公因子来更新答案（公因子比之前维护的ans大）。那么我们现在可以捋一捋所知信息：对于一个区间，我们能否通过某种方法查看这个区间内各个数字的因子，然后判断出最大的公因子即为所求。那么假设现在i位置的数字为a[i],那么如果a[i]具有因子x，如果某个位置a[j]也具有因子x，那么区间[i,j]至少拥有这样的gcd为x，如果x大于当前的ans，那么我们就可以更新答案了。    
        根据上述信息，我们维护一颗线段树，线段树维护的值是区间内最大的gcd。首先我们预处理所有数字的因子，然后我们将排序过后的区间从左到右依次处理（为了加强理解，设定k<i<j），每扫描一个值a[i],我们查看a[i]的所有因子，对于某一个因子x，如果之前有某个值a[k]也存在这样的因子x，那么就可以更新区间[k,i]（这个非常关键），然后这个x也可能会更新后面的某个区间[i,j]（假设a[j]包含因子x）。接着我们考虑数组pre[x]代表x这个因子上一次（最近一次）出现的位置（即某个数值包含因子x），如果没有出现过就标记为-1，如果之前处理了所有的pre[x]，那么我们枚举每个数值的因子，就可以根据pre数组判断能否更新区间[pre[x], now_postion]，那么对于查询[l , r]只要它在[pre[x], now_postion]中，那么就可以更新线段树的值。那么对于按右端点排序好的查询，如果在不断update的过程中遇到了查询的右端点，那么我们就可以做查询即可。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define N 50005
#define MAX(x, y) ((x)>(y)?(x):(y))
using namespace std;
int a[N];
int pre[N];
int ans[N];
vector<int>fac[N];

typedef struct{
    int l, r, id;
}Input;

Input in[N];

bool cmp(Input a, Input b)
{
    return a.r < b.r;
}

void Init()
{
    int i, j;
    for(i = 1; i < N; i++)
        for(j = i; j < N; j += i)
            fac[j].push_back(i);
}

struct LineTree{
    void Push_up(int rt)
    {
        T[rt].Max = MAX(T[rt<<1].Max, T[rt<<1|1].Max);
    }
    void Build(int rt, int l, int r)
    {
        T[rt].l = l;
        T[rt].r = r;
        T[rt].Max = 0;
        if(l == r) return;
        T[rt].mid = ((l + r)>>1);
        Build(rt<<1, l, T[rt].mid);
        Build(rt<<1|1, T[rt].mid + 1, r);
    }
    void Update(int rt, int pos, int val)
    {
        if(T[rt].l == pos && T[rt].r == pos){
            if(val > T[rt].Max) T[rt].Max = val; 
            return;
        }
        if(pos <= T[rt].mid) Update(rt<<1, pos, val);
        else Update(rt<<1|1, pos, val);
        Push_up(rt);
    }
    int Query(int rt, int l, int r)
    {
        if(l == T[rt].l && r == T[rt].r) return T[rt].Max;
        if(r <= T[rt].mid) return Query(rt<<1, l, r);
        else if(l > T[rt].mid) return Query(rt<<1|1, l, r);
        else return MAX(Query(rt<<1, l, T[rt].mid), Query(rt<<1|1, T[rt].mid + 1, r));
    }
    typedef struct{
        int l, mid, r, Max;
    }Node;
    Node T[N<<2];
};

LineTree tree;

int main()
{
    //freopen("in.txt","r",stdin);
    Init();
    int T;
    scanf("%d", &T);
    while(T--){
        int n, m, i, j, k;
        scanf("%d", &n);
        tree.Build(1, 1, n);
        for(i = 1; i <= n; i++)
            scanf("%d", a + i);
        scanf("%d", &m);
        for(i = 0; i < m; i++){
            scanf("%d%d", &in[i].l, &in[i].r);
            in[i].id = i;
        }
        sort(in, in + m, cmp);
        memset(pre, 0, sizeof(pre));
        for(i = 1, j = 0; i <= n && j < m; i++){
            for(k = 0; k < fac[a[i]].size(); k++){
                int tmp = fac[a[i]][k];
                if(pre[tmp])
                    tree.Update(1, pre[tmp], tmp);
                pre[tmp] = i;
            }
            while(j < m && in[j].r == i){
                ans[in[j].id] = tree.Query(1, in[j].l, i);
                j++;
            }
        }
        for(i = 0; i < m; i++)
            printf("%d\n", ans[i]);
    }
    return 0;
}