A、B是兩個n*n的矩陣，計算C=A*B。

傳統演算法：

按照下面公式計算，需要n3次乘法和n3-n2次加法，時間複雜度為Θ(n3)。

遞迴演算法：

假定n為2的冪，將A、B、C分成4個大小為(n/2)*(n/2)的子矩陣。

用分治法來計算C。

需要8次(n/2)*(n/2)矩陣的乘法和4次(n/2)*(n/2)矩陣的加法，其中乘法是原來的1/8倍消費，加法是原來的1/4倍耗費。用m表示n=1是乘法的耗費，用a表示加法的耗費。
於是有了下面的遞推式：

可以推出：

同樣需要n3次乘法和n3-n2次加法，與傳統方法相比，時間複雜度沒有改進，反而還增加了遞迴帶來的管理開銷。

Strassen演算法：

複雜度為o(n3)，執行時間漸進少於n3。
像遞迴方法一樣劃分矩陣，但在計算C的時候有一些不同。
首先計算出一些中間值：

再由這些中間值得出C：

Strassen演算法進行了18次加法和7次乘法。對於執行時間有如下的遞推式：

經過計算可得，執行時間為Θ(nlog7)=O(n2.81)。

三個演算法的比較：

沒有相關程式碼，但貼一個常用的矩陣類模板：

#include<iostream>
#include<stdio.h>
#include<cstdio>
#include<cstring>
#define ll long long
using namespace std;

const int dim=20; //最高的維度,可調
int mod=1000000007; // 結果取的模,可調
int mk=5;// 運算時是運算幾維矩陣的,可調

struct Matrix
{
    ll a[dim][dim];
    Matrix(){memset(a,0,sizeof(a));}
};


Matrix operator *(const Matrix& a,const Matrix& b)
{
    Matrix ret;
    for(int i=0;i<mk;++i)
        for(int j=0;j<mk;++j)
            for(int k=0;k<mk;++k)
            {
                ret.a[i][j]+=a.a[i][k]*b.a[k][j];
                ret.a[i][j]%=mod;
            }
    return ret;
}
Matrix operator ^(Matrix x, ll n)
{
    Matrix ret;
    for(int i=0;i<mk;++i)ret.a[i][i]=1;
    while(n)
    {
        if(n&1)ret=ret*x;
        x=x*x;
        n>>=1;
    }
    return ret;
}

int main()
{
    int a;
    cin>>a;
}