矩陣快速冪 學習筆記

　　

　　據說，矩陣快速冪在遞推式優化上相當神奇，而且效率很高。。。

　　兩矩陣相乘，朴素算法的復雜度是O(N^3)。如果求一次矩陣的M次冪，按朴素的寫法就是O(N^3*M)。既然是求冪，不免想到快速冪取模的算法，這里有快速冪取模的介紹，a^b %m 的復雜度可以降到O(logb)。如果矩陣相乘是不是也可以實現O(N^3 * logM)的時間復雜度呢？答案是肯定的。

　　先定義矩陣數據結構：　　

struct Mat {
    double mat[N][N];
};

　　O(N^3)實現一次矩陣乘法

Mat operator * (Mat a, Mat b) {
    Mat c;
    memset(c.mat, 0, sizeof(c.mat));
    int i, j, k;
    for(k = 0; k < n; ++k) {
        for(i = 0; i < n; ++i) {
            if(a.mat[i][k] <= 0)  continue;   //(針對ZOJ2853)剪枝，cpu運算乘法的效率並不是想像的那么理想（加法的運算效率高於乘法，比如Strassen矩陣乘法）
            for(j = 0; j < n; ++j) {
                if(b.mat[k][j] <= 0)    continue;    //剪枝
                c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
            }
        }
    }
    return c;
}

 

　　下面介紹一種特殊的矩陣：單位矩陣

很明顯的可以推知，任何矩陣乘以單位矩陣，其值不改變。

有了前邊的介紹，就可以實現矩陣的快速連乘了。

Mat operator ^ (Mat a, int k) {
    Mat c;
    int i, j;
    for(i = 0; i < n; ++i)
        for(j = 0; j < n; ++j)
            c.mat[i][j] = (i == j);    //初始化為單位矩陣

    for(; k; k >>= 1) {
        if(k&1) c = c*a;

        a = a*a;
    }
    return c;
}

　　舉個例子:

　　求第n個Fibonacci數模M的值。如果這個n非常大的話，普通的遞推時間復雜度為O(n)，這樣的復雜度很有可能會掛掉。這里可以用矩陣做優化，復雜度可以降到O(logn * 2^3)

如圖：

A = F(n - 1), B = F(N - 2)，這樣使構造矩陣的n次冪乘以初始矩陣得到的結果就是。

因為是2*2的據稱，所以一次相乘的時間復雜度是O(2^3)，總的復雜度是O(logn * 2^3 + 2*2*1)。

 

zoj上的一道例題: zoj 2853 Evolution.

這道題都不用考慮怎么去構造能夠實現有效運算的矩陣。直接修改單位矩陣就可以。比如P(i, j) = 0.5，則mat[i][j] += 0.5,mat[i][i] -= 0.5; 然后求T*mat^M,(T表示原始的population序列，相當於1*n的矩陣)

ps:這道題不加剪枝的話還是會掛掉 -_-!

渣代碼 :3S+ 過得，很水 T_T

 

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int N = 210;

struct Mat {
    double mat[N][N];
};

double num[N];
int n, m;
Mat a;

void init() {
    int i, j, q;
    double x;
    for(i = 0; i < n; ++i)
            for(j = 0; j < n; ++j)
                a.mat[i][j] = (i == j);
    for(i = 0; i < n; ++i) {
        scanf("%lf", num + i);
    }
    scanf("%d", &q);
    while(q--) {
        scanf("%d%d%lf", &i, &j, &x);
        a.mat[i][i] -= x;
        a.mat[i][j] += x;
    }
}

Mat operator * (Mat a, Mat b) {
    Mat c;
    memset(c.mat, 0, sizeof(c.mat));
    int i, j, k;
    for(k = 0; k < n; ++k) {
        for(i = 0; i < n; ++i) {
            if(a.mat[i][k] <= 0)  continue;    //***
            for(j = 0; j < n; ++j) {
                if(b.mat[k][j] <= 0)    continue;    //***
                c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
            }
        }
    }
    return c;
}

Mat operator ^ (Mat a, int k) {
    Mat c;
    int i, j;
    for(i = 0; i < n; ++i)
        for(j = 0; j < n; ++j)
            c.mat[i][j] = (i == j);

    for(; k; k >>= 1) {
        if(k&1) c = c*a;

        a = a*a;
    }
    return c;
}

int main() {
    //freopen("data.in", "r", stdin);

    int i;
    double res;

    while(~scanf("%d%d", &n, &m)) {
        if(!n && !m)    break;
        init();
        a = a^m; res = 0;
        for(i = 0; i < n; ++i) {
            res += num[i]*a.mat[i][n-1];
        }
        printf("%.0f\n", res);
    }
    return 0;
}

 

 

　　ps:以上內容是本菜參考各種資料整理的，歡迎轉載，請注明出處。http://www.cnblogs.com/vongang/archive/2012/04/01/2429015.html