稀疏矩阵的加减乘除算法

参考数据结构严蔚敏稀疏矩阵乘法

#include<iostream>
#include<vector>
#include<unistd.h>
#include<fstream>

using namespace std;
class Tuple{
public:
    int row,col,val;
    Tuple():row(0),col(0),val(0){}
    Tuple(int ar,int ac,int av):row(ar),col(ac),val(av){}
};
class Spamat{
public:
    //in order to eliminate syntax ambiguity, cannot use parentheses for in-class initialze, only brackets
    //vector<Tuple> tup{100};  ok
    //vector<Tuple> tup(100);  error
    vector<Tuple> tup;
    int rownum,colnum,cnt;
    Spamat():rownum(0),colnum(0),cnt(0){}
    Spamat(int rn,int cn,int ct):rownum(rn),colnum(cn),cnt(ct){}
};
class Solution{
public:
    Spamat mat1,mat2,mat3;
    fstream datasrc{"data.txt",ios::in};
    void input(){
        int row,col,val;
//        cout << "input the information of the first matrix with format:
";
//        cout << "rownum	colnum	count
...
";
        datasrc >> mat1.rownum >> mat1.colnum >> mat1.cnt;
        for(int i=0;i<mat1.cnt;++i){
            datasrc >> row >> col >> val;
            mat1.tup.push_back(Tuple(row,col,val));
        }
//        cout << "input the information of the second matrix with format:
";
//        cout << "rownum	colnum	count
...
";
        datasrc >> mat2.rownum >> mat2.colnum >> mat2.cnt;
        for(int i=0;i<mat2.cnt;++i){
            datasrc >> row >> col >> val;
            mat2.tup.push_back(Tuple(row,col,val));
        }
        cout << "input ok" << endl;
        //pause();
    }
    void output(Spamat &mat){
        cout << "cnt : " << mat.cnt << endl;
        for(auto t : mat.tup){
            cout << t.row << " " << t.col << " " << t.val << endl;
        }
        cout << "out ok" << endl;
    }
    void solve(){
        input();
        output(mat1);
        output(mat2);
        vector<int> rowcnt(100,0);
        vector<int> rowpos(100,0);
        vector<int> temp(100,0);
        for(int i=0;i<mat2.cnt;++i){
            rowcnt[mat2.tup[i].row]++;
        }
        rowpos[1] = 0;
        for(int i=2;i<=mat2.rownum;++i){
            rowpos[i] = rowpos[i-1] + rowcnt[i-1];
        }
        for(int i=1;i<=mat1.rownum;++i){
            //temp.clear();
            std::fill(temp.begin(),temp.end(),0);
            for(int j=0;j<mat1.cnt;++j){
                if(mat1.tup[j].row > i)break;
                else if(mat1.tup[j].row == i){
                    //cout << "in mat1: " << i << " " << j << endl;
                    int tcol = mat1.tup[j].col;
                    //cout << "~" << " " << rowpos[tcol] << " ~ " << rowcnt[tcol]+rowpos[tcol] << endl;
                    for(int k=rowpos[tcol];k<rowpos[tcol]+rowcnt[tcol];++k){

                        temp[mat2.tup[k].col] += mat1.tup[j].val * mat2.tup[k].val;
                        //cout << "temp ; " <<mat2.tup[k].col<<" " << temp[mat2.tup[k].col] << endl;
                    }

                }
            }
            for(int j=1;j<=mat2.colnum;++j){
                if(temp[j] != 0){
                    mat3.tup.push_back(Tuple(i,j,temp[j]));
                }
            }
        }
        mat3.cnt = mat3.tup.size();
        output(mat3);
    }
};
int main()
{
    Solution sol;
    sol.solve();
    return 0;
}

稀疏矩阵加法：

#include <iostream>
#include<vector>

using namespace std;
class Tuple{
public:
    int row,col,val;
    Tuple():row(0),col(0),val(0){}
    Tuple(int tr,int tc,int tv):row(tr),col(tc),val(tv){}
};
vector<Tuple> mat1,mat2,mat3;
int rownum,colnum,len1,len2;
int cmpmat(Tuple &t1,Tuple &t2);
int main()
{
    int tr,tc,tv;
    cin >> rownum >> colnum >> len1 >> len2;
    mat1.reserve(len1);
    mat2.reserve(len2);
    mat3.reserve(len1+len2);
    for(int i=0;i<len1;++i){
        cin >> tr >> tc >> tv;
        mat1.push_back(Tuple(tr,tc,tv));
    }
    for(int i=0;i<len2;++i){
        cin >> tr >> tc >> tv;
        mat2.push_back(Tuple(tr,tc,tv));
    }
    vector<Tuple>::iterator iter1 = mat1.begin(),iter2 = mat2.begin();
    while(iter1!=mat1.end()&&iter2!=mat2.end()){
        if(cmpmat(*iter1,*iter2)==0){
            tv = (*iter1).val+(*iter2).val;
            if(tv){
               mat3.push_back(Tuple(iter1->row,iter1->col,tv));
            }
            ++iter1;
            ++iter2;
            continue;
        }
        if(cmpmat(*iter1,*iter2)<0){
            mat3.push_back(Tuple(iter1->row,iter1->col,iter1->val));
            ++iter1;
        }
        else{
            mat3.push_back(Tuple(iter2->row,iter2->col,iter2->val));
            ++iter2;
        }
    }
    if(iter1!=mat1.end()){
        for(;iter1!=mat1.end();++iter1){
            mat3.push_back(Tuple(iter1->row,iter1->col,iter1->val));
        }
    }
    if(iter2!=mat2.end()){
        for(;iter2!=mat2.end();++iter2){
            mat3.push_back(Tuple(iter2->row,iter2->col,iter2->val));
        }
    }
    for(auto tp : mat3){
        cout << tp.row << " " << tp.col << " " << tp.val << endl;
    }
    return 0;
}
int cmpmat(Tuple &t1,Tuple &t2)
{
    if(t1.row==t2.row&&t1.col==t2.col){
        return 0;
    }
    if((t1.row<t2.row)||(t1.row==t2.row)&&(t1.col<t2.col)){
        return -1;
    }
    return 1;
}