hdu-4471-Homework-矩阵快速幂+优化加速

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4471

题目意思：

求f(n).



当n为特殊点nk时



解题思路：

当x不为特殊点时，直接用基本的矩阵快速幂，求出f[x],当x为特殊点时，用另外一个矩阵，左乘转移一下。

也就是按特殊点nk,将1-n分成很多区段，一个区段一个特殊点这样来回求。

两点优化：

1、因为要多次用到同一矩阵的快速幂，所以先预处理该矩阵的2K次幂，免的计算每个区间的时候，都要计算该矩阵的2K次幂。

2、矩阵相乘的时候，把K作为主要控制元，一次计算 a[i][k]*a[k][j] ,当有a[i][k]等于0时，直接跳出来。

注意：

矩阵大小的选取，位置的选放。

c1 c2 c3 ... ct f(n-1) f(n)

1 0 0 ... 0 f(n-2) f(n-1)

0 1 0 ... 0 f(n-3) f(n-2)

0 0 1 ... 0 ... ...

... .... ... . ... ...

0 0 0 ..1 0 f(n-t) f(n-t+1)

话不多说。

代码解释的很详细：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#define eps 1e-6
#define INF 0x1f1f1f1f
#define PI acos(-1.0)
#define ll __int64
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
using namespace std;
#define Maxn 110
#define M 1000000007

/*
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
*/

//本题基本思路不难想到，主要是细节优化
//学习简洁写法

struct Mar
{
int row,col;
int s[Maxn][Maxn];

void init(int a,int b)
{
row=a,col=b;
memset(s,0,sizeof(s));
}
};

Mar operator * (const Mar & a,const Mar & b)
{
Mar res;
res.init(a.row,b.col); //初始化

for(int k=1;k<=a.col;k++) //以列向量为标准，在0较多的情况下可以降低时间复杂度，
{                         //以后注意这样写
for(int i=1;i<=res.row;i++)
{
if(a.s[i][k]==0)
continue;
for(int j=1;j<=res.col;j++)
{
if(b.s[k][j]==0)
continue;
res.s[i][j]=(1LL*a.s[i][k]*b.s[k][j]+res.s[i][j])%M; //枚举k时，想成可能为0
}  //强制转化为ll类型，免得超了
}
}
/*
for(int i=1;i<=res.row;i++)
for(int j=1;j<=res.col;j++)
for(int k=1;k<=a.col;k++)
res.s[i][j]=(1LL*a.s[i][k]*b.s[k][j]+res.s[i][j])%M;*/
return res;
}

Mar ba,sp[Maxn],ans,pp[35]; //pp[i]表示ba^(2*i)是预处理的矩阵,免得每一次都要计算
int nn[Maxn],tt[Maxn],m,n,q,t,pos[Maxn];//对下表排序

void getpp()
{
pp[0]=ba;
for(int i=1;i<=31;i++) //10^9 最多也就2^31次方
pp[i]=pp[i-1]*pp[i-1];
}

bool cmp(int a,int b) //对下标排序，免得每次都移动，特别是单个元素内容很多时，浪费时间
{
return nn[a]<nn[b];
}

void Cal(int a)//a表示次数,矩阵快速幂算,另外一种写的形式
{
for(int i=0;i<=31;i++)
{
if(a&(1<<i))
ans=pp[i]*ans;
}
return ;
}
/*
void Cal(int a) //这样写就tle,因为每个区段都要重新算矩阵的次方，果断采用上面的那种思路
{
Mar tmp=ba;
while(a)
{
if(a&1)
ans=tmp*ans;
a=a>>1;
tmp=tmp*tmp;
}
}*/

int main()
{
int ca=0;

while(scanf("%d%d%d",&n,&m,&q)!=EOF)
{
memset(ans.s,0,sizeof(ans));
for(int i=m;i>=1;i--)
scanf("%d",&ans.s[i][1]); //开始的m个
scanf("%d",&t);
memset(ba.s,0,sizeof(ba.s));
for(int i=1;i<=t;i++)  //
scanf("%d",&ba.s[1][i]);
//scanf("%d",&q);
for(int i=1;i<=q;i++)
{
pos[i]=i;
scanf("%d%d",&nn[i],&tt[i]);
memset(sp[i].s,0,sizeof(sp[i].s));
for(int j=1;j<=tt[i];j++)
scanf("%d",&sp[i].s[1][j]);
}
int Max=t;
for(int i=1;i<=q;i++)
Max=max(Max,tt[i]); //把最大的表长找到
ba.row=ba.col=Max;
ans.row=Max,ans.col=1;
for(int i=2;i<=ba.row;i++) //构造基本的矩阵
ba.s[i][i-1]=1;

getpp();

for(int i=1;i<=q;i++)
{
sp[i].row=sp[i].col=Max;
for(int j=2;j<=sp[i].row;j++) //构造特殊位置的矩阵
sp[i].s[j][j-1]=1;
}
sort(pos+1,pos+1+q,cmp); //由下标对nn排序

int last=m;
for(int i=1;i<=q;i++)
{
int p=pos[i]; //定位

if(nn[p]>n||nn[p]<=last) //不用算
continue;
Cal(nn[p]-last-1);
ans=sp[p]*ans; //特殊点单独计算
last=nn[p];
}
Cal(n-last);
printf("Case %d: %d\n",++ca,ans.s[1][1]);

}

return 0;
}