hdu 5297 - Y sequence（ 2015 Multi-University Training Contest 1）容斥原理

Y sequence

Problem Description

Yellowstar likes integers so much that he listed all positive integers in ascending order,but he hates those numbers which can be written as a^b (a, b are positive integers,2<=b<=r),so he removed them all.Yellowstar calls the sequence that formed by the rest integers“Y sequence”.When r=3,The first few items of it are：
2,3,5,6,7,10……
Given positive integers n and r，you should output Y(n)(the n-th number of Y sequence.It is obvious that Y(1)=2 whatever r is).

Input

The first line of the input contains a single number T:the number of test cases.
Then T cases follow, each contains two positive integer n and r described above.
n<=2*10^18,2<=r<=62,T<=30000.

Output

For each case,output Y(n).

Sample Input

2
10 2
10 3

Sample Output

13
14
题意：去掉数列中可以开2次方，3次方…r次方的数，剩下的组成Y数列，问第n个数是多少
思路：首先我们可以很直观的想到，被删去的数显然是很分散的。因为能表示成某个数的幂这样的形式的数非常少。于是我们想到一个大致的思路——从n开始计算，首先计算1~n中实际上在Y数列里的数的个数t，然后答案至少要往后再加上n - t个数（被删去的数的个数），假设当前加到了m，再计算1~m中实际上在Y数列里的数的个数，假设为x个数，看x是不是等于n，如果小于n的话，让m加上n - x，再继续这样算 …… 直到加到某个数ans时，1~ans中实际上在Y数列里的个数恰好为N，此时ans即为答案。

思路想到这里，有两个问题需要明白。第一个，会不会加到超过正确答案呢？显然不会，因为每次加上的数都只是被删去的数的个数，而新加的数有可能还有被删去的，所以肯定不会超过n。第二个，会不会效率很低呢？当然也是不会的，因为被删去的数很分散，新加进来的数里面又含有的应该被删去的数相对于当前新加进来的数来说是很少很少的，所以效率是很高的。

那么问题只剩下一个了——如何快速求1~n里面有多少个数能表示成某个数的幂的形式。

我们这样想，首先删去所有的平方数。有n^(1/2)个。再删去所有的三次方数。有n^(1/3)个 …… 这样枚举幂数b（从2开始），然后删去n^(1/b)个数，但是有重复的，比如某个数的6次方可能被平方数删去了一次，又被3次方数删去了一次，于是想到用容斥原理加回来。这样，只需要枚举幂为质数的b的值。枚举质数b的时候，当b超过r就不再枚举。然后再用容斥求最后结果即可。当然，用pow函数是可以的，不过要注意精度。另外容斥的时候注意先不要把1算上去，最后答案减去1（因为1无论如何都是要被删的）即可。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
int prime[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67};  
int cnt[100]={19,0,1,1,1,1,2,1,1,1,2,1,2,1,2,2,1,1,2,1,2,2,2,1,2,1,2,1,2,1,3,1,1,2,2,2,2,1,2,2  
,2,1,3,1,2,2,2,1,2,1,2,2,2,1,2,2,2,2,2,1,3,1,2,2,1};  
long long considrt[6000000],nconsidrt;  
void GetConsider(int r)  
{  
    nconsidrt=0;  
    int i,j,sz;  
    for(i=0;prime[i]<=r;i++)  
    {  
        sz=nconsidrt;  
        for(j=0;j<sz;j++)  
        {  
            if(considrt[j]*prime[i]<=63)  
                considrt[nconsidrt++]=considrt[j]*prime[i];  
        }  
        considrt[nconsidrt++]=prime[i];  
    }  
}  

long long cal(long long x)  
{  
    long long ret(0);  
    for(int i=0;i<nconsidrt;i++)  
    {  
        if(cnt[considrt[i]]&1)  
            ret+=(long long)pow(x+0.5,1.0/considrt[i])-1;  
        else  
            ret-=(long long)pow(x+0.5,1.0/considrt[i])-1;  
    }  
    return x-ret-1;  
}  

long long solve(long long n,int r)  
{  
    GetConsider(r);  
    long long ans = n;  
    while(1)  
    {  
        long long temp = cal(ans);  
        if(temp == n)  
            break;  
        ans += n - temp;   
    }  
    return ans;  
}  
int main()  
{  
    int ncase,r;  
    long long n;  
    scanf("%d",&ncase);  
    while(ncase--)  
    {  
        scanf("%I64d%d",&n,&r);  
        printf("%I64d\n",solve(n,r));  
    }  
    return 0;  
}