1、关于矩阵快速幂
#define maxn 110
struct Matrax{
int map[maxn][maxn];
} per, A;
int n,m;
void init(){
for( int i = 0 ; i < n ; ++i ){
for( int j = 0 ; j < n ; ++j ){
scanf("%d",&A.map[i][j]);
A.map[i][j] %= m;
per.map[i][j] = ( i == j );
}
}
}
Matrax Multi( Matrax a , Matrax b ){ // a*b
Matrax c;
for( int i = 0 ; i < n ; ++i ){
for( int j = 0 ; j < n ; ++j ){
c.map[i][j] = 0;
for( int k = 0 ; k < n ; ++k )
c.map[i][j] += ( a.map[i][k] * b.map[k][j] ) % m;
c.map[i][j] %= m;
}
}
return c;
}
Matrax Power( int k ){ //A^k%m
Matrax ans = per, p = A;
while( k ){
if( k & 1 )
ans = Multi(ans, p);
p = Multi(p, p);
k >>= 1;
}
return ans;
}
Matrax Add( Matrax a , Matrax b ){ // a+b
Matrax c;
for( int i = 0 ; i < n ; ++i )
for( int j = 0 ; j < n ; ++j )
c.map[i][j] = ( a.map[i][j] + b.map[i][j] ) % m;
return c;
}
Matrax MatraxSum( int k ){ //A+A^2+A^3+ …+A^k
if( k == 1 )
return A;
Matrax temp , b;
temp = MatraxSum(k/2);
if( k & 1 ){
b = Power( k / 2 + 1 );
temp = Add( temp , Multi( temp , b ) );
temp = Add( temp , b );
}
else{
b = Power( k / 2 );
temp = Add( temp , Multi( temp , b ) );
}
return temp;
} 2、二维空间点的变换（平移、缩放、翻转、旋转）
给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转
这里的操作是对所有点同时进行的。其中翻转是以坐标轴为对称轴进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时O(mn)。利用矩阵乘法可以在O(m)的时间里把所有操作合并为一个矩阵，然后每个点与该矩阵相乘即可直接得出最终该点的位置，总共耗时O(m+n)。假设初始时某个点的坐标为x和y，下面5个矩阵可以分别对其进行平移、旋转、翻转和旋转操作。预先把所有m个操作所对应的矩阵全部乘起来，再乘以(x,y,1)，即可一步得出最终点的位置。
3、经典题目VOJ1049[送给圣诞夜的礼品]
题目内容：列表共有m行，这m行都称作操作（不是序列），每一行有n个数字，这些数字互不相同而且每个数字都在1到n之间。一开始，礼品的序列就是现在礼品所处的位置，也就是说，一开始礼品的序列就是1、2、3、4……n；那么然后，我们看列表的第一行操作，设这一行操作的第i个数字为a[i]，那么就把原来序列中的第a[i]个礼物放到现在这个序列的第i的位置上，然后组成新的礼物序列。然后，看列表的第二行操作……、第三行操作……一直到最后一行操作，重复上面的操作。当最后一行的操作结束，组成了的序列又按照第一行来操作，然后第二行操作……第三行操作……一直循环下去，直到一共操作了k行为止。
题目大意：顺次给出m个置换，反复使用这m个置换对初始序列进行操作，问k次置换后的序列。m<=10, k<2^31。
样例输入：
7 5 8
6 1 3 7 5 2 4
3 2 4 5 6 7 1
7 1 3 4 5 2 6
5 6 7 3 1 2 4
2 7 3 4 6 1 5
样例输出：
2 4 6 3 5 1 7
分析：首先将这m个置换“合并”起来（算出这m个置换的乘积），然后接下来我们需要执行这个置换k/m次（取整，若有余数则剩下几步模拟即可）。注意任意一个置换都可以表示成矩阵的形式。例如，将1 2 3 4置换为3 1 2 4，相当于下面的矩阵乘法：
置换k/m次就相当于在前面乘以k/m个这样的矩阵。
建立置换矩阵部分的代码：
#define maxn 110;
struct Matrax{
int map[maxn][maxn];
}; // 置换矩阵
int op[maxn][maxn];//存储操作序列
int n,m,k;
void init(){ //"合并"后的矩阵
Matrax move;
for( int i = 0 ; i < m ; ++i ){
for( int j = 0 ; j < n ; ++j )
scanf("%d",&op[i][j]);
memset(move.map,0,sizeof(move.map));
for( int j = 0 ; j < n ; ++j )
move.map[j][op[i][j]-1] = 1;
}
}
Matrax LastMove(Matrax a){
Matrax lastmove;
for( int i = 0 ; i < (k%m) ; ++i ){
memset(lastmove.map,0,sizeof(lastmove.map));
for( int j = 0 ; j < n ; ++j )
lastmove.map[j][op[i][j]-1] = 1;
a = Multi(a,lastmove);
}
return a;
}4、经典题目VOJ1067[Warcraft III 守望者的烦恼]
题目内容：她的闪烁技能是可以升级的，k级的闪烁技能最多可以向前移动k个监狱，一共有n个监狱要视察，她从入口进去，一路上有n个监狱，而且不会往回走，当然她并不用每个监狱都视察，但是她最后一定要到第n个监狱里去，因为监狱的出口在那里，但是她并不一定要到第1个监狱。她在拥有k级闪烁技能时视察n个监狱一共有多少种方案？
样例输入：
2
4
样例输出：
5
提示：
把监狱编号1 2 3 4,闪烁技能为2级，
一共有5种方案
→1→2→3→4
→2→3→4
→2→4
→1→3→4
→1→2→4
分析：
状态方程dp[n] = dp[n-k] + dp[n-k+1] + ... +dp[n-1]
由于n比较大 n<=2^31-1
要用矩阵来优化后面的状态转移
也就是矩阵
0 1 0 0 a b
0 0 1 0 * b = c
0 0 0 1 c d
1 1 1 1 d a+b+c+d
然后在快速幂。。。
其对应矩阵的构造方法为：在右上角的(n-1)*(n-1)的小矩阵中的主对角线上填1，矩阵第n行填对应的系数，其它地方都填0。
5、矩阵Fibonacci数
给定n和p，求第n个Fibonacci数mod p的值，n不超过2^31
构造一个2 x 2的矩阵，使得它乘以(a,b)得到的结果是(b,a+b)。每多乘一次这个矩阵，这两个数就会多迭代一次。那么，我们把这个2 x 2的矩阵自乘n次，再乘以(0,1)就可以得到第n个Fibonacci数了。
6、给定一个有向图，问从A点恰好走k步（允许重复经过边）到达B点的方案数mod p的值
把给定的图转为邻接矩阵，即A(i,j)=1当且仅当存在一条边i->j。令C=A*A，那么C(i,j)=ΣA(i,k)*A(k,j)，实际上就等于从点i到点j恰好经过2条边的路径数（枚举k为中转点）。类似地，C*A的第i行第j列就表示从i到j经过3条边的路径数。同理，如果要求经过k步的路径数，我们只需要二分求出A^k即可。
7、 用1 x 2的多米诺骨牌填满M x N的矩形有多少种方案，M<=5，N<2^31，输出答案mod p的结果
我们以M=3为例进行讲解。假设我们把这个矩形横着放在电脑屏幕上，从右往左一列一列地进行填充。其中前n-2列已经填满了，第n-1列参差不齐。现在我们要做的事情是把第n-1列也填满，将状态转移到第n列上去。由于第n-1列的状态不一样（有8种不同的状态），因此我们需要分情况进行讨论。在图中，我把转移前8种不同的状态放在左边，转移后8种不同的状态放在右边，左边的某种状态可以转移到右边的某种状态就在它们之间连一根线。注意为了保证方案不重复，状态转移时我们不允许在第n-1列竖着放一个多米诺骨牌（例如左边第2种状态不能转移到右边第4种状态），否则这将与另一种转移前的状态重复。把这8种状态的转移关系画成一个有向图，那么问题就变成了这样：从状态111出发，恰好经过n步回到这个状态有多少种方案。比如，n=2时有3种方案，111->011->111、111->110->111和111->000->111，这与用多米诺骨牌覆盖3x2矩形的方案一一对应。这样这个题目就转化为了我们前面的例题6。
8、经典题目POJ2778[DNA Sequence]
题目大意是，检测所有可能的n位DNA串有多少个DNA串中不含有指定的病毒片段。合法的DNA只能由ACTG四个字符构成。题目将给出10个以内的病毒片段，每个片段长度不超过10。数据规模n<=2 000 000 000。
以ATC,AAA,GGC,CT这四个病毒片段为例，说明怎样像上面的题一样通过构图将问题转化为例题8。我们找出所有病毒片段的前缀，把n位DNA分为以下7类：以AT结尾、以AA结尾、以GG结尾、以?A结尾、以?G结尾、以?C结尾和以??结尾。其中问号表示“其它情况”，它可以是任一字母，只要这个字母不会让它所在的串成为某个病毒的前缀。显然，这些分类是全集的一个划分（交集为空，并集为全集）。现在，假如我们已经知道了长度为n-1的各类DNA中符合要求的DNA个数，我们需要求出长度为n时各类DNA的个数。我们可以根据各类型间的转移构造一个边上带权的有向图。例如，从AT不能转移到AA，从AT转移到??有4种方法（后面加任一字母），从?A转移到AA有1种方案（后面加个A），从?A转移到??有2种方案（后面加G或C），从GG到??有2种方案（后面加C将构成病毒片段，不合法，只能加A和T）等等。这个图的构造过程类似于用有限状态自动机做串匹配。然后，我们就把这个图转化成矩阵，让这个矩阵自乘n次即可。最后输出的是从??状态到所有其它状态的路径数总和。
/*
少用取模，那东西太耗时间了
*/
#include<cstdio>
#include<cstring>
const int NODE=13*13;
const int CH=4;
int tree[NODE][CH],cnt;
int word[NODE];
int fail[NODE];
int Que[NODE];
int num[150];
int m,n;
int matnum,matcal[NODE];
__int64 mm[NODE][NODE],r[NODE][NODE],tem[NODE][NODE];
void Ins(char *a,int val){
int p=0;
for(; *a; a++){
int c=num[*a];
if(!tree[p][c]){
memset(tree[cnt],0,sizeof(tree[cnt]));//初始化新的节点
word[cnt]=0;
tree[p][c]=cnt++;
}
p=tree[p][c];
}
word[p]=val;//做一个标记，说明这是病毒串
}
void AC(){
int *s=Que,*e=Que;
for(int i=0; i<CH; ++i)
if(tree[0][i]){
fail[tree[0][i]]=0;//修改失败指针
*e++=tree[0][i];
}
while(s!=e){
int p=*s++;
for(int i=0; i<CH; ++i){
if(tree[p][i]){
int v=tree[p][i];
*e++=v;
fail[v]=tree[fail[p]][i];
word[v]|=word[fail[v]];//Wa了N次
}
else{
tree[p][i]=tree[fail[p]][i];
}
}
}
}
char s[13];
void Input(){
fail[0]=0;
memset(tree[0],0,sizeof(tree[0]));//初始化根节点，开始都指向根节点
//从1开始，0有特殊使用
cnt=1;//已经有根节点,节点是从1<=i<cnt
num['A']=0;
num['T']=1;
num['C']=2;
num['G']=3;
for(int i=1; i<=m; i++){
scanf("%s",s);
Ins(s,1);
}
}
void init()//建立矩阵的关系{
memset(mm,0,sizeof(mm));
memset(matcal,0,sizeof(matcal));
matnum=0;//矩阵从0<=i<matnum
for(int i=0; i<cnt; ++i)
if(word[i]==0) matcal[i]=matnum++;
for(int i=0; i<cnt; ++i)
if(word[i]==0){
for(int j=0; j<CH; ++j){
if(word[tree[i][j]]==0){ //不是病毒串
mm[matcal[i]][matcal[tree[i][j]]]++;
}
}
}
}
void Mul(__int64 a[NODE][NODE],__int64 b[NODE][NODE]){
memset(tem,0,sizeof(tem));
for(int i=0; i<matnum; ++i)
for(int j=0; j<matnum; ++j){
for(int k=0; k<matnum; ++k)
tem[i][j]=tem[i][j]+a[i][k]*b[k][j];
tem[i][j]=tem[i][j]%100000;
}
}
void work(){
for(int i=0; i<matnum; ++i) r[i][i]=1;
while(n){
if(n&1){
Mul(mm,r);
memcpy(r,tem,sizeof(tem));
}
n>>=1;
Mul(mm,mm);
memcpy(mm,tem,sizeof(tem));
}
int res=0;
for(int i=0; i<matnum; ++i) res+=r[0][i];
res=res%100000;
printf("%d/n",res);
}
int main(){
scanf("%d%d",&m,&n);
Input();
AC();
init();
work();
return 0;
}
拓展：(关于根据表达式创建矩阵方法)
若有递推式：f(n) = a(1)f(n-1)+a(2)f(n-2)+a(3)f(n-3)+......+a(m)f(n-m)，则可以转换为以下矩阵形式：
逆向思维
题意：
对于给定的一个矩阵A，A+A^2+A^3+...+A^K 是多少呢？
其中A^2 表示两个矩阵的乘积A*A，A^3表示三个矩阵的乘积A*A*A，依此类推。求结果中的非0元素个数。
题解：
平时一般都用矩阵来表示一个图，这里用图来表示一个矩阵。A^K中A[i][j]表示从在这个图上i走了K步后可达到j。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define maxn 1005
#define inf 0x1fffff
bool reach[maxn][maxn];
int map[maxn][maxn];
char s[maxn];
int d[maxn],n;
struct pt{
int d,x;
};
void bfs(int x){
int i,j;
pt now,next;
queue<pt>q;
now.x = x;
now.d = 0;
d[now.x] = now.d;
q.push(now);
while( !q.empty() ){
now = q.front();
q.pop();
if( now.d > n+2 ) break;
for( i = 1 ; i <= map[now.x][0] ; ++i ){
next.x = map[now.x][i];
next.d = now.d + 1;
if( next.d < d[next.x] ){
d[next.x] = next.d;
q.push(next);
reach[x][next.x] = 1;
}
}
}
}
int main(){
int m,k,i,x,y,z,j,sum;
while( scanf("%d %d %s",&n,&m,s) != EOF ){
memset(reach,0,sizeof(reach));
for( i = 1 ; i <= n ; ++i )
reach[i][i] = 1;
memset(map,0,sizeof(map));
for( i = 1 ; i <= m ; ++i ){
scanf("%d %d %d",&x,&y,&z);
x++,y++;
if( z > 0 ){
reach[x][y] = 1;
map[x][++map[x][0]] = y;
}
}
for( i = 1 ; i <= n ; ++i ){
for( j = 1 ; j <= n ; ++j )
d[j] = inf;
bfs(i);
}
sum = 0;
for( i = 1 ; i <= n ; ++i )
for( j = 1 ; j <= n ; ++j )
sum += reach[i][j];
printf("%d\n",sum);
}
return 0;
}
扫一扫
906
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
