一道算法的作业题，Strassen算法，C++实现，大家帮忙看看

[wilcox1937]

有２个２Ｘ２的矩阵Ａ，Ｂ和一个结果局阵Ｃ
现在用如下的Strassen算法实现A X B=C
P=(a11+a22)(b11+b22)
Q=(a21+a22)b11
R=a11(b12-b22)
S=a22(b21-b11)
T=(a11+a12)b22
U=(a21-a11)(b11+b12)
V=(a12-a22)(b21+b22)


c11=P+S-T+V
c12=R+T
c21=Q+S
c22=P+R-Q+U

现在要推广到２个８Ｘ８的矩阵乘法，用到递归，上课的时候没听仔细，达人帮帮忙．

[cxjddd]

有谁再给他上节课吧。

可以用递归吧。把 8*8 的看成一个 2*2 的，这样又可以把 4*4 的看成 2*2 的，然后又是一个 2*2 的。

晕啊，我说得好糊涂n_n

[wilcox1937]

楼上的我知道的，先前我也是这么想的，但用Ｃ＋＋实现起来我有点没方向，能给点代码吗？

[kbsoft]

把这个帖子移到算法版。

[brxren]

可不可以把8*8的矩阵分成4个4*4的矩阵，再把4*4的分成4个2*2的矩阵阿？那么原来2*2的算法里所谓的a11,a12,a21,a22在没有达到2*2之前就表示矩阵，达到2*2，就表示一个数。不知可不可以！

[wilcox1937]

楼上的意思和我前面说的差不多，就是不知道怎么实现，我头都昏了，哪位给个代码饿，谢谢

[liansdan]

U

[kxw]

我看得很明白

[wilcox1937]

还要用到面向对象啊，很麻烦啊，不过还是谢谢fangrk(加把油，伙计！) 。
能不能简单点啊？？（是不是我要求太高了？？）

[fangrk]

由于需要动态产生“矩阵”，所以只能借助对象的析构函数来完成这个使命。使用vector使得资源泄漏的问题最小化。我觉得没法再简单了。

[wilcox1937]

是吗？多谢了，难怪我想到后来头昏了，思路都理不过来了，多谢 fangrk(加把油，伙计！) 指点了。

[fangrk]

#include <iostream>
#include <vector>
using namespace std;

class Matrix
{
public:
Matrix(int);
Matrix(const Matrix&);
Matrix& operator=(const Matrix&);
int operator()(int,int) const;
int& operator()(int,int);
Matrix& operator +=(const Matrix&);
Matrix& operator -=(const Matrix&);
Matrix& operator *=(int);
Matrix& operator *=(const Matrix&);
Matrix GetQuarter(int) const ;//得到1/4个矩阵
Matrix& SetQuarter(const Matrix&,int);//设置1/4个矩阵
int Side() const;//矩阵的行/列
void Show() const;//打印矩阵
private:
void Malloc(int);//设置一个仿二维数组的大小
const int MN;//矩阵的行/列
vector< vector<int> > Data;//矩阵的数据
};

Matrix operator +(const Matrix&,const Matrix&);//全局函数:矩阵相加
Matrix operator -(const Matrix&,const Matrix&);//全局函数:矩阵相减
Matrix operator *(int,const Matrix&);//全局函数:整数乘以矩阵,在本程序中没用到
Matrix operator *(const Matrix&,int);//全局函数:矩阵乘以整数,在本程序中没用到
Matrix operator *(const Matrix&,const Matrix&);//全局函数:矩阵相乘

void Matrix::Malloc(int mn)//设定一个仿二维数组,大小为mn*mn;
{
Data.resize(mn);
for(int i=0;i<mn;++i)
Data[i].resize(mn);
}

Matrix::Matrix(int mn):MN(mn)
{
Malloc(MN);
}

Matrix::Matrix(const Matrix& rhs):MN(rhs.MN)//拷贝构造
{
Malloc(MN);
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]=rhs.Data[i][j];
}

