NOIP2005普及组第4题循环

NOIP2005普及组第4题循环
NOIP2005普及组第4题循环
时间限制: 1 Sec 内存限制: 128 MB
提交: 27 解决: 6
[][][][命题⼈:外部导⼊]
题⽬描述
乐乐是⼀个聪明⽽⼜勤奋好学的孩⼦。

他总喜欢探求事物的规律。

⼀天，他突然对数的正整数次幂产⽣了兴趣。

众所周知，2的正整数次幂最后⼀位数总是不断的在重复2，4，8，6，2，4，8，6……我们说2的正整数次幂最后⼀位的循环长度是4（实际上4的倍数都可以说是循环长度，但我们只考虑最⼩的循环长度）。

类似的，其余的数字的正整数次幂最后⼀位数也有类似的循环现象：
循环
循环长度
数字循环循环长度
22、4、8、64
33、9、7、14
44、62
551
661
77、9、3、14
88、4、2、64
99、12
这时乐乐的问题就出来了：是不是只有最后⼀位才有这样的循环呢？对于⼀个整数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
样例输出
4
提⽰
题⽬类型：⾼精度乘法+规律。

分析：⼀般来说遇到这种问题，像10^100这样的数据范围，不是⾼精度就是另有规律可循。

这是⼀个循环结问题，以往有遇到打表找规律的这种问题，极容易被忽悠。

WA点：
1. 答案有可能存在long long int保存不下的情况，需要⽤数组保存。

并且过程需要⾼精度⾼乘。

2. 既需要⾼精度低乘，⼜需要⾼精度⾼乘，在数组拷贝的过程中极可能出现失误。

3. 单组输⼊
TLE点：
1. 在数组的⽐较过程中，可以⽤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[205], aans[205], n[205], ans[205], last[205], now[205], t[205];
int single_j[12] = { 1,1,4,4,2,1,1,4,4,2 };//单循环结
void init()
{
memset(a, 0, sizeof a); memset(last, 0, sizeof last);
memset(aans, 0, sizeof aans); memset(now, 0, sizeof now);
memset(ans, 0, sizeof ans); memset(n, 0, sizeof n); memset(t, 0, 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 = 0;
for (int ii = 1; ii <= k; ii++)
{
for (j = 1; j <= k; j++)
{
z[ii + j - 1] += (x[j] * y[ii] + up) % 10;
up = (x[j] * y[ii] + up) / 10;
}
up = 0;
}
for (int ii = 1; ii <= k; ii++) {//进位
z[ii + 1] += z[ii] / 10;
z[ii] %= 10;
}
}
void multiplyl(int x[], int yy, int z[])
{//⾼精度低乘
int up = 0;
for (int ii = 1; ii <= k; ii++)
{
z[ii] = (x[ii] * yy + up) % 10;
up = (x[ii] * yy + up) / 10;
}
}
int main()
{
//scanf("%d%d", &m, &k);
init();
cin >> s;
cin >> k;
int temp = 0, len = s.size();
for (i = len - 1; i >= len - k; i--)
n[++temp] = s[i] - '0';
int tmp = 0;
for (int i = 1; i <= k; i++) ans[i] = n[i];
for (int i = 1; i < single_j[n[1]]; i++)
{
memset(aans, 0, sizeof aans);
multiplyh(ans, n, aans);
for (int j = 1; j <= k; j++) { ans[j] = aans[j]; }//更新为第⼀次出现末尾循环节的状态 }
t[1] = single_j[n[1]];//最低位的循环结
for (int i = 1; i <= k; i++) now[i] = ans[i];
int pos = 2;//当前倒数位数
while (pos <= k)
{
for (int j = 1; j <= k; j++)
{
ans[j] = n[j];
last[j] = now[j];
}
tmp = 0;
while (tmp < 11)
{
tmp++;
memset(aans, 0, sizeof aans);
multiplyh(ans, now, aans);
for (j = 1; j <= k; j++)
{
ans[j] = aans[j];
}
if (ans[pos] == n[pos]) break;//找到循环结
memset(aans, 0, sizeof(aans));
multiplyh(last, now, aans);//更新last
for (j = 1; j <= k; j++) last[j] = aans[j];
}
if (tmp >= 11) { cout << -1; return0; }
for (int j = 1; j <= k; j++) now[j] = last[j];
memset(aans, 0, sizeof aans);
multiplyl(t, tmp, aans);//更新循环节数组
for (int i = 1; i <= 100; i++) t[i] = aans[i];
pos++;
}
int flag = 0;//不输出前导0
for (int i = 100; i >= 1; i--)
{
if (t[i]) flag = 1;
if (flag) cout << t[i]; }
return0;
}。