[NOI2011]兔农

问题描述

　　农夫栋栋近年收入不景气，正在他发愁如何能多赚点钱时，他听到隔壁的小朋友在讨论兔子繁殖的问题。
　　问题是这样的：第一个月初有一对刚出生的小兔子，经过两个月长大后，这对兔子从第三个月开始，每个月初生一对小兔子。新出生的小兔子生长两个月后又能每个月生出一对小兔子。问第n个月有多少对兔子？
　　聪明的你可能已经发现，第n个月的兔子数正好是第n个Fibonacci(斐波那契)数。栋栋不懂什么是Fibonacci数，但他也发现了规律：第i+2个月的兔子对数等于第i个月的兔子对数加上第i+1个月的兔子对数。前几个月的兔子对数依次为：
　　1 1 2 3 5 8 13 21 34 …
　　栋栋发现越到后面兔子对数增长的越快，期待养兔子一定能赚大钱，于是栋栋在第一个月初买了一对小兔子开始饲养。
　　每天，栋栋都要给兔子们喂食，兔子们吃食时非常特别，总是每k对兔子围成一圈，最后剩下的不足k对的围成一圈，由于兔子特别害怕孤独，从第三个月开始，如果吃食时围成某一个圈的只有一对兔子，这对兔子就会很快死掉。
　　我们假设死去的总是刚出生的兔子，那么每个月的兔子对数仍然是可以计算的。例如，当k=7时，前几个月的兔子对数依次为：
　　1 1 2 3 5 7 12 19 31 49 80 …
　　给定n，你能帮助栋栋计算第n个月他有多少对兔子么？由于答案可能非常大，你只需要告诉栋栋第n个月的兔子对数除p的余数即可。

输入格式

　　从文件rabbit.in中读入数据。
　　输入一行，包含三个正整数n, k, p。

输出格式

　　输出到文件rabbit.out中。
　　输出一行，包含一个整数，表示栋栋第n个月的兔子对数除p的余数。

暂见代码，之后会更新解释

75分：

#include <iostream>

using namespace std;

long long f[1000005],n,k,p,truef[1000005];

int main()
{
    freopen("rabbit.in","r",stdin);
    freopen("rabbit.out","w",stdout);
    cin >> n >> k >> p;
    f[1] = f[2] = truef[1] = truef[2] = 1;
    for(int i = 3;i <= n; ++i)
    {
        f[i] = (f[i - 1] + f[i - 2]) % k;
        truef[i] = (truef[i - 1] + truef[i - 2]) % p;
        if(f[i] == 1)
        {
            f[i]--;
            truef[i]--;
            if(truef[i] == -1)
                truef[i] = p - 1;
        }
    }
    cout << truef[n] << endl;
    return 0;
}

100分：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long ll;
ll inv[1000005],n,k,p,pos[1000005],fib[10000005],vis[1000005],index1[1000005];
inline void exgcd(ll a,ll b,ll &d,ll &x,ll &y)//扩欧求逆元 
{
	if(b == 0)
	{
		x = 1,y = 0;
		d = a;
		return ;
	}
	exgcd(b,a % b,d,x,y);
	ll t = x;
	x = y;
	y = t - (a / b) * y;
}
inline void PreInv()//处理出1~k - 1的逆元 
{
	ll x,y,d;
	inv[1] = 1;
	for(int i = 2;i < k; ++i)
	{
		d = 0,x = 0,y = 0;
		exgcd(i,k,d,x,y);
		if(d != 1)
			inv[i] = -1;
		else
			inv[i] = (x % k + k) % k;
	}
}
struct matrix
{
	ll a[3][3];
	inline void init()
	{
		memset(a,0,sizeof a);
	}
	inline void pow0()
	{
		memset(a,0,sizeof a);
		a[0][0] = a[1][1] = a[2][2] = 1;
	}
	matrix operator * (const matrix &t)const
	{
		matrix Z;
		Z.init();
		for(int i = 0;i < 3; ++i)
			for(int j = 0;j < 3; ++j)
			{
				for(int k = 0;k < 3; ++k)
					Z.a[i][j] += (a[i][k] * t.a[k][j]) % p;
				Z.a[i][j] %= p;
			}
		return Z; 
	}
}A,B,mid[1000005],ans,to,Q;
inline matrix pow(matrix a,ll b)//矩阵快速幂 
{
	matrix ret;
	ret.pow0();
	while(b)
	{
		if(b & 1)
			ret = ret * a;
		a = a * a;
		b >>= 1;
	}
	return ret;
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("rabbit.in","r",stdin);
	freopen("rabbit.out","w",stdout);
	cin >> n >> k >> p;
	fib[1] = fib[2] = 1;
	for(int i = 3;; ++i)
	{
		fib[i] = (fib[i - 1] + fib[i - 2]) % k;
		if(!pos[fib[i]])
			pos[fib[i]] = i;
		if(fib[i] == 1 && fib[i - 1] == 1)
			break;
	}
	PreInv();
	A.a[2][2] = A.a[1][0] = A.a[0][1] = A.a[1][1] = 1;
	B.a[1][1] = B.a[2][2] = B.a[0][0] = 1;
	B.a[2][1] = -1;
	ll id = 0,cnt = 1;
	while(true)//搜循环 
	{
		if(vis[cnt])//访问过
			break;
		if(!pos[inv[cnt]] || inv[cnt] == -1)//当前位没有逆元，无法向后跳
			break;
		id++;
		vis[cnt] = id;//记录当前值访问次序
		index1[id] = index1[id - 1] + pos[inv[cnt]];//当前段的末尾(长度和)(走到下一个inv)
		mid[id] = pow(A,pos[inv[cnt]]) * B;//预处理fib的值 
		cnt = 1LL * cnt * fib[pos[inv[cnt]] - 1] % k;//前进到下一次少兔的下一个
		cnt %= k;
		//数列形如 i 0 i i 2i 3i ... 0 j
		//记斐波那契数列为fib[i]。假如某段段首数字为x，那么这一段内第i个数即为x*fib[i] % k。若记这一段长度为len，则有x*fib[len]==1 (mod k)
		//x*fib[len-1]%k
	}
	ans.pow0();
	to.pow0();
	if(vis[cnt])//混循环 
	{
		ll home = vis[cnt] - 1,i;//cnt的第一次出现 
		for(i = 1;i <= home && n >= index1[i]/*能够前进到下一位置*/; ++i)
			ans = ans * mid[i];//非循环部分 
		if(i <= home)//后面无循环 
		{
			Q = pow(A,n - index1[i - 1]);
			ans = ans * Q;//乘上后面的 
		}
		else//后面纯循环 
		{
			//转化为区间斐波那契 
			ll len = index1[id] - index1[home];//循环长度 
			n -= index1[home];//已在108-109行处处理
			for(i = home + 1;i <= id; ++i)//循环节内乘 
				to = to * mid[i];
			to = pow(to,n / len);//每个循环节用快速幂 
			ans = ans * to;
			n %= len;
			for(i = home + 1; n >= index1[i] - index1[home]; ++i)
				ans = ans * mid[i];//当前循环节多余的 
			Q = pow(A,n - index1[i - 1] + index1[home]);
			ans = ans * Q;//到n多余的
		}
	}
	else//不循环
	{
		ll q;
		for(q = 1;q <= id && n >= index1[q]; ++q)
			ans = ans * mid[q];
		Q = pow(A,n - index1[q - 1]);
		ans = ans * Q;
	} 
	cout << ((ans.a[0][1] + ans.a[2][1]) % p + p) % p << endl;
	return 0;
}