POJ 2773：Happy 2006 - 第k大与n互素的数

题意：

给出n和k求出第k个与n互素的数

解法一：（效率较低 2235MS）

如果知道欧几里德算法的话就应该知道gcd（b×t+a，b）=gcd（a，b）  （t为任意整数）

则如果a与b互素，则b×t+a与b也一定互素；如果a与b不互素，则b×t+a与b也一定不互素

故与m互素的数对m取模具有周期性，则根据这个方法我们就可以很快的求出第k个与m互素的数

假设小于m的数且与m互素的数有k个，其中第i个是ai，则第m×k+i与m互素的数是k×m+ai

唉~！我就只能想到最慢的算法了。一定要学习更优的算法。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
int prime[1000000];

int gcd(int a,int b){
 return b==0?a:gcd(b,a%b);
}

int main(){
int m,k,num=0,ans,i;
while(~scanf("%d%d",&m,&k)){
num=0;
for(i=1;i<=m;i++)
if(gcd(m,i)==1)
prime[++num]=i;
if(!(k%num))
ans=m*(k/num-1)+prime[num];
else//要特别考虑k%j=0的情况，因为数组是从0开始的，第i个对应的是pri[i-1]  
ans=m*(k/num)+prime[k%num];
printf("%d\n",ans);
}
return 0;
}

解法二：（对解法一进行优化后 266MS）

参考：http://blog.csdn.net/wsniyufang/article/details/6668014

对m求欧拉函数的同时对m进行分解，求出m的所有素因子，所有与m不互素的数，都至少与m有一个公共素因子，于是，我们可以在每次找到一个m的素因子后，将它的整数倍标记，这样，后面枚举的时候就可以用O(1)的时间判断了

另外，这里，是经过类似优化后47ms的。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<ctime>
#include<map>
#include<vector>
using namespace std;
const int N=1000000;
int prime[801];//保存1000以内的素数
int num;//1000以内素数的个数
int isprime[1000001];
int flag[1000001];//flag[i]表示i是否与当前m互质
void getprime()//筛出素数
{
for(int i=2;i<=1000000;i++)if(isprime[i]==0)
{
prime[num++]=i;
for(int j=1;j*i<=1000000;j++)
isprime[j*i]=1;
}
}
int euler(int n)//求出n的欧拉函数并且筛出所有与其互质的数flag[i]==0表示n与i不互质
{
int nn=n;
int res=n;
for(int i=0;i<num&&prime[i]*prime[i]<=n;i++)
{
if(n%prime[i]==0)
{
res=res/prime[i]*(prime[i]-1);
while(n%prime[i]==0)
{
n/=prime[i];
}
for(int j=prime[i];j<=nn;j=j+prime[i])//所有prime[i]的倍数肯定与n不互质
{
flag[j]=1;
}
}
}
if(n>1)
{
res=res/n*(n-1);
for(int j=n;j<=nn;j+=n)
{
flag[j]=1;
}
}
return res;
}
int solve(int key)
{
int cnt=0;
for(int i=1;i<=1000001;i++)
{
if(flag[i]==0)
cnt++;
if(cnt==key)
return i;
}
}
int main()
{
int m,k;
getprime();
while(scanf("%d%d",&m,&k)!=EOF)
{
memset(flag,0,sizeof(flag));
if(m==1)
{printf("%d\n",k);continue;}
int f=euler(m);
int key=(k-1)%f+1;
printf("%I64d\n",(__int64)((k-1)/(f)*m+solve(key)));

}
}

解法三：（0ms轻松撸过的啊~~）

参考http://blog.csdn.net/muxidreamtohit/article/details/8034188
经典的二分加上容斥定理  

program：#include<iostream>

#include<stdio.h>
#define N 1005
using namespace std;
int n , k, K, cnt;
int mark[N + 10], prime[N];
int a[11];

void init()
{
    cnt = 0;
    for(int i = 2; i <= N; i++)
    {
        if(!mark[i])
        {
            prime[cnt++] = i;
            for(int j = 2 * i; j <= N; j += i)
            {
                mark[j] = 1;
            }
        }
    }
}

void getprime()
{
    int tmp = n;
    k = 0;
    for(int i = 0; i < cnt && prime[i] * prime[i] <= n; i++)
    {
        if(tmp % prime[i] == 0)
        {
            a[k++] = prime[i];
            while(tmp % prime[i] == 0)
            {
                tmp /= prime[i];
            }
        }
    }
    if(tmp != 1)
    {
        a[k++] = tmp;
    }
}

int judge(int num)
{
    int sum = 0;
    for(int i = 1; i < (1 << k); i++)
    {
        int tmp = 1;
        int t = 0;
        for(int j = 0; j < k; j++)
        {
            if((1 << j) & i)
            {
                t++;
                tmp = tmp * a[j];
            }
        }
        if(t % 2 == 1)
        {
            sum += num / tmp;
        }
        else
        {
            sum -= num / tmp;
        }
    }
    return num - sum;
}

int main()
{
    init();
    while(scanf("%d%d", &n, &K) != -1)
    {
        getprime();
        int l = 1, r = 1000000000, mid, ans;
        while(l <= r)
        {
            mid = (l + r) >> 1;
            int pt = judge(mid);
            if(pt >= K)
            {
                if(pt == K) ans = mid;
                r = mid - 1;
            }
            else
            {
                l = mid + 1;
            }
        }
        printf("%d\n", ans);
    }
}