稀疏矩阵的表示和运算

稀疏矩阵的表示和运算

Time Limit: 1 Sec  Memory Limit: 128 M[Submit][Status][Web Board]

Description

如果一个矩阵中，0元素占据了矩阵的大部分，那么这个矩阵称为“稀疏矩阵”。对于稀疏矩阵，传统的二维数组存储方式，会使用大量的内存来存储0，从而浪费大量内存。为此，我们可以用三元组的方式来存放一个稀疏矩阵。
对于一个给定的稀疏矩阵，设第r行、第c列值为v，且v不等于0，则这个值可以表示为<r, c, v>。这个表示方法就称为三元组。那么，对于一个包含N个非零元素的稀疏矩阵，就可以用一个由N个三元组组成的表来存储了。
如：{<1, 1, 9>, <2, 3, 5>, <10, 20, 3>}就表示这样一个矩阵A：A[1,1]=9，A[2,3]=5，A[10,20]=3。其余元素为0。
现在请定义Triple类，用来表示稀疏矩阵的三元组存储方法，并重载其输出、输入、加法运算符。

Input

输入包括N+M+2行，其中前N+1行为第一个矩阵的三元组数据，后M+1行是第2个矩阵的三元组数据。
每个矩阵的三元组数据中，每个三元组占1行。每行的格式为：
r c v
其中，r、c为三元组中对应矩阵的非零元素的行号、列号；v是该位置的值。r、c都是非负整数，v是非零整数。
当r=c=v=0时，表示该矩阵的输入结束。
所有输入均在int类型范围内。
由于没有输入矩阵的行数和列数，假定两个矩阵一定是可加的。

Output

对于给定的两个矩阵，求它们的和，并输出。输出仍然采用三元组的方式，每行输出一个三元组，格式为：
r c v
其中r、c是正整数，表示该元素的行号、列号；v是非零值，表示元素值。
输出时，要求按照行优先顺序来输出所有非零元素。也就是说，对于两行输出：
r1 c1 v1
r2 c2 v2
必须满足：r1<r2或者r1=r2&&c1<c2。

Sample Input

1 1 102 2 503 4 600 0 01 1 112 2 513 4 615 5 700 0 0

Sample Output

1 1 212 2 1013 4 1215 5 70

HINT

注意：
1.输入时的顺序不一定是行优先的顺序，所以在计算前，应该要进行“排序”。
2. 输出时，如果求和之后，对应位置的元素为0，那么三元组不应存储。也就是说，不能输出矩阵元素为0的三元组。

Append Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Three
{
public :
int r,c,v;
Three ()
{

}
Three (int ri,int ci,int vi)
{
r=ri;
c=ci;
v=vi;
}
bool operator<(const Three &t) const
{
if (r<t.r)
return true;
else if (r==t.r&&c<t.c)
return true;
else
return false ;
}
};
class Triple
{
public :
vector <Three> vec;
friend istream& operator>>(istream &is,Triple
9558
&p);
friend ostream& operator<<(ostream &os,const Triple &p);
Triple operator+(Triple &t)
{
Triple tmp;
vector <Three> ::iterator iter,iter2;
for (iter=vec.begin(); iter!=vec.end(); iter++)
{
int flag = 0;
for (iter2=t.vec.begin(); iter2!=t.vec.end(); iter2++)
{
if (iter->r==iter2->r&&iter->c==iter2->c)
{
flag=1;
Three three(iter->r,iter->c,iter->v+iter2->v);
tmp.vec.push_back(three);
}
}
if (flag==0)
tmp.vec.push_back(*iter);
}
for (iter2=t.vec.begin(); iter2!=t.vec.end(); iter2++)
{
int flag= 0;
for (iter=vec.begin(); iter!=vec.end(); iter++)
{
if (iter->r==iter2->r&&iter->c==iter2->c)
{
flag=1;
}
}
if (flag==0)
tmp.vec.push_back(*iter2);
}
sort (tmp.vec.begin(),tmp.vec.end());
return tmp;
}
} ;
istream& operator>>(istream &is,Triple &p)
{
Three tmp;
while(is>>tmp.r>>tmp.c>>tmp.v)
{
if (tmp.r==0 && tmp.c == 0 && tmp.v == 0)
return is;
else
p.vec.push_back(tmp);
}
return is;
}
ostream& operator<<(ostream &os, const Triple &p)
{
int len = p.vec.size();
vector<Three>::const_iterator  iter;  //在这里，Triple为const 所以得定义为 const_iterator,否则会报错！！！
//    for (iter = p.vec.begin(); iter!=p.vec.end(); iter++)
//    {
//        if (iter->v==0)
//            continue;
//        os<< (iter->r) <<" "<< (iter->c) <<" "<< (iter->v) <<endl;
//    }
for (int i = 0; i < len; i++)
{
if (p.vec[i].v==0)
continue;
os<< p.vec[i].r <<" "<< p.vec[i].c <<" "<< p.vec[i].v <<endl;
}
return os;
}

int main()
{
Triple mat1, mat2, mat3;
cin>>mat1;
cin>>mat2;
mat3 = mat1 + mat2;
cout<<mat3;
return 0;
}

这是这次模拟考试最后一个题目，思路很明确，很快写完代码之后。在下面跑的是对的，交上之后跑不起来。

记得上次也是跑不起来，后来问老师才知道 oj的编译器要求比一直用的codeblocks高，对于sort需要重载的小于运算符，还有输出都必须加const
模考时最后发现输出的for循环这段代码有问题，却也改不出来。无奈干脆没用迭代器。回来以后百度才知道，必须用const_iterator。