HLOJ1361 Walking on the Grid II 矩阵快速幂

题目分析：

就当是一次记录吧，2013年绍兴市市赛的一题，重现赛当时我想递推可能是矩阵快速幂吧，但是这个递推公式真没推出来（赛后猛如虎系列），这题和第一题有联系又有区别，第一题的递推很简单，dp[i][j] = dp[i-1][j] + dp[i][j-1]，但是第二题有两个问题：1.H的范围扩大到1000000000，二维数组无法存储（空间过大）2.普通递推的话递推的次数太多（w*h，时间过大），简单来说必须改变一下思维，否则一定爆内存且超时，之前的递推公式也用不了了

这里先放一张我的手稿（丑图警告）

这里需要通过仔细的观察，将上图处于同一斜线的位置归为同一层（或者说这些在同一斜线上的点的横坐标与纵坐标的和是相同的），还记得上面提到的两个难题吗，现在来解决空间过大无法存储二维数组的问题，此时我们观察，对于图中的某一点（i,j）来说，到达它的行走方案一定是到达（i-1,j）和到达(i,j-1)的方案的和，就斜线上每个位置来说，就等于它左边的与上面的格子的数的和，而且这里每条斜线上的点仅仅用于下一斜线上的点的计算（这里就很像背包问题的二维化一维的思想）我们可以将二维数组转化成一维数组，dp[j]代表第i条斜线的从右上往左下的第j个点的可达方案数，由于w<=30，所以斜线的长度最长也只有31（有一个0点需要辅助计算）

此时空间的问题就解决了，我们接下来需要做的就是通过条斜线上的点点，推出下一条斜线上的点的种数，且我们很容易发现（就斜线上某一个点来说，dp[j] = dp[j] + dp[j-1]，这里要注意，此时dp[j]代表的是第i条斜线的从右上往左下第j个点，而此时只有一个一维数组在存放，所以前面的等式，前一个dp[j]代表的是第i条斜线的dp[j]的值，而等式后面的dp[j]与dp[j-1]代表的是第i-1条斜线的这两个点的走法），此时我们将第一条斜线的数据抽象成一个1XW的矩阵，它乘上一个WXW的矩阵就会得到一个代表第二条斜线的矩阵

且根据我们的推理，我们的递推公式是dp[j] = dp[j] + dp[j-1]，最后一条斜线所抽象的第w个点就是到达W*H的位置所有的行走方案的总数，而对于出现的障碍点，我们可以对它们根据横纵坐标之和进行排序（横纵之和就是斜线的编号，初始点1，1所以斜线编号我定义为2），然后对于当前的斜线求和下一个障碍点所在的斜线编号值差，矩阵快速幂求出当前障碍点的所有dp[j]的种数，而对于障碍点，dp[j] = 0，这样从下一条斜线开始就会受到影响，对于其他的障碍点也是相同的处理，如果同一条斜线有多个障碍点就将dp[j]都 = 0，此时的j就是障碍点的横坐标，最后求一次到达第(w+h)条斜线的举证快速幂

代码：

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;

int w, h, d;
const long long mod = 1e9 + 7;
struct mat{
    long long m[35][35];
};
struct Node{
    long long x, y;
    long long sum;
}danger[55];

bool cmp(Node a, Node b){
    return a.sum < b.sum;
}

mat operator * (mat a, mat b){
    mat ret;
    for(int i = 0; i <= w; i++){
        for(int j = 0; j <= w; j++){
            long long temp = 0;
            for(int k = 0; k <= w; k++){
                if(a.m[i][k] && b.m[k][j]){
                    temp += a.m[i][k] * b.m[k][j];
                    temp %= mod;
                }
            }
            ret.m[i][j] = temp;
        }
    }    
    return ret;
}

mat pow_mat(mat res, mat a, int n){
    while(n){
        if(n&1) res = res * a;
        a = a * a;
        n >>= 1;
    }
    return res;
}

int main(){
    while(scanf("%d%d%d", &w, &h, &d) != EOF){
        for(int i = 0; i < d; i++){
            scanf("%d%d", &danger[i].x, &danger[i].y);
            danger[i].sum = danger[i].x + danger[i].y;
        }
        sort(danger, danger+d, cmp);
        mat x;                                    //构造一个幂矩阵 
        for(int i = 0; i <= w; i++){
            for(int j = 0; j <= w; j++){
                x.m[i][j] = 0;
            }
        }
        for(int i = 0; i <= w-1; i++){
            for(int j = i; j < i+2; j++){
                x.m[i][j] = 1;
            }
        } 
        x.m[w][w] = 1;
        mat res;
        for(int i = 0; i <= w; i++){
            for(int j = 0; j <= w; j++){
                res.m[i][j] = 0;
            }
        } 
        res.m[0][1] = 1;                                //默认横纵坐标和为2开始，即（1，1）点         
        int cen = 2;                                    //这里定义的层数为点的横纵坐标之和 
        for(int i = 0; i < d; i++){
            if(danger[i].sum > cen){                    //当前的危险点层数大于已经完成计算的层数 
                res = pow_mat(res, x, danger[i].sum - cen);
                cen = danger[i].sum;
                res.m[0][danger[i].x] = 0;            
            }else if(danger[i].sum == cen){                //当前的危险点的层数等于已经完成的计算的层数则直接更新危险点为0种 
                res.m[0][danger[i].x] = 0;
            }
        }        
        if(h+w > cen) res = pow_mat(res, x, h+w - cen);        //最后将剩余的层数直接求完    
        printf("%d
", res.m[0][w]);
    }    
    return 0;
}