HDU 2462 The Luckiest number

The Luckiest number

Time Limit: 1000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 2462
64-bit integer IO format: %I64d      Java class name: Main

Chinese people think of '8' as the lucky digit. Bob also likes digit '8'. Moreover, Bob has his own lucky number L. Now he wants to construct his luckiest number which is the minimum among all positive integers that are a multiple of L and consist of only digit '8'.

 

Input

The input consists of multiple test cases. Each test case contains exactly one line containing L(1 ≤ L ≤ 2,000,000,000).

The last test case is followed by a line containing a zero.

 

Output

For each test case, print a line containing the test case number( beginning with 1) followed by a integer which is the length of Bob's luckiest number. If Bob can't construct his luckiest number, print a zero.

 

Sample Input

8
11
16
0

Sample Output

Case 1: 1
Case 2: 2
Case 3: 0

Source

2008 Asia Hefei Regional Contest Online by USTC

 

解题：

首先，由题意可以得出，(10^x - 1)/ 9 * 8 = L * p(p是一个未知数，但必定是整数)。

           然后对上式进行移项处理，得：(10^x - 1) = 9 * L * p / 8。

           设m = 9 * L / gcd(L, 8)，则有(10^x - 1) = m * p'。p’是必然存在的一个整数。

           然后问题就转化成为了 10^x = 1(mod m)，观察此式，显然，m和10必定互质。

           于是根据欧拉定理，10^(Euler(m)) = 1(mod m) 。由于题目要求最小的解，解必然是Euler(m)的因子。

转自 OK_again

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int maxn = 400110;
LL mul(LL a, LL b, LL mod) {
    LL ret = 0;
    while(b) {
        if(b&1) ret = (ret + a) % mod;
        a = (a<<1)%mod;
        b >>= 1;
    }
    return ret;
}
LL quickPow(LL base,LL index,LL mod){
    LL ret = 1;
    while(index){
        if(index&1) ret = mul(ret,base,mod);
        index >>= 1;
        base = mul(base,base,mod);
    }
    return ret;
}
bool np[maxn] = {true,true};
int p[maxn],tot;
void init(){
    for(int i = 2; i < maxn; ++i){
        if(!np[i]) p[tot++] = i;
        for(int j = 0; j < tot && p[j]*i < maxn; ++j){
            np[p[j]*i] = true;
            if(i%p[j] == 0) break;
        }
    }
}
LL Euler(LL n){
    LL ret = n;
    for(int i = 0; (LL)p[i]*p[i] <= n; ++i){
        if(n%p[i] == 0){
            ret = ret/p[i]*(p[i] - 1);
            while(n%p[i] == 0) n /= p[i];
        }
    }
    if(n > 1) ret = ret/n*(n-1);
    return ret;
}
vector<int>F;
void Fn(LL n){
    F.clear();
    for(int i = 0; i < tot && n > 1; ++i){
        while(n%p[i] == 0){
            n /= p[i];
            F.push_back(p[i]);
        }
    }
    if(n > 1) F.push_back(n);
}
int main(){
    init();
    LL L;
    int cs = 1;
    while(scanf("%I64d",&L),L){
        LL m = 9*L/__gcd(L,8LL);
        if(__gcd(m,10LL) != 1){
            printf("Case %d: 0
",cs++);
            continue;
        }
        LL x = Euler(m);
        Fn(x);
        for(auto it:F)
            if(quickPow(10,x/it,m) == 1) x /= it;
        printf("Case %d: %I64d
",cs++,x);
    }
    return 0;
}