Problem H: 稀疏矩阵的表示和运算

Problem H: 稀疏矩阵的表示和运算

Time Limit: 1 Sec   Memory Limit: 128 MB
Submit: 155   Solved: 49
[ 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

append.cc,

#include <bits/stdc++.h>

using namespace std;

const int maxn =40000;
struct edge
{
    int r,c,v;
};
bool cmp(const edge &t1,const edge &t2 )
{
    if(t1.r!=t2.r)
        return t1.r<t2.r;
    else return t1.c<t2.c;
}
class Triple
{
public:
    edge es[maxn];
    int len;
    Triple():len(0) {}
    friend istream& operator >> (istream &is, Triple&t)
    {
    int len = 0;
    while(1)
    {
        is >> t.es[len].r >> t.es[len].c >> t.es[len].v;
        if(t.es[len].v==0&&t.es[len].c==0&&t.es[len].r==0)break;
        len++;
    }
    t.len = len ;
    return is;
    }
    friend ostream& operator << (ostream &os, Triple & t)
    {
    sort(t.es,t.es+t.len,cmp);
    for(int i=0; i<t.len; i++)
    {
        if(t.es[i].v !=0)
            os << t.es[i].r << " " << t.es[i].c << " " << t.es[i].v << endl;
    }
    return os;
    }
    Triple operator + ( Triple &t)
    {
        Triple c;
        int e=0;
        bool flag = false;
        sort(t.es,t.es+t.len,cmp);
        sort(es,es+len,cmp);
        for(int i=0; i<t.len; i++)
        {
            flag=false;
            for(int j=0; j<len; j++)
            {
                if(flag==false  &&  es[j].r==t.es[i].r  &&  es[j].c==t.es[i].c)
                {
                    flag=true;
                    c.es[e].r=es[j].r;
                    c.es[e].c=es[j].c;
                    c.es[e].v=es[j].v+t.es[i].v;
                    e++;
                    break;
                }
            }
            if(!flag)
            {
                c.es[e].r=t.es[i].r;
                c.es[e].c=t.es[i].c;
                c.es[e].v=t.es[i].v;
                e++;
            }
        }
        for(int i=0; i<len; i++)
        {
            flag=false;
            for(int j=0; j<t.len; j++)
            {
                if(flag==false  &&  t.es[j].r==es[i].r  &&  t.es[j].c==es[i].c)
                {
                    flag=true;
                    break;
                }
            }
            if(!flag)
            {
                c.es[e].r=es[i].r;
                c.es[e].c=es[i].c;
                c.es[e].v=es[i].v;
                e++;
            }
        }
        c.len= e;
        return c;
    }
};

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