Matrix& Matrix::operator=(const Matrix& rhs)//矩阵赋值
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]=rhs.Data[i][j];
return *this;
}

int Matrix::operator()(int m,int n) const//得到矩阵的某个元素,坐标从0开始
{ return Data[m][n];
}

int& Matrix::operator()(int m,int n)//得到矩阵的某个元素,坐标从0开始,可以赋值
{ return Data[m][n];
}

Matrix& Matrix::operator +=(const Matrix& rhs)//类公开函数,A+=B;
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]+=rhs.Data[i][j];
return *this;
}

Matrix& Matrix::operator -=(const Matrix& rhs)//类公开函数,A-=B;
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]-=rhs.Data[i][j];
return *this;
}

Matrix& Matrix::operator *=(int Num)//类公开函数,A*=i;
{
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]*=Num;
return *this;
}

Matrix Matrix::GetQuarter(int Pos) const//得到1/4个矩阵,Pos=0代表左上,Pos=1代表右上...
{
int X,Y;
switch(Pos%4)
{
case 0:X=Y=0;break;
case 1:X=0;Y=MN/2;break;
case 2:X=MN/2;Y=0;break;
case 3:X=Y=MN/2;
}
Matrix T(MN/2);
for(int i=0;i<T.MN;++i)
for(int j=0;j<T.MN;++j)
T.Data[i][j]=Data[i+X][j+Y];
return T;
}

Matrix& Matrix::SetQuarter(const Matrix& rhs,int Pos)//把rhs的值拷贝为自身的1/4个矩阵,Pos含义同上
{
int X,Y;
switch(Pos%4)
{
case 0:X=Y=0;break;
case 1:X=0;Y=MN/2;break;
case 2:X=MN/2;Y=0;break;
case 3:X=Y=MN/2;
}
for(int i=0;i<rhs.MN;++i)
for(int j=0;j<rhs.MN;++j)
Data[i+X][j+Y]=rhs.Data[i][j];
return *this;
}

int Matrix::Side() const//得到行/列
{
return MN;
}

Matrix& Matrix::operator *=(const Matrix& rhs)//类公开函数 A*=B;
{
*this= *this * rhs;//调用全局函数:矩阵相乘
return *this;
}

void Matrix::Show() const//打印矩阵
{ cout<<"Display Matrix:"<<endl;
for(int i=0;i<MN;++i){
for(int j=0;j<MN;++j)
cout<<Data[i][j]<<' ';
cout<<endl;
}
}

Matrix operator +(const Matrix& rhs1,const Matrix& rhs2)//全局函数:矩阵相加
{
Matrix T(rhs1);
return T+=rhs2;//调用类公开函数+=
}

Matrix operator -(const Matrix& rhs1,const Matrix& rhs2)//全局函数:矩阵相减
{
Matrix T(rhs1);
return T-=rhs2;//调用类公开函数-=
}

Matrix operator *(int Num,const Matrix& rhs)//全局函数:整数乘以矩阵
{
Matrix T(rhs);
return T*=Num;//调用类公开函数*=
}

Matrix operator *(const Matrix& rhs,int Num)//全局函数:矩阵乘以整数
{
Matrix T(rhs);
return T*=Num;//调用类公开函数*=
}

