Algorithm 斯特拉森矩阵乘法

嗯，这是《算法概论》中的一个问题，它的编号是

4.2-6

。它是这样描述的：

使用

Strassen算法作为
子例程
，将
kn*n矩阵乘以n*kn矩阵
的速度有多快

我想把这两个矩阵都扩展到
kn*kn矩阵
，然后我可以把Strassen算法应用到这个问题上。但是我会得到一个
Math.pow（kn，lg7）的运行时间

有谁有更好的解决办法吗。祝大家新年快乐。
你可以看到上的实现，这个算法在维基百科中也有很好的描述。
你可以看到上的实现，这个算法在维基百科中也有很好的描述。
想想，不要用k*1向量乘以1*k向量。这需要k^2乘法，最后得到一个k*k矩阵。这里唯一不同的是，向量的元素是n*n矩阵，因此如果使用Strassen的算法乘以n*n矩阵，则最终将执行O（k^2 n^（log 7））标量乘法。
请考虑将k*1向量乘以1*k向量。这需要k^2乘法，最后得到一个k*k矩阵。这里唯一不同的是，向量的元素是n*n矩阵，因此如果使用Strassen的算法乘以n*n矩阵，则最终会执行O（k^2 n^（log 7））标量乘法。
Strassen算法的另一个基于向量的实现在这里，它显示了naive和strssens的运行时间比较：

enter code here:
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <vector>
#include <ctime>
using namespace std;
void fun(vector<vector<int> >& u , vector<vector<int> >&m , int P , int n)
{


    for(int i = 0 ; i < n ; i++)
    {
        vector<int>t ;
        for(int j = 0 ; j < n ; j++)
        {
                      switch(P)
          {
                        case 1:
                        {
               t.push_back(u[i][j]);
                           break;
            }
                        case 2:
                        {
                t.push_back(u[i][j+n]);
                            break;
                }
                        case 3:
                        {
                t.push_back(u[i+n][j]);
                            break;
            }
                        case 4:
                        {
            t.push_back(u[i+n][j+n]);
                            break;
            }
                     }
                  }

                  m[i] = t;
    }
}
void normalmul(int n , vector< vector<int> >& u   , vector< vector<int> >& v  ,     vector< vector<int> >& z )

{
for(int i = 0 ; i < n ; i++)
{
    for(int j = 0 ; j < n ; j++)
    {
        z[i][j] = 0;
        for(int k = 0 ; k < n ; k++)
        {
            z[i][j] += (u[i][k] * v[k][j]);
        }
    }
}
}

void strassen(int n , vector< vector<int> >& u   , vector< vector<int> >& v  , vector< vector<int> >& z)

