矩阵的加法、乘法计算
创建 稀疏矩阵类 ,采用行主顺序把稀疏矩阵非0元素映射到一维数组中,提供操作:两个稀疏矩阵相加、两个稀疏矩阵相乘、输出矩阵。
键盘输入矩阵的行数、列数;并按行优先顺序输入矩阵的各元素值,建立矩阵;
对建立的矩阵执行相加、相乘的操作,输出操作的结果矩阵。
操作描述
为方便操作描述,我们假设存在一个矩阵P,下列各操作实际为对矩阵P的操作。
重置矩阵:
1
矩阵的行数n 矩阵的列数m
[n行m列 表示矩阵中的所有元素]
即重置矩阵P的尺寸为n行m列,且随后按行优先顺序输入矩阵P的各个元素。
矩阵乘法:
2
矩阵的行数 矩阵的列数
[n行m列 表示矩阵中的所有元素]
设输入的矩阵为Q,若PxQ运算合法,则将PxQ的结果矩阵赋给P,若不合法,则将Q赋给P,同时输出-1。
矩阵加法:
3
矩阵的行数 矩阵的列数
[n行m列 表示矩阵中的所有元素]
设输入的矩阵为Q,若P+Q运算合法,则将P+Q的结果矩阵赋给P,若不合法,则将Q赋给P,同时输出-1。
输出操作:
4
设当前矩阵P的尺寸为n行m列,第一行输出矩阵P的行数和列数,随后n行按行优先顺序输出矩阵P,每行m个数字,来表示当前的矩阵内容,每行数字之间用空格分隔。
输入格式
第一行一个w(1<=w<=40)代表操作个数,接下来若干行是各个操作,其中保证第一个操作一定为重置矩阵。
输出格式
当执行操作4时,输出矩阵P;当执行操作2或3时,若对应运算不合法,则输出-1。
Sample Input
5
1
3 3
3 4 0
0 2 1
4 1 1
2
2 3
4 1 1
2 2 3
4
3
2 3
1 2 3
2 2 3
4
Sample Output
-1
2 3
4 1 1
2 2 3
2 3
5 3 4
4 4 6
限制
矩阵的行数n与列数m一定为整数,且1<=n,m<=40。
1s, 64MB for each test case。
#include<iostream>
using namespace std;
const long long int maxsz=9999999;
template<class T>
struct triple{
int row,col;
T value;
triple& operator=(triple& x){
row=x.row;
col=x.col;
value=x.value;
return *this;
}
};
template<class T>
class sparseMatrix{
private:
int rows;//行
int cols;//列
int terms;//非零元素个数
triple<T>* tArray;//用来存value的数组
public:
~sparseMatrix(){delete[] tArray;};//析构函数
sparseMatrix(int &m,int &n);//构造函数
void change(int m,int n);
void sparseMatrix1(sparseMatrix& a);//复制函数
void input();//重置1
int multiply(sparseMatrix<T> &b);//乘法2
int add(sparseMatrix<T> &b);//加法3
void output();//输出4
};
//构造函数 ,初始化
template<class T>
sparseMatrix<T>::sparseMatrix(int &m,int &n)
{
rows=m;cols=n;
terms=0;
tArray=new triple<T> [maxsz];
}
template<class T>
void sparseMatrix<T>::change(int m,int n)
{
rows=m;
cols=n;
}
template<class T>
void sparseMatrix<T>::sparseMatrix1(sparseMatrix& a)
{
rows=a.rows; //赋值矩阵的性质
cols=a.cols;
terms=a.terms;
for(int i=0;i<terms;i++){
tArray[i].row=a.tArray[i].row;
tArray[i].col=a.tArray[i].col;
tArray[i].value=a.tArray[i].value;
}
}
//重置矩阵1
template<class T>
void sparseMatrix<T>::input()
{
T elem;terms=0;
for(int i=0;i<rows*cols;i++)
{
cin>>elem;
if(elem!=0){
tArray[terms].value=elem;
tArray[terms].col=i-(i/cols)*cols+1;
tArray[terms].row=i/cols+1;
terms++;
}
}
/*if(terms==0){
tArray[terms].row=1;
tArray[terms].col=1;
tArray[terms].value=0;
terms=1;
}*/
}
//乘法
template<class T>
int sparseMatrix<T>::multiply(sparseMatrix<T> &b)
{
if(cols!=b.rows){
sparseMatrix1(b);
return -1;
}
else{
sparseMatrix<T> c(rows,b.cols);
T* tag=new T[b.cols+1];
for(int i=0;i<b.cols+1;i++)
tag[i]=0;
for(int j=0;j<terms;j++)
{
for(int k=0;k<b.terms;k++)
if(tArray[j].col==b.tArray[k].row)
tag[b.tArray[k].col]+=tArray[j].value*b.tArray[k].value;
//分析知道↑,当被乘数的列==乘数的行时,两个数可相乘,且不为0
if((j<terms-1&&tArray[j].row!=tArray[j+1].row)||j==terms-1)
{
for (int h = 1; h < b.cols+1; h++)
{
if (tag[h] != 0)
{
c.tArray[c.terms].row = tArray[j].row;
c.tArray[c.terms].col = h;
c.tArray[c.terms].value= tag[h];
tag[h] = 0;
c.terms++;
}
}
}
}
sparseMatrix1(c);
return 0;
}
}
//加法3
template<class T>
int sparseMatrix<T>::add(sparseMatrix<T>& b)
{
if(rows!=b.rows || cols !=b.cols)
{
sparseMatrix1(b);
return -1;
}
else{//设置结果矩阵的特征
sparseMatrix<T> c(rows,cols);
int it=0,ib=0;
while(it!=terms && ib !=b.terms){
int tIndex=(tArray[it]).row*cols+(tArray[it]).col;
int bIndex=b.tArray[ib].row*cols+(b.tArray[ib]).col;
if(tIndex<bIndex)
{
c.tArray[c.terms].col=tArray[it].col;
c.tArray[c.terms].row=tArray[it].row;
c.tArray[c.terms].value=tArray[it].value;
it++;c.terms++;
}
else {
if(tIndex==bIndex){
if((tArray[it]).value+(b.tArray[ib]).value!=0)
{
c.tArray[c.terms].col=(tArray[it]).col;
c.tArray[c.terms].row=(tArray[it]).row;
c.tArray[c.terms].value=(tArray[it]).value+(b.tArray[ib]).value;
c.terms++;
}
it++;ib++;
} //
else
{
c.tArray[c.terms].col=b.tArray[ib].col;
c.tArray[c.terms].row=b.tArray[ib].row;
c.tArray[c.terms].value=b.tArray[ib].value;
ib++;c.terms++;
}
}
}
//复制剩余项
for(;it != terms;it++)
{
c.tArray[c.terms].col=tArray[it].col;
c.tArray[c.terms].row=tArray[it].row;
c.tArray[c.terms].value=tArray[it].value;
c.terms++;
}
for(;ib !=b.terms;ib++)
{
c.tArray[c.terms].col=b.tArray[ib].col;
c.tArray[c.terms].row=b.tArray[ib].row;
c.tArray[c.terms].value=b.tArray[ib].value;
c.terms++;
}
sparseMatrix1(c);
return 0;
}
}
template<class T>
void sparseMatrix<T>::output()
{
int k=0;
cout<<rows<<" "<<cols<<endl;
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
if(k<terms && tArray[k].row==i+1 && tArray[k].col==j+1)
cout<<tArray[k++].value<<" ";
else
cout<<0<<" ";
}
cout<<endl;
}
}
int main()
{
int w,x,deci=0,m=0,n=0;
sparseMatrix<int> sm(m,n);
cin>>w;
for(int i=0;i<w;i++){
cin>>x;
if(x==1)//输入
{
cin>>m>>n;
sm.change(m,n);
sm.input();}
else if(x==2)//乘法
{
cin>>m>>n;
sparseMatrix<int> a(m,n);
a.input();
deci=sm.multiply(a);
if(deci==-1)
cout<<deci<<endl;;
}
else if(x==3)//加法
{
cin>>m>>n;
sparseMatrix<int> b(m,n);
b.input();
deci=sm.add(b);
if(deci==-1)
cout<<deci<<endl;
}
else//输出
sm.output();
}
return 0;
}
这里矩阵乘法按照列计算的,若要降低算法的复杂度,乘法需要改变为按行计算,也即是被乘数的行。