POJ 3696 The Luckiest Number【欧拉函数+快速幂+快速乘】

最新推荐文章于 2019-08-25 20:00:26 发布

神探小小迪

最新推荐文章于 2019-08-25 20:00:26 发布

阅读量274

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数学数论算法竞赛进阶指南数据结构

本文链接：https://blog.youkuaiyun.com/qq_37867156/article/details/83048932

数据结构同时被 3 个专栏收录

155 篇文章

订阅专栏

算法竞赛进阶指南

41 篇文章

订阅专栏

数学

24 篇文章

订阅专栏

本文探讨了一个有趣的数学问题：如何找到最小的正整数，该数是特定幸运数L的倍数，并且仅由数字8组成。通过分析和使用欧拉定理，文章详细解释了求解过程，包括如何确定目标数字的长度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

Sample Output

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

题解：P143。 设x个8连在一起是L的倍数，由题意可知，长度为x全8序列为：8*(10^x-1)/ 9 = L * p，即（10^x-1）=9 * L * p/8。令m=9 * L/gcd(L,8),则存在p'，使9 * L * p/8=m * p'，方程转换为(10^x-1)=m * p'，即求同余方程10^x≡1（mod m）的最小解。

根据欧拉定理可知，10^Φ（m）≡ 1（mod m），而我们要求的是最小的解，所以答案肯定是Φ（m）的因子，所以只需要枚举Φ（m）的因子，然后检查模值是否为1即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define ll long long
using namespace std;
const int maxn = 1000010;
ll L, fact[maxn], p;
ll gcd(ll a, ll b){
    return b ? gcd(b, a%b) : a;
}
ll multi(ll a, ll b, ll c){
    ll res = a, ans = 0;
    while(b){
        if(b & 1) ans = (ans + res) % c;
        res = (res + res) % c;
        b >>= 1;
    }
    return ans;
}
ll quick_pow(ll a, ll b, ll c){
    ll ans = 1, res = a % c;
    while(b){
        if(b & 1) ans = multi(ans, res, c);
        res = multi(res, res, c);
        b >>= 1;
    }
    return ans;
}
ll phi(ll n){
    ll ans = n;
    for(ll i = 2; i*i <= n; i++){
        if(n % i == 0){
            ans = ans / i * (i-1);
            while(n % i == 0) n /= i;
        }
    }
    if(n > 1) ans = ans / n * (n-1);
    return ans;
}
int main()
{
    int cnt = 0;
    while(~scanf("%lld", &L) && L){
        int m = 0;
        ll d = gcd(L, 8);
        p = L * 9 / d;
        ll n = phi(p);
        for(ll i = 1; i*i <= n; i++){
            if(n % i == 0){
                fact[m++] = i;
                if(i != n/i) fact[m++] = n/i;
            }
        }
        sort(fact, fact+m);
        int flag = 0;
        for(int i = 0; i < m; i++){
            if(quick_pow(10, fact[i], p) == 1){
                flag = 1;
                printf("Case %d: %lld\n", ++cnt, fact[i]);
                break;
            }
        }
        if(!flag) printf("Case %d: 0\n", ++cnt);
    }
    return 0;
}