稀疏矩阵类

稀疏矩阵类

Design a class Sparse that implements interface Matrix: Sparse should has the following public object functions in addition:

1. A constructor Sparse(int rows, int column), which initializes all elements in the matrix to 0's.
2. A function Sparse Sparse::operator + (Sparse & sparse2), which returns the pair-wise sum of two sparse matrixes.
3. A function Sparse Sparse::operator * (Sparse & sparse2), which returns the product of two sparse matrixes.

HINT

稀疏矩阵是大多数元素都为0的矩阵。
因此，存储稀疏矩阵的时候只存储不为0的元素可以节省空间。
例如，完整地存储一个1000000 * 1000000的浮点数矩阵需要8 TB的内存。
但是，如果矩阵只有10个非0元素，那么我们只需记录这10个元素在矩阵中的位置和值。
要记录这10个元素中的每一个，我们可以使用一个3元组(行,列,值)，这个3元组的类Entry已经在主程序定义好。
要记录这10个元素，我们可以用一个vector存储10个Entry的对象。
要获得这10个非0元素的值，只需查找这个vector。
位置(行,列)不在这个vector中的元素，就是值为0的元素。
题目中要求实现的print函数，只输出非0元素(的3元组表示)。顺序为小行优先，同行则小列优先。

例如：

A、B都是1000000*1000000的矩阵
矩阵A：
	(1,1,10)
	(1,2000000,50)
	(1000000,2000000,20)
矩阵B：
	(1,3000000,30)
	(2000000,1,40)
	(1,1,-10)

C是1000000*2000000的矩阵
D是2000000*3000000的矩阵
矩阵C：
	(1,1,10)
	(1,2000000,50)
	(1000000,2000000,20)
矩阵D：
	(1,3000000,30)
	(2000000,1,40)
	(1,1,-10)

A+B得:
	(1,1000000,80)
	(1000000,1,40)
	(1000000,1000000,20)
C*D得:
	(1,1,1900)
	(1,3000000,300)
	(1000000,1,800)

#include<vector>
#include<algorithm>
 #include <iostream> 
 using namespace std; 
 
class Entry
{
public:
	int row;
	int column;
	double value;
};
	
class Matrix
{	
public:
	virtual int size(int dimension) const = 0;
	
	virtual void set(int row, int column, 
	double value) = 0;
	
	virtual double get(int row, int column) 
	const = 0;
	
	virtual void print() = 0;
	
};

  
bool Comp1(const Entry &a,const Entry &b)
{
	return a.row<b.row;
}
bool Comp2(const Entry &a,const Entry &b)
{
	return (a.row==b.row&&a.column<b.column);
}
class Sparse : public Matrix
{
private:
	int _rows, _columns;
	vector<Entry> entry;
public:
	Sparse(int rows, int column)
	{
		_rows = rows;
		_columns = column;
		entry = vector<Entry>();
	}
	int size(int dimension) const
	{
		if(dimension == 1) return _rows;
		if(dimension == 2) return _columns;
	}
	void set(int row, int column, double value)
	{
		Entry e;
		e.row = row;
		e.column = column;
		e.value = value;
		entry.push_back(e);
	}
	double get(int row, int column) const
	{
		for(int i=0; i < entry.size();i++)
		{
			if(entry[i].row == row
				 && entry[i].column == column ){
				return entry[i].value;	
			}
		}
	}
	void print()
	{
		for(int i=0; i < entry.size();i++)
		{
			cout<<"("<<entry[i].row<<","<<entry[i].column<<","
				<<entry[i].value<<")
";
		}
	}
    //稀疏矩阵的 加法运算
	Sparse operator + (Sparse & sparse2)
	{
		Sparse s(_rows, _columns);

		for(int i=0; i < this->entry.size(); i++)
		{
			for(int j = 0 ;j< sparse2.entry.size(); j++)
			{
				if(this->entry[i].row == sparse2.entry[j].row 
					&& this->entry[i].column == sparse2.entry[j].column){
					Entry e;
					e.row = sparse2.entry[j].row;
					e.column =  sparse2.entry[j].column;
					e.value = this->entry[i].value + sparse2.entry[j].value;
					
					if(e.value)
					s.entry.push_back(e);
					
					this->entry[i].value = 0;
					sparse2.entry[j].value = 0;
				}
				
			}
		}
		for(int i=0; i < this->entry.size(); i++)
		{
			Entry e;
			e.row = this->entry[i].row;
			e.column = this->entry[i].column;
			e.value = this->entry[i].value;
			if(e.value)
				s.entry.push_back(e);
		}
		for(int i=0; i < sparse2.entry.size(); i++)
		{
			Entry e;
			e.row = sparse2.entry[i].row;
			e.column = sparse2.entry[i].column;
			e.value = sparse2.entry[i].value;
			if(e.value)
				s.entry.push_back(e);
		}
		sort(s.entry.begin(),s.entry.end(),Comp1);
		sort(s.entry.begin(),s.entry.end(),Comp2);
		
		return s;
	}
};
//稀疏矩阵的 乘法运算
Sparse operator * (Sparse & sparse2)
	{
		Sparse s(_rows, sparse2._columns);

		for(int i=0; i < this->entry.size(); i++)
		{
			for(int j = 0 ;j< sparse2.entry.size(); j++)
			{
				if(this->entry[i].column == sparse2.entry[j].row ){
				   
				   Entry e;
					e.row =this->entry[i].row;
					e.column =  sparse2.entry[j].column;
					e.value = this->entry[i].value * sparse2.entry[j].value;
					int isIns = 0;
					int index = -1;
					for(int k = 0 ; k < s.entry.size();k++){
						if(s.entry[k].row == e.row && s.entry[k].column == e.column){
							isIns = 1;
							index = k;
						}
					}
					if(e.value && isIns == 0)
					s.entry.push_back(e);
					if(e.value && isIns == 1){
						s.entry[index].value += e.value;
					}
				}
				
			}
		}
		
		sort(s.entry.begin(),s.entry.end(),Comp1);
		sort(s.entry.begin(),s.entry.end(),Comp2);
		
		return s;
	}
void print(Matrix & matrix) {
	matrix.print();
}

void readAndSetElement(Matrix & matrix) {
	int row;
	int column;
	double value;
	cin >> row >> column >> value;
	matrix.set(row, column, value);
}

void readAndSetMultipleElements(Matrix & matrix, int count) {
	for (int i = 0; i < count; ++ i) {
		readAndSetElement(matrix);
	}
}

int main() {
	int rows;
	int columns;
	cin >> rows >> columns;
	
	Sparse sparse1(rows, columns);
	readAndSetMultipleElements(sparse1, 3);
	
	Sparse sparse2(rows, columns);
	readAndSetMultipleElements(sparse2, 3);
	
	Sparse sparse3 = sparse1 + sparse2;
	print(sparse3);
}