POJ 3735 Training Little Cats

刚开始看三种操作就有点像矩阵的基本行、列运算，觉得应该用矩阵，但是之前某次考试的时候用矩阵乘法超时了，而且一直没有用矩阵解决过实际问题，这次也算是长了姿势

三种操作对应三种基本矩阵，在由于基本矩阵属于稀疏矩阵，因此可以用一个小的优化来加快矩阵乘法的运算速度（下面是a与b矩阵相乘得到c矩阵）：

for(int i=0;i<n;++i){
    for(int j=0;j<n;++j){
        if(a[i][j]){
            for(int k=0;k<n;++k）{
                c[i][k] += a[i][j]*b[j][k];
            }
        }
    }
}

再来看m的大小…1 000 000 000….要直接乘m次肯定是吃不消的，因此要使用快速幂的算法，每次都折半进行矩阵乘法：

while(m){
    if(m%2){
        ans = process*ans;
    }
    process = process*process;
}

矩阵还是挺有意思的…

#include <iostream>
#include <cstdio>
#include <memory.h>
#include <algorithm>
using namespace std;

#define maxn 105

long long int ans[maxn][maxn]={0};
long long int process[maxn][maxn]={0};
long long int temp[maxn][maxn]={0};
long long int n,m,k;

void give(int k){
    process[k][n+1]++;
}

void eat(int k){
    for(int i=1;i<=n+1;++i)
        process[k][i] = 0;
}

void swp(int x,int y){
    for(int i=1;i<=n+1;++i)
        swap(process[x][i],process[y][i]);
}

int main(){
    while(scanf("%lld%lld%lld",&n,&m,&k),n|m|k){
        memset(ans,0,sizeof(ans));
        memset(process,0,sizeof(process));
        for(int i=1;i<=n+1;++i){
            ans[i][i] = process[i][i] = 1;
        }

        while(k--){
            char ins;
            cin>>ins;
            int x,y;

            switch(ins){
                case 'g':
                    scanf("%d",&x);
                    give(x);
                    break;
                case 'e':
                    scanf("%d",&x);
                    eat(x);
                    break;
                case 's':
                    scanf("%d%d",&x,&y);
                    swp(x,y);
                    break;
                default:
                    break;
            }
        }

        while(m){
            memset(temp,0,sizeof(temp));
            if(m%2){
                for(int i=1;i<=n+1;++i){
                    for(int j=1;j<=n+1;++j){
                        if(process[i][j]){
                            for(int k=1;k<=n+1;++k){
                                temp[i][k] += process[i][j]*ans[j][k];
                            }
                        }
                    }
                }
                for(int i=1;i<=n+1;++i){
                    for(int j=1;j<=n+1;++j){
                        ans[i][j] = temp[i][j];
                    }
                }
            }

            memset(temp,0,sizeof(temp));
            for(int i=1;i<=n+1;++i){
                for(int j=1;j<=n+1;++j){
                    if(process[i][j]){
                        for(int k=1;k<=n+1;++k){
                            temp[i][k] += process[i][j]*process[j][k];
                        }
                    }
                }
            }
            for(int i=1;i<=n+1;++i){
                for(int j=1;j<=n+1;++j){
                    process[i][j] = temp[i][j];
                }
            }

            m/=2;
        }
        for(int i=1;i<=n;++i){
            printf("%lld ",ans[i][n+1]);
        }
        printf("\n");

    }
    //system("pause");
    return 0;
}