POJ-------2773

Description
Two positive integers are said to be relatively prime to each other if the Great Common Divisor (GCD) is 1. For instance, 1, 3, 5, 7, 9…are all relatively prime to 2006.

Now your job is easy: for the given integer m, find the K-th element which is relatively prime to m when these elements are sorted in ascending order.

Input
The input contains multiple test cases. For each test case, it contains two integers m (1 <= m <= 1000000), K (1 <= K <= 100000000).

Output
Output the K-th element in a single line.

Sample Input

2006 1
2006 2
2006 3

Sample Output

1
3
5
题意：给你一个数m和k，求出第k个与m互质的数。
分析：题目的时间要求为3000Ms所以想用纯暴力是不可能的了。
根据欧几里得的一个定理，如果a，b互素则b*t+a，b也互质。反正不互质。即gcd（a，b）==gcd（b*t+a，b）==1；
那么先求出小于m与m互质的数存入一个数组中，并且记录下个数。如果k%m!=0,那么这个数就为k/j*m+phi【k%j-1 】(此处j为小于m且与m互质的个数，phi为小于m且与m互质数的数组)
如果k%m==0，则为（k/j-1）*m+phi[j-1]

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int pri[1000000];
int gcd ( int a, int b )
{
    return b == 0 ? a : gcd ( b, a % b ) ;
}
int main()
{
    int m, k ;
    while ( cin >> m >> k )
    {
        int i, j ;
        for ( i = 1, j = 0 ; i <= m ; i ++ )
            if ( gcd ( m, i ) == 1 )
                pri [ j ++ ] = i ;

        if ( k%j != 0)
            cout <<k/j * m +pri[k%j-1] << endl;
        else//要特别考虑k%j=0的情况，因为数组是从0开始的，第i个对应的是pri[i-1]
            cout << (k/j-1)*m+pri[j-1] << endl ;
    }
    return 0;
}

上面的那个算法的时间复杂度较高2000+ms
下面有一个更简单的算法要用到容斥原理
具体思想还没弄太懂以后弄懂再补

    #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)));

        }
    }