HDU 4777 Rabbit Kingdom

Rabbit Kingdom

Time Limit: 3000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 4777
64-bit integer IO format: %I64d      Java class name: Main

　　Long long ago, there was an ancient rabbit kingdom in the forest. Every rabbit in this kingdom was not cute but totally pugnacious, so the kingdom was in chaos in season and out of season.
　　n rabbits were numbered form 1 to n. All rabbits' weight is an integer. For some unknown reason, two rabbits would fight each other if and only if their weight is NOT co-prime.
　　Now the king had arranged the n rabbits in a line ordered by their numbers. The king planned to send some rabbits into prison. He wanted to know that, if he sent all rabbits between the i-th one and the j-th one(including the i-th one and the j-th one) into prison, how many rabbits in the prison would not fight with others.
　　Please note that a rabbit would not fight with himself.

 

Input

　　The input consists of several test cases.
　　The first line of each test case contains two integer n, m, indicating the number of rabbits and the queries.
　　The following line contains n integers, and the i-th integer Wi indicates the weight of the i-th rabbit.
　　Then m lines follow. Each line represents a query. It contains two integers L and R, meaning the king wanted to ask about the situation that if he sent all rabbits from the L-th one to the R-th one into prison.
　　(1 <= n, m, Wi <= 200000, 1 <= L <= R <= n)
　　The input ends with n = 0 and m = 0.

 

Output

　　For every query, output one line indicating the answer.

 

Sample Input

3 2
2 1 4
1 2
1 3
6 4
3 6 1 2 5 3
1 3
4 6
4 4
2 6
0 0

Sample Output

2
1
1
3
1
2

Hint

　　In the second case, the answer of the 4-th query is 2, because only 1 and 5 is co-prime with other numbers in the interval [2,6] .

 

Source

2013 Asia Hangzhou Regional Contest

 

解题：首先我们需要处理各数距离它左边最近和右边最近的与其不互质的数

1. $nxt[p]记录最新的含有p因子的数的位置$
2. $然后分解当前数的因子，就可以找出上个含有p因子的数的位置$
3. $然后就可以更新上个数的最近的右边不互质数的位置已经当前数左边最近的不互质数的位置$

接下来就是利用树状数组更新

1. 对所有左边界为i的数，我们可以把他们对应的位置上加1
2. 然后对应位置的右边界减去1，因为如果超过右边界，那么对应位置这个数就不应该算进去，所以要减1
3. 用MS C++交，G++爆内存，奶奶的

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn = 200010;
struct QU {
    int L,R,id;
    bool operator<(const QU &rhs)const {
        return L < rhs.L;
    }
} Q[maxn];
int C[maxn],L[maxn],R[maxn],nxt[maxn],d[maxn],ans[maxn],n,m;
vector<int>fac[maxn];
vector<int>Ls[maxn];
void init() {
    for(int i = 2; i <= 200000; ++i)
        for(int j = i; j <= 200000; j += i)
            fac[j].push_back(i);
}
int sum(int i,int ret = 0) {
    while(i > 0) {
        ret += C[i];
        i -= i&-i;
    }
    return ret;
}
void add(int i,int val) {
    while(i <= n) {
        C[i] += val;
        i += i&-i;
    }
}
void solve() {
    for(int i = 0; i <= n; ++i) Ls[i].clear();
    sort(Q,Q + m);
    memset(C,0,sizeof C);
    memset(L,0,sizeof L);
    memset(R,0,sizeof R);
    memset(nxt,0,sizeof nxt);
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < fac[d[i]].size(); ++j) {
            int p = fac[d[i]][j];
            if(!nxt[p]){
                nxt[p] = i;
                continue;
            }
            if(!R[nxt[p]]) R[nxt[p]] = i;
            if(L[i] < nxt[p]) L[i] = nxt[p];
            nxt[p] = i;
        }
        Ls[L[i]].push_back(i);
    }
    for(int i = 0,cur = 0; i <= n; ++i){
        while(Q[cur].L == i){
            ans[Q[cur].id] = sum(Q[cur].R) - sum(Q[cur].L - 1);
            ++cur;
        }
        for(int j = 0; j < Ls[i].size(); ++j){
            add(Ls[i][j],1);
            if(R[Ls[i][j]]) add(R[Ls[i][j]],-1);
        }
        if(R[i]) add(R[i],1);
    }
    for(int i = 0; i < m; ++i)
        printf("%d
",ans[i]);
}
int main() {
    init();
    while(scanf("%d%d",&n,&m),n||m) {
        for(int i = 1; i <= n; ++i) scanf("%d", d + i);
        for(int i = 0; i < m; ++i) {
            scanf("%d%d",&Q[i].L,&Q[i].R);
            Q[i].id = i;
        }
        solve();
    }
    return 0;
}