Matrix operator *(const Matrix& rhs1,const Matrix& rhs2)//全局函数,矩阵相乘
{ if(rhs1.Side()!=rhs2.Side()) throw;
if(rhs1.Side()==2){//行/列为2,按照常规方法计算
Matrix T(2);
T(0,0)=rhs1(0,0)*rhs2(0,0)+rhs1(0,1)*rhs2(1,0);//A11B11+A12B21;
T(0,1)=rhs1(0,0)*rhs2(0,1)+rhs1(0,1)*rhs2(1,1);//A11B12+A12B22
T(1,0)=rhs1(1,0)*rhs2(0,0)+rhs1(1,1)*rhs2(1,0);//A21B11+A22B21
T(1,1)=rhs1(1,0)*rhs2(0,1)+rhs1(1,1)*rhs2(1,1);//A21B12+A22B22
return T;
};
Matrix A11(rhs1.GetQuarter(0));//第一个矩阵的左上1/4矩阵
Matrix A12(rhs1.GetQuarter(1));//第一个矩阵的右上1/4矩阵
Matrix A21(rhs1.GetQuarter(2));//第一个矩阵的左下1/4矩阵
Matrix A22(rhs1.GetQuarter(3));//第一个矩阵的右下1/4矩阵
Matrix B11(rhs2.GetQuarter(0));//第二个矩阵的左上1/4矩阵
Matrix B12(rhs2.GetQuarter(1));//第二个矩阵的右上1/4矩阵
Matrix B21(rhs2.GetQuarter(2));//第二个矩阵的左下1/4矩阵
Matrix B22(rhs2.GetQuarter(3));//第二个矩阵的右下1/4矩阵
Matrix M1(A11*(B12-B22));//递归调用全局函数,矩阵相乘
Matrix M2((A11+A12)*B22);//递归调用全局函数,矩阵相乘
Matrix M3((A21+A22)*B11);//递归调用全局函数,矩阵相乘
Matrix M4(A22*(B21-B11));//递归调用全局函数,矩阵相乘
Matrix M5((A11+A22)*(B11+B22));//递归调用全局函数,矩阵相乘
Matrix M6((A12-A22)*(B21+B22));//递归调用全局函数,矩阵相乘
Matrix M7((A11-A21)*(B11+B12));//递归调用全局函数,矩阵相乘
Matrix C11(M5+M4-M2+M6);//调用全局函数,矩阵相加/减
Matrix C12(M1+M2);//调用全局函数,矩阵相加
Matrix C21(M3+M4);//调用全局函数,矩阵相加
Matrix C22(M5+M1-M3-M7);//调用全局函数,矩阵相加/减

Matrix T(rhs1.Side());//返回的矩阵
//设置C11-C22为T的四个小矩阵
T.SetQuarter(C11,0).SetQuarter(C12,1).SetQuarter(C21,2).SetQuarter(C22,3);
return T;
}

bool Is2Pow(int i)//判断i是否是2的n次方
{ if(i<2) return false;
while(i>2){
if(i%2) return false;
i/=2;
}
return i==2 ? true:false;
}
int main()
{ int M;
cout<<"Input two matrixes[M*M],and culculate multiply with Strassen!"<<endl;
cout<<"M=";
cin>>M;
if(Is2Pow(M)==false){
cout<<"Error:M should equal 2^n";
return 1;
}
cout<<"Input Matrix A["<<M<<"*"<<M<<"]:"<<endl;
Matrix A(M);
for(int i=0;i<M;++i)
for(int j=0;j<M;++j)
cin>>A(i,j);
cout<<"Input Matrix B["<<M<<"*"<<M<<"]:"<<endl;
Matrix B(M);
for(int i=0;i<M;++i)
for(int j=0;j<M;++j)
cin>>B(i,j);
Matrix AB(A*B);
cout<<"A*B"<<endl;
AB.Show();
Matrix BA(B*A);
cout<<"B*A"<<endl;
BA.Show();
return 0;
}

[fangrk]

我半年前写的，直接拷贝上来了。

这道题是女友读研究生一年级下半学期时候的算法题目。用面向对象吧！不然很难的！

不要转移帖子了吧！：）

[Flamesong]

我就是静不下心来研究这些玩意,感觉比较遥远.

[wilcox1937]

没人能帮我吗？惨了，5555555555555

[ZhangYv]

很多高中生上算法课也会讲到这个经典的基本动态规划的例子，用不着研究生 ：）