HDU/HDOJ 1395 ACM浙大月赛 2^x mod n = 1

 

2^x mod n = 1

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

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
  
  

 

Author

MA, Xiao

 

Source

ZOJ Monthly, February 2003

 

做法要利用这样几个定理：

第一个是a^phi(m)%m=1

这个等式在m和a互质的时候一定成立

在这个题目中，因为a=2

所以m与a不互质，除非m为偶数

当然m=1的时候需要特殊处理下，这些都是小问题。

 

现在这个问题明了了，即在m为奇数(大于1)的时候一定有解。

那么就有人萌生了直接暴力的方法。当然对于这个题，直接暴力是可以的，我最先开始也是这样过的

但是今天重新做了一下这个题我仔细的思考了一下，发现果然有更加巧妙的方法来解决该类问题。

首先说暴力的缺点吧，大多数情况暴力其实还是非常快的，但是如果当m为一个非常大的质数，那么问题就严重了。因为质数的欧拉函数就是质数-1

那么也就是说，最坏情况下，我们可能要枚举很多次才能找到一个解

 

那么更为高效的方法是：把m的欧拉函数值，假设值为phi进行质因数分解

然后依次枚举phi的每一个因子，同时判断这个因子x是否满足2^x%m==1，不断更新一个最小值，最后得到答案。

那么为什么这样做就是对的呢？

首先需要知道：

a^x%m==1满足这个方程的最小x称为a对模m的指数。我们记做ordm(a)，如果ordm(a)==phi(m)则我们称a为模m的原根

有：a^X%m==1    <-===->    ordm(a)整除X

根据以上所说：a^phi(m)=1成立，那么phi(m)%ordm(a)==0也是成立的

所以ordm(a)就是phi的一个因子

所以分解phi然后枚举phi的因子的做法是正确的（恩，是有科学依据的。。哈哈）

 

我的代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#define inf 99999999
#define maxn 1000000

using namespace std;
typedef __int64 ll;

bool flag[maxn];
ll prime[maxn];

void init()
{
	ll i,j,num=0;
	for(i=2;i<maxn;i++)
	{
		if(!flag[i])
		{
			prime[num++]=i;
			for(j=i*i;j<maxn;j=j+i)
				flag[j]=true;
		}
	}
}

ll eular(ll n)
{
	ll i,res=1;
	for(i=2;i*i<=n;i++)
	{
		if(n%i==0)
		{
			res=res*(i-1);
			n=n/i;
			while(n%i==0)
			{
				res=res*i;
				n=n/i;
			}
		}
		if(n==1)
			break;
	}
	if(n>1)
		res=res*(n-1);
	return res;
}

ll exmod(ll a,ll b,ll n)
{
	ll ret=1;
	for(;b;b>>=1,a=a*a%n)
		if(b&1)
			ret=ret*a%n;
	return ret;
}

ll solve(ll n,ll fac[])
{
	ll i,num=0;
	for(i=0;prime[i]*prime[i]<=n;i++)
	{
		if(n%prime[i]==0)
		{
			n=n/prime[i];
			fac[num++]=prime[i];
			while(n%prime[i]==0)
			{
				n=n/prime[i];
				fac[num++]=prime[i];
			}
		}
		if(n==1)
			break;
	}
	if(n>1)
		fac[num++]=n;
	return num;
}

void getans(ll n,ll mod)
{
	ll fac[100],num,ans=n,i;
	bool loop=true;
	while(loop)
	{
		loop=false;
		num=solve(n,fac);
		for(i=0;i<num;i++)
		{
			if(exmod(2,n/fac[i],mod)==1)
			{
				loop=true;
				if(n/fac[i]<ans)
					ans=n/fac[i];
			}
		}
		n=ans;
	}
	printf("2^%I64d mod %I64d = 1\n",ans,mod);
}

int main()
{
	ll n,phi;
	init();
	while(scanf("%I64d",&n)!=EOF)
	{
		if(n%2==0||n==1)
		{
			printf("2^? mod %I64d = 1\n",n);
			continue;
		}
		phi=eular(n);
		getans(phi,n);
	}
	return 0;
}