給定有理數P/Q，求它的二進制小數的循環節長度。
先把這個分數化為既約分數，則循環節開始的位置M是使滿足2^M | Q的最大M。令Q1=Q/2^M,則循環節的長度就是求最小的N使2^N模Q1為1。這個問題好像沒有有效的解法（關于Q1的位數為多項式級別）。由于2和Q1互素，可以用歐拉定理來解。即2^phi（Q1）對Q1同余1。所求的N一定是phi（Q1）的一個因子，先分解Q1，再分解phi（Q1），遞歸枚舉phi（Q1）的所有因子，快速取冪算之，找到最小的滿足要求的phi（Q1）的因子即為所求。
只是異常繁瑣，而且分解因子要生成素數表，對時空要求都較高，不知有什么更佳的辦法。
/**//*Problem: 3358 User: y09shendazhi
Memory: 3620K Time: 47MS
Language: C++ Result: Accepted
Source Code */
#include <iostream>
#include<algorithm>
using namespace std;
__int64 PrimeFactor[100];//因子
__int64 Cnt;
__int64 P,Q;
__int64 ans1,ans2;//輸出結果
__int64 Factor;//遞歸尋找因子的時候用到
const __int64 INF=1000000000000000;
const __int64 MAXN=400000;
__int64 isCom[MAXN];//
__int64 Prime[MAXN];//素數表
void getPrime()//線性生成400000以內的素數
{
__int64 num=0;
__int64 i,j;
__int64 temp=0;
for(i=2;i<MAXN;i++)
{
if(!isCom[i])
Prime[num++]=i;
for(j=0;j<num&&(temp=i*Prime[j])<MAXN;j++)
{
isCom[temp]=1;
if(!(i%Prime[j]))
break;
}
}
}
__int64 FastPower(__int64 radix,__int64 n,__int64 mod)//遞歸實現快速取模
{
if(n==1)
return radix%mod;
if(n==0)
return 1;
__int64 c=FastPower(radix,n>>1,mod);
return (1&n)==1?(radix*c*c)%mod:(c*c)%mod;
}
__int64 Gcd(__int64 a,__int64 b)//最大公因數
{
if(a==0)
return b;
return Gcd(b%a,a);
}
__int64 cmp(__int64 a,__int64 b){return a>b;}//排序的比較函數
void getPrimeFactor()//得到歐拉函數素因子分解式
{
__int64 temp=Q;
__int64 i,j;
//分解分母
for(i=0;Prime[i]*Prime[i]<=temp;i++)
{
if(temp%Prime[i]==0)
{
PrimeFactor[Cnt++]=Prime[i];
while(temp%Prime[i]==0)
{
temp/=Prime[i];
isCom[Prime[i]]++;
}
}
}
if(temp!=1)
{
PrimeFactor[Cnt++]=temp;
isCom[temp]++;
}
//分解分母的歐拉函數值
__int64 count=Cnt;
for(i=0;i<count;i++)
{
isCom[PrimeFactor[i]]--;
__int64 copy=PrimeFactor[i];
if(isCom[PrimeFactor[i]]==0)
PrimeFactor[i]=0;
copy--;
for(j=0;Prime[j]*Prime[j]<=copy;j++)
{
if(copy%Prime[j]==0)
{
if(isCom[Prime[j]]==0)
{
PrimeFactor[Cnt++]=Prime[j];
}
while(copy%Prime[j]==0)
{
copy/=Prime[j];
isCom[Prime[j]]++;
}
}
}
if(copy!=1)
{
if(isCom[copy]==0)
PrimeFactor[Cnt++]=copy;
isCom[copy]++;
}
}
//對因子排序，由大到小
sort(PrimeFactor,PrimeFactor+Cnt,cmp);
Cnt=0;
while(PrimeFactor[++Cnt]);
}
void solve(__int64 depth)//遞歸尋找因子，各個計算
{
if(depth==Cnt)
{
if(Factor<ans2)
{
if(FastPower(2,Factor,Q)==1)
ans2=Factor;
}
return ;
}
solve(depth+1);
for(__int64 i=1;i<=isCom[PrimeFactor[depth]];i++)
{
for(__int64 j=1;j<=i;j++)
Factor*=PrimeFactor[depth];
solve(depth+1);
for(__int64 k=1;k<=i;k++)
Factor/=PrimeFactor[depth];
}
}
int main()
{
getPrime();
int t=0;
while(scanf("%I64d/%I64d",&P,&Q)!=EOF)
{
//變量初始化
for(__int64 i=0;i<Cnt;i++)
isCom[PrimeFactor[i]]=0;
memset(PrimeFactor,0,sizeof(PrimeFactor));
ans2=INF;
ans1=1;
Cnt=0;
Factor=1;
cout<<"Case #"<<++t<<": ";
P%=Q;
Q/=Gcd(P,Q);
while(!(1&Q))
{
Q>>=1;
ans1++;
}
//特殊情況
if(P==0)
{
cout<<"1,1 "<<endl;
continue;
}
else if(Q==1)
{
printf("%I64d,1 \n",ans1);
continue;
}
getPrimeFactor();//得到因子分解
solve(0);//遞歸求解
printf("%I64d,%I64d \n",ans1,ans2);//結果
}
return 0;
}