{
if(n == 32)
{
    normalmul(n,u,v,z);
    return;
}
else
{
    int Shiftt = n>>1;
    vector<vector<int> >AA(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >BB(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >CC(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >DD(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >EE(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >FF(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >GG(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >HH(Shiftt , vector<int>(Shiftt));

    vector<vector<int> >A1(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >A2(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >A3(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >A4(Shiftt , vector<int>(Shiftt));
    fun(u,AA,1,n>>1);
    fun(u,BB,2,n>>1);
    fun(u,CC,3,n>>1);
    fun(u,DD,4,n>>1);
    fun(v,EE,1,n>>1);
    fun(v,FF,2,n>>1);
    fun(v,GG,3,n>>1);
    fun(v,HH,4,n>>1);
    vector<vector<int> >M1(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M2(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M3(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M4(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M5(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M6(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >M7(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >T1(Shiftt , vector<int>(Shiftt));
    vector<vector<int> >T2(Shiftt , vector<int>(Shiftt));
    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = AA[i][j] + DD[i][j];
            T2[i][j] = EE[i][j] + HH[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M1);


    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = CC[i][j] - AA[i][j];
            T2[i][j] = EE[i][j] + FF[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M6);

    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = BB[i][j] - DD[i][j];
            T2[i][j] = GG[i][j] + HH[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M7);


    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = CC[i][j] + DD[i][j];
            T2[i][j] = EE[i][j] ;
        }
    }
    strassen(Shiftt,T1,T2,M2);


    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = AA[i][j] ;
            T2[i][j] = FF[i][j] - HH[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M3);


    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = DD[i][j];
            T2[i][j] = GG[i][j] - EE[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M4);


    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            T1[i][j] = AA[i][j] + BB[i][j];
            T2[i][j] = HH[i][j];
        }
    }
    strassen(Shiftt,T1,T2,M5);

    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            A1[i][j] = M1[i][j] + M4[i][j] - M5[i][j] + M7[i][j] ;
            A2[i][j] = M3[i][j] + M5[i][j] ;
            A3[i][j] = M2[i][j] + M4[i][j] ;
            A4[i][j] = M1[i][j] - M2[i][j] + M3[i][j] + M6[i][j] ;
        }
    }
    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            z[i][j] = A1[i][j];
        }
    }
    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            z[i][j+Shiftt] = A2[i][j];
        }
    }
    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            z[i+Shiftt][j] = A3[i][j];
        }
    }
    for(int i = 0 ; i < Shiftt ; i++)
    {
        for(int j = 0 ; j < Shiftt ; j++)
        {
            z[i+Shiftt][j+Shiftt] = A4[i][j];
        }
    }
}
}


int main()
{
int t,n;
freopen("input_file.txt","r",stdin);
cin >> t;
while(t--)
{
    int vl ;
    scanf("%d",&n);
    cout <<  "value of n " << n  << endl ;;
    vector< vector<int> >u(n,vector<int>(n));
    vector< vector<int> >v(n,vector<int>(n));
    vector< vector<int> >z(n,vector<int>(n));
    vector< vector<int> >zz(n,vector<int>(n));
    vector<int> temp;
    for(int i = 0 ; i < n ; i++)
    {
            vector<int> temp;
        for(int j = 0 ; j < n ; j++)
        {
            scanf("%d",&vl);
            temp.push_back(vl);
        }
        u[i] = temp;
    }
    for(int i = 0 ; i < n ; i++)
    {
        vector<int> temp;
        for(int j = 0 ; j < n ; j++)
        {
            scanf("%d",&vl);
            temp.push_back(vl);
        }
        v[i] = temp;
    }
    clock_t start , end ;

    //USING NAIVE APPROACH

    start = clock();
            cout<<"Traditional Algorithm Running Time : ";
    normalmul(n,u,v,z);

    end = clock() ;

    cout<<(double)(end-start)/CLOCKS_PER_SEC<<" seconds"<<endl ;


    /*cout << "ANSWER OF MULTIPLICATION BY NAIVE APPROACH" << endl ;
    for(int i = 0 ; i < n ; i++)
    {
        for(int j = 0 ; j  < n ; j++)
        {
            cout << z[i][j] << " ";
        }
        cout << endl ;
    }*/


    //USING STRASSENS ALGORITHM 

    start = clock() ;

    strassen(n,u,v,zz);

    end = clock();
            cout<<"Strassen Algorithm Running Time : ";
    cout<<(double)(end-start)/CLOCKS_PER_SEC<<" seconds"<<endl ;

    /*cout << "ANSWER BY STRASSENS ALGORITHM " << endl ;
    for(int i = 0 ; i < n ; i++)
    {
        for(int j = 0 ; j  < n ; j++)
        {
            cout << zz[i][j] << " ";
        }
        cout << endl ;
    }*/
}
return 0;
    */  IPG_2011006   Abhishek Yadav */
}

在此处输入代码：
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
void fun（向量&u，向量&m，整数P，整数n）
{
对于（int i=0；i&u，向量&v，向量&z）
{
对于（int i=0；i&u，向量&v，向量&z）
{
如果（n==32）
{
法线（n，u，v，z）；
返回；
}
其他的
{
int Shiftt=n>>1；
向量a（Shiftt，向量（Shiftt））；
向量BB（Shiftt，向量（Shiftt））；
vectorCC（Shiftt，vector（Shiftt））；
向量dd（Shiftt，向量（Shiftt））；
向量机（Shiftt，向量机（Shiftt））；
向量（Shiftt，向量（Shiftt））；
向量（Shiftt，向量（Shiftt））；
向量hh（Shiftt，向量（Shiftt））；
向量A1（Shiftt，向量（Shiftt））；
向量A2（Shiftt，向量（Shiftt））；
向量A3（Shiftt，向量（Shiftt））；
向量4（Shiftt，向量（Shiftt））；
乐趣（u，AA，1，n>>1）；
乐趣（u，BB，2，n>>1）；
乐趣（u，CC，3，n>>1）；
乐趣（u，DD，4，n>>1）；
乐趣（v，EE，1，n>>1）；
乐趣（v，FF，2，n>>1）；
乐趣（v，GG，3，n>>1）；
乐趣（v，HH，4，n>>1）；
向量1（Shiftt，向量（Shiftt））；
向量2（Shiftt，向量（Shiftt））；
向量3（Shiftt，向量（Shiftt））；
向量4（Shiftt，向量（Shiftt））；
向量5（Shiftt，向量（Shiftt））；
向量6（Shiftt，向量（Shiftt））；
向量7（Shiftt，向量（Shiftt））；
向量1（Shiftt，向量（Shiftt））；
向量2（Shiftt，向量（Shiftt））；
对于（int i=0；i