NOIP2005普及组第4题循环

时间限制: 1 Sec 内存限制: 128 MB
提交: 27 解决: 6
[提交][状态][讨论版][命题人:外部导入]

题目描述

乐乐是一个聪明而又勤奋好学的孩子。他总喜欢探求事物的规律。一天，他突然对数的正整数次幂产生了兴趣。

众所周知，2的正整数次幂最后一位数总是不断的在重复2，4，8，6，2，4，8，6……我们说2的正整数次幂最后一位的循环长度是4（实际上4的倍数都可以说是循环长度，但我们只考虑最小的循环长度）。类似的，其余的数字的正整数次幂最后一位数也有类似的循环现象：

循环

循环长度

数字	循环	循环长度
2	2、4、8、6	4
3	3、9、7、1	4
4	4、6	2
5	5	1
6	6	1
7	7、9、3、1	4
8	8、4、2、6	4
9	9、1	2

这时乐乐的问题就出来了：是不是只有最后一位才有这样的循环呢？对于一个整数n的正整数次幂来说，它的后k位是否会发生循环？如果循环的话，循环长度是多少呢？

注意：

1．如果n的某个正整数次幂的位数不足k，那么不足的高位看做是0。

2．如果循环长度是L，那么说明对于任意的正整数a，n的a次幂和a + L次幂的最后k位都相同。

输入

只有一行，包含两个整数n（1 <= n < 10100）和k（1 <= k <= 100），n和k之间用一个空格隔开，表示要求n的正整数次幂的最后k位的循环长度。

输出

包括一行，这一行只包含一个整数，表示循环长度。如果循环不存在，输出-1。

【数据规模】

对于30%的数据，k <= 4；

对于全部的数据，k <= 100。

样例输入

32 2

样例输出

提示

题目类型：高精度乘法+规律。

分析：一般来说遇到这种问题，像10^100这样的数据范围，不是高精度就是另有规律可循。这是一个循环结问题，以往有遇到打表找规律的这种问题，极容易被忽悠。

WA点：

答案有可能存在long long int保存不下的情况，需要用数组保存。并且过程需要高精度高乘。
既需要高精度低乘，又需要高精度高乘，在数组拷贝的过程中极可能出现失误。
单组输入

TLE点：

在数组的比较过程中，可以用O(1)的时间复杂度解决，而不必O(100)。

高精度高乘：大数与大数相乘，数组乘数组实现。

高精度低乘：大数与整数（较小）相乘，数字乘数字实现。

规律：当后K为数字存在循环结的必要条件是，后K-1位数字存在循环结，并且K的最小循环结必定是K-1的最小循环结的整数倍。并且对于当前位数的处理不必要取模，既然已经用了数组高精度保存便可以只考虑当前位数。在比较时，显然后K-1位已经按照之前的循环结递推过来必定相同，我们只需要比较倒数第K位是否相等即可。

技巧：关于查找循环结上限的问题，当前位数出现可能是0,1,2,3,4,5,6,7,8,9，在10次之内必定会出现与第一次相同的情况，当前次数*K-1的循环结即可得到K的循环结。如果10之内未能出现，那肯定就不存在了。

解析：我直接举一个例子进行说明吧：111 3（由于1的循环长度就是1，所以我直接从末两位循环开始）

我们来看111的末两位循环：

111 -> 321 -> 631 -> 041 -> 551 -> 161 -> 871 -> 681 -> 591 -> 601 -> 711

711处末两位出现循环，循环长度为10，循环节为11-> ...-> 01

现在我们再来看末三位循环：

111->...->601 (10个数)

711->...->201 (201就是601^2的末三位)

311->...->801 (801就是601^3的末三位)

911->...->401 (401就是601^4的末三位)

511->...->001 (001就是601^5的末三位)

111->...->601 (601就是601^6的末三位)

末三位的循环长度就是5*10=50；

好了，现在来讲具体的做法，并假设我们现在求数字n的后k位循环。

