PTA 7-4 矩阵的乘法运算

线性代数中的矩阵可以表示为一个row＊column的二维数组，当row和column均为1时，退化为一个数，当row为1时，为一个行向量，当column为1时，为一个列向量。 建立一个整数矩阵类matrix，其私有数据成员如下：

int row;
int column;
int **mat;

建立该整数矩阵类matrix构造函数； 建立一个 *（乘号）的运算符重载，以便于对两个输入矩阵进行乘法运算； 建立输出函数void display()，对整数矩阵按行进行列对齐输出，格式化输出语句如下：

cout<<setw(10)<<mat[i][j];
//需要＃include <iomanip>

主函数里定义三个整数矩阵类对象m1、m2、m3. ###输入格式： 分别输入两个矩阵，分别为整数矩阵类对象m1和m2。 每个矩阵输入如下： 第一行两个整数 r c，分别给出矩阵的行数和列数 接下来输入r行，对应整数矩阵的每一行 每行输入c个整数，对应当前行的c个列元素 ###输出格式： 整数矩阵按行进行列对齐（宽度为10）后输出 判断m1和m2是否可以执行矩阵相乘运算。 若可以，执行m3=m1*m2运算之后，调用display函数，对m3进行输出。 若不可以，输出"Invalid Matrix multiplication!" 提示：输入或输出的整数矩阵，保证满足row>=1和column>=1。

输入样例：

4  5
1 0 0 0 5
0 2 0 0 0
0 0 3 0 0
0 0 0 4 0
5  5
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 8 9
5 6 7 8 9

输出样例：

        26        32        38        44        50
         4         6         8        10        12
         9        12        15        18        21
        16        20        24        32        36

矩阵乘法就不多说了，这题关键的地方有这几个：

1.判断是否能进行矩阵乘法，假设是A * B,也就是看A的列数和B的行数是否相等，但是要注意，当两个矩阵之中，有一个是1*1矩阵，此时这个矩阵就是一个数了，相当于矩阵的数乘运算，这种情况要单独做判断和相应的运算

2.行距的设置，需要用到函数setw()

代码如下：

#include<iostream>
#include<iomanip>
using namespace std;
class Matrix
{
	friend Matrix operator*(const Matrix& m1, const Matrix& m2);
	friend bool isMatrix(const Matrix& m1, const Matrix& m2);
	friend void isSingal(Matrix& tmp, const Matrix& m, int r, int c, int s);
private:
	int row;
	int col;
	int** mat;
public:
	void get(int r, int c)
	{
		row = r;
		col = c;
		mat = new int* [r];
		for (int i = 0; i < r; i++)
		{
			mat[i] = new int[c];
		}
		for (int i = 0; i < r; i++)
		{
			for (int j = 0; j < c; j++)
			{
				cin >> mat[i][j];
			}
		}
	}
	void show()
	{
		int i, j;
		for (i = 0; i < row; i++)
		{
			for (j = 0; j < col; j++)
			{
				cout << setw(10) << mat[i][j];
			}
			cout << endl;
		}
	}

	~Matrix()
	{
		if (mat != NULL)
		{
			for (int i = 0; i < row; i++)
			{
				delete[] mat[i];
				mat[i] = NULL;
			}
			delete[] mat;
			mat = NULL;
		}
	}
};

bool isMatrix(const Matrix& m1, const Matrix& m2)
{
	if ((m1.row == 1 && m1.col == 1) || (m2.row == 1 && m2.col == 1))
		return true;
	if (m1.col != m2.row)
		return false;
	return true;
}

void isSingal(Matrix &tmp, const Matrix& m, int r, int c, int s)
{
	tmp.row = r;
	tmp.col = c;
	tmp.mat = new int* [r];
	for (int i = 0; i < r; i++)
	{
		tmp.mat[i] = new int[c];
	}
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			tmp.mat[i][j] = m.mat[i][j] * s;
		}
	}
}

Matrix operator*(const Matrix& m1, const Matrix& m2)
{
	Matrix tmp;
	if (m1.col == m1.row && m1.col == 1)
	{
		isSingal(tmp, m2, m2.row, m2.col, m1.mat[0][0]);
	}
	else if (m2.col == m2.row && m2.col == 1)
	{
		isSingal(tmp, m1, m1.row, m1.col, m2.mat[0][0]);
	}
	else
	{
		tmp.row = m1.row;
		tmp.col = m2.col;
		tmp.mat = new int* [m1.row];
		int k = 0;
		for (int i = 0; i < m1.row; i++)
		{
			tmp.mat[i] = new int[m2.col];
		}
		for (int i = 0; i < m1.row; i++)
		{
			for (int j = 0; j < m2.col; j++)
			{
				int sum = 0;
				for (k = 0; k < m1.col; k++)
				{
					sum += m1.mat[i][k] * m2.mat[k][j];
				}
				tmp.mat[i][j] = sum;
			}
		}
	}
	return tmp;
}

int main()
{
	int r, c;
	cin >> r >> c;
	Matrix m1;
	m1.get(r, c);

	cin >> r >> c;
	Matrix m2;
	m2.get(r, c);

	if (isMatrix(m1, m2))
	{
		Matrix m3 = m1 * m2;
		m3.show();
	}
	else
	{
		cout << "Invalid Matrix multiplication!" << endl;
	}
	return 0;
}