hdu 3519

给你n个硬币，问你存在连续相同（正面or反面）长度>2的排列数。

n很大，显然dp还要加上优化,n<=（10^9）,很显然的是用矩阵。

dp[i][j]表示前i个硬币最后j个是连续的。

那么dp[i][j]只有两种转移方法：dp[i+1][j+1],dp[i+1][1];

因为长度一旦超过2，我们就可以确定这个排列是符合要求的，后面的任何一位不管是正面还是反面都满足要求，所以就可以算出dp[i][3]*2^(n-i);一旦出现了连续三个就可以满足这个式子。

dp[i][3]=dp[i-1][2];

dp[i][2]=dp[i-1][1];

dp[i][1]=dp[i-1][1]+dp[i-1][2];

dp[1][1]=2;dp[1][2]=0;dp[1][3]=0;

这里我们引入多一列dp[i][4]记录前面满足条件的总数；

dp[i][4]=dp[i-1][3]+dp[i-1][4]*2（这里乘2，就是前面满足条件的排列在第i位可以任意放）；

现在构造矩阵

dp[i][1] dp[i][2] dp[i][3] dp[i][4]

1          1          0         0

1          0          1         0

0          0          0         1

0          0          0         2

处状态为

dp[1][1] dp[1][2] dp[1][3] dp[1][4]

2           0           0            0

接着矩阵快速幂就ok了，dp[n+1][4]为最后结果；

Run ID	Submit Time	Judge Status	Pro.ID	Exe.Time	Exe.Memory	Code Len.	Language	Author
5323716	2012-02-06 22:17:44	Accepted	3519	0MS	424K	939 B	G++	xym2010

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#define LG long long
using namespace std;
const int maxn=10005,MAX=1<<30,MIN=-(1<<30);
struct node
{
	int gp[5][5];
}A,B;
int n,m;
node mul(node a,node b)
{
	node c;
	for(int i=0;i<4;i++)
		for(int j=0;j<4;j++)
		{
			c.gp[i][j]=0;
			for(int k=0;k<4;k++)
			{
				c.gp[i][j]+=a.gp[i][k]*b.gp[k][j];
				c.gp[i][j]%=m;
			}
		}
		return c;
}
node sort_exp(int k)
{
	node ans=B,a=A;
	while(k)
	{
		if(k&1)ans=mul(ans,a);
		k>>=1;
		a=mul(a,a);
	}
	return ans;
}

int main()
{
	for(int i=0;i<2;i++)
		B.gp[i][i]=1;
	memset(A.gp,0,sizeof(A.gp));
	A.gp[0][0]=A.gp[0][1]=A.gp[1][0]=A.gp[1][2]=A.gp[2][3]=1;
	A.gp[3][3]=2;
	m=10007;
	while(~scanf("%d",&n))
	{
		node ans=sort_exp(n);
		printf("%d\n",2*ans.gp[0][3]%m);
	}
	return 0;
}