hdu5726 GCD

GCD

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2008    Accepted Submission(s): 660

Problem Description

Give you a sequence of  N(N≤100,000)  integers :  a1,...,an(0<ai≤1000,000,000) . There are  Q(Q≤100,000)  queries. For each query  l,r  you have to calculate  gcd(al,,al+1,...,ar)  and count the number of pairs (l′,r′)(1≤l<r≤N) such that  gcd(al′,al′+1,...,ar′)  equal  gcd(al,al+1,...,ar) .

 

Input

The first line of input contains a number  T , which stands for the number of test cases you need to solve.

The first line of each case contains a number  N , denoting the number of integers.

The second line contains  N  integers,  a1,...,an(0<ai≤1000,000,000) .

The third line contains a number  Q , denoting the number of queries.

For the next  Q  lines, i-th line contains two number , stand for the  li,ri , stand for the i-th queries.

 

Output

For each case, you need to output “Case #:t” at the beginning.(with quotes,  t  means the number of the test case, begin from 1).

For each query, you need to output the two numbers in a line. The first number stands for  gcd(al,al+1,...,ar)  and the second number stands for the number of pairs (l′,r′)  such that  gcd(al′,al′+1,...,ar′)  equal  gcd(al,al+1,...,ar) .

 

Sample Input

  
  

   
   1
5
1 2 4 6 7
4
1 5
2 4
3 4
4 4
  
  

 

Sample Output

  
  

   
   Case #1:
1 8
2 4
2 4
6 1
  
  

 

#include <cstdio>
#include <map>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <algorithm>

using namespace std;

const int maxn = 100000;
int f[maxn + 5][20], mm[maxn + 5];
int T, N, Q;
map<int, long long> m;

int gcd(int a, int b) {
    if (!b) return a;
    return gcd(b, a % b);
}

void initrmp()
{
    mm[0] = -1;
    for (int i = 1; i <= N; i++) {
        mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
    }
    for (int j = 1; j <= 18; 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 query(int l, int r) {
    int k = mm[r - l + 1];
    return gcd(f[l][k], f[r - (1 << k) + 1][k]);
}

void pre()
{
    int L, tmp, g;
    m.clear();
    for (int i = 1; i <= N; i++) {
        L = i;
        g = f[L][0];
        while (L <= N) {
            int l = L, r = N;
            while (l <= r) {
                int mid = (l + r) >> 1;
                if (query(i, mid) == g) {
                    tmp = mid;
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
            m[g] += (tmp - L + 1);
            L = tmp + 1; //debug
            g = gcd(g, f[L][0]);
        }
    }
}

int main()
{
    int cas = 0, ans;
    cin >> T;
    while (T--) {
        scanf("%d", &N);
        for (int i = 1; i <= N; i++) {
            scanf("%d", &f[i][0]);
        }
        initrmp();
        pre();
        scanf("%d", &Q);
        printf("Case #%d:\n", ++cas);
        while(Q--) {
            int l, r;
            scanf("%d%d", &l, &r);
            ans = query(l, r);
            printf("%d %I64d\n", ans, m[ans]); 
        }
    }
    return 0;
}