hdu 1395(欧拉函数)

2^x mod n = 1

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 15810    Accepted Submission(s): 4914

Problem Description

Give a number n, find the minimum x(x>0) that satisfies 2^x mod n = 1.

 

Input

One positive integer on each line, the value of n.

 

Output

If the minimum x exists, print a line with 2^x mod n = 1.

Print 2^? mod n = 1 otherwise.

You should replace x and n with specific numbers.

 

Sample Input

2
5

 

Sample Output

2^? mod 2 = 1 2^4 mod 5 = 1

这里提供两种方法来做，暴力或者欧拉函数。但是暴力我感觉的话数据量大一点可能就AC不了了。

暴力做法(大一的时候写的)：

#include<math.h>
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
int n=;
int quick_pow_mod(int a,int b,int c)
{
    int ans=;
    while(b>)
    {
        if(b&)
            ans=(a*ans)%c;
        b=b>>;
        a=(a*a)%c;
    }
    return ans;
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int flag=,t,k;
        if(n%== || n==) printf("2^? mod %d = 1\n",n);   //n=1！！！！！！！！
        else
        {
            for(int i=; ; i++)
            {
                k=quick_pow_mod(,i,n);
                if(k==)
                {
                    t=i;
                    flag=;
                    break;
                }
            }
            if(flag)
                printf("2^? mod %d = 1\n",n);
            else printf("2^%d mod %d = 1\n",t,n);
        }

    }
}

欧拉函数:

用φ(n)表示不大于n且与n互素的数的个数，该函数以欧拉的名字命名，称为欧拉函数。

      如果n是一个素数，即n = p，那么φ(n) = p-1（所有小于n的都互素）；

      如果n是素数的k次幂，即n = p^k，那么φ(n) = p^k - p^(k-1) （除了p的倍数其它都互素）；

      如果m和n互素，那么φ(mn) = φ(m)φ(n)（可以利用上面两个性质进行推导）。

      将n分解成如图二-4-1的素因子形式，那么利用上面的定理可得φ(n)

aaarticlea/png;base64,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" alt="" />

欧拉定理：若n,a为正整数，且n,a互素，则: aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAH8AAAAkCAIAAAAvlnJwAAADs0lEQVRoge2Zy4HbIBCGOXDkTAFUQAmUMDVMDVRBEZRBFdQxbZDDZCcEgWJ7tUvi6D9ZCAn4mBeyarf2Se2ewH+tm/5O3fR36qa/Uzf9nbrp79RNf6eupE9ET7Xfuox+jPHlu/+trqFPRABw0iHGmHO+ZKx30jX0AeAcLhE55y4Z6530HP0YY0qJiFJKMUZrbSmltWaMqbVyn5SStba1lnO21kq71vrSmS8lI36Rcs4ppUsm8wR9AODwHUJg6IgYQmitKfXzPUSUc3bOpZRKKdZaSbn9Dn1SpRTv/fQWIn5pko8xaq3ZvB7sf7LqR+kTESMmImMMNyIi70dv173JS8/WmnOO9+wzqrUCgHNO9rtXKeU8/VyiEMLj9FtrJyH3UfqlFEaccxa7c84x5Z4FADCCwUL7KPRJ5Zyn9C/Z4D8KAJ6lv0qKz9k+ESEiIrbWOPTzXa21+Lsg4J593L8qJkzpE9H3pJZn6ccYOT4ftaTPMd1aa4xhmuzXzjlETCn1++m9F6OTmYUQ+jjQR6Feda3V3Kb0Y4y9j5dSQgha61orRyrnHBGVUowxSqlj5kBEAPDeH6211hpCcM4ZY4wxR/qIKKMjIo8rM1mZxZx+CIHTeq11WKdEmwHH+XmqlMIecxSvdqrV26b0Qwi9iRFRCEEpFUKotTICay0A1Fr5Df2UvPdiKyklpZRsAGeynsBAHxF5FRwb+HGhJGHjuJB57pKVp5QGCqttPE931ybDKX3n3DAKU5BL733vf8YYMf9SygCInZ5/a617V5hGHnZ0SXgDJaXUNCFN6HvvpZ49Lmma7tpHAJneYn+f3mofpjTV6pEpfWvt4F4DfQAYajChj4jDCwGAW44bM6XfT3iIga213pN+a580fQwWYxweO+f4smihVf+V7b9MX1iLZD+GMNIW9JVSYrLe+2Emj9q+VA6lFKb/F36hfCTut2foD4Ge38b2y5lvyBADffYPudRaD6yH/fvVPlzzi7ia5EXyqfX45FXiCDvV6hGGNZhFX3Ww2HrkEgD6cDwk9j50sAkKLy6Z+BMLn3WHsN4PzTm2/6o47E2vSasxhreac/03nF+eEiJaa7lk7AutWuvxyM3dhJpSitMY89Va90bNFTYAcJnUD8rFq9aas6sxpvezEILMhCva3o1ijKvvIm/139aFn5IuVF/FDHor+iml1alio06Kt7ei31pbnel3afgoMOjd6H9RTfyyzv90ejf6/5Zu+jt109+pm/5O3fR36qa/Uzf9nfoBDN+7krIAbekAAAAASUVORK5CYII=" alt="" />

但是我们求出的欧拉函数并不是这个方程最小的解。它的解有可能在它的因子中,这个是可以证明的。这里就不详细证明了。分解因子然后得到最小的解。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
using namespace std;
typedef long long LL;
const int N = ;
bool p[N];
int euler[N];
int e[N];
void getEuler()
{
    memset(euler,,sizeof(euler));
    euler[] = ;
    for(int i = ; i <= N; i++)
        if(!euler[i])
            for(int j = i; j <= N; j+= i)
            {
                if(!euler[j])
                    euler[j] = j;
                euler[j] = euler[j]/i*(i-);
            }
}
int pow_mod(int a,int b,int mod)
{
    int ans = ;
    while(b)
    {
        if(b&) ans = ans*a%mod;
        a=a*a%mod;
        b>>=;
    }
    return ans;
}
int main()
{
    getEuler();
    int n;
    while(~scanf("%d",&n))
    {
        if(n%&&n!=)
        {
            int m = euler[n];
            memset(e,,sizeof(e));
            int id=;
            e[id++] = m;
            for(int i=; i*i<=m; i++) ///分解出m所有的因子
            {
                if(m%i==)
                {
                    if(i*i==m) e[id++] =i;
                    else
                    {
                        e[id++]=i;
                        e[id++]=m/i;
                    }
                }
            }
            sort(e,e+id);
            int ans = m;
            for(int i=; i<id; i++)
            {
                if(pow_mod(,e[i],n)==)
                {
                    ans = e[i];
                    break;
                }
            }
            printf("2^%d mod %d = 1\n",ans,n);
        }
        else printf("2^? mod %d = 1\n",n);
    }
    return ;
}