朴素的做法就是直接求n^2,n^3,n^4.。。。，并判断是否出现循环。但观察上面的演示例子，我们发现可以不必这样，以n=111为例，末两位循环节长度为10，即表示n与（n^10）*n的末两位是相同的。对于末三位的循环，肯定是（m*n^10），即m*(n^10)与n^10的末三位是相同的，m*（n^10）*n的末三位与n相同。于是，计算末三位循环的时候，我们就直接将n^10作为第一个数，然后每次乘n^10，共乘5次，末三位出现循环，即m=5，所以末三位循环街长度就为5*10=50。

#include<iostream>

#include<cstring>

#include<cstdio>

#include<string>

#include<algorithm>

using namespace std;

string s;

int m, k; int i, j; int a[], aans[], n[], ans[], last[], now[], t[];

int single_j[] = { ,,,,,,,,, };//单循环结

void init()

{

    memset(a, , sizeof a); memset(last, , sizeof last);

    memset(aans, , sizeof aans); memset(now, , sizeof now);

    memset(ans, , sizeof ans); memset(n, , sizeof n); memset(t, , sizeof t);

    //for (int i = 1;; i++) { if (m == 0) break; n[i] = m % 10; m /= 10; }//将m存入数组n，以便于高精度

}

void multiplyh(int x[], int y[], int z[])

{//高精度高乘

    int up = ;

    for (int ii = ; ii <= k; ii++)

    {

        for (j = ; j <= k; j++)

        {

            z[ii + j - ] += (x[j] * y[ii] + up) % ;

            up = (x[j] * y[ii] + up) / ;

        }

        up = ;

    }

    for (int ii = ; ii <= k; ii++) {//进位

        z[ii + ] += z[ii] / ;

        z[ii] %= ;

    }

}

void multiplyl(int x[], int yy, int z[])

{//高精度低乘

    int up = ;

    for (int ii = ; ii <= k; ii++)

    {

        z[ii] = (x[ii] * yy + up) % ;

        up = (x[ii] * yy + up) / ;

    }

}

int main()

{

    //scanf("%d%d", &m, &k);

    init();

    cin >> s;

    cin >> k;

    int temp = , len = s.size();

    for (i = len - ; i >= len - k; i--)

        n[++temp] = s[i] - '';

    int tmp = ;

    for (int i = ; i <= k; i++) ans[i] = n[i];

    for (int i = ; i < single_j[n[]]; i++)

    {

        memset(aans, , sizeof aans);

        multiplyh(ans, n, aans);

        for (int j = ; j <= k; j++) { ans[j] = aans[j]; }//更新为第一次出现末尾循环节的状态

    }

    t[] = single_j[n[]];//最低位的循环结

    for (int i = ; i <= k; i++) now[i] = ans[i];

    int pos = ;//当前倒数位数

    while (pos <= k)

    {

        for (int j = ; j <= k; j++)

        {

            ans[j] = n[j];

            last[j] = now[j];

        }

        tmp = ;

        while (tmp < )

        {

            tmp++;

            memset(aans, , sizeof aans);

            multiplyh(ans, now, aans);

            for (j = ; j <= k; j++)

            {

                ans[j] = aans[j];

            }

            if (ans[pos] == n[pos]) break;//找到循环结

            memset(aans, , sizeof(aans));

            multiplyh(last, now, aans);//更新last

            for (j = ; j <= k; j++) last[j] = aans[j];

        }

        if (tmp >= ) { cout << -; return ; }

        for (int j = ; j <= k; j++) now[j] = last[j];

        memset(aans, , sizeof aans);

        multiplyl(t, tmp, aans);//更新循环节数组

        for (int i = ; i <= ; i++)  t[i] = aans[i];

        pos++;

    }

    int flag = ;//不输出前导0

    for (int i = ; i >= ; i--)

    {

        if (t[i]) flag = ;

        if (flag) cout << t[i];

    }

    return ;

}