稀疏矩阵的乘法运算

数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。

 

本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100.

 

输入：

 

第1个稀疏矩阵的行数
          列数
          非零元个数(三个数都大于0)
          三元组

第2个稀疏矩阵的行数
          列数
          非零元个数(三个数都大于0)
          三元组   

 

以行为主序输入稀疏矩阵三元组表

 

输出：

 

       乘积矩阵的行数
          列数
          非零元个数(三个数都大于0)
          三元组

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 3↵ 4↵ 4↵ 1 1 3↵ 1 4 5↵ 2 2 -1↵ 3 1 2↵ 4↵ 2↵ 4↵ 1 2 2↵ 2 1 1↵ 3 1 -2↵ 3 2 4↵	以文本方式显示 3↵ 2↵ 3↵ 1,2,6↵ 2,1,-1↵ 3,2,4↵	1秒	256KB	0
测试用例 2	以文本方式显示 100↵ 1↵ 2↵ 1 1 1↵ 2 1 1↵ 1↵ 100↵ 2↵ 1 1 1↵ 1 100 1↵	以文本方式显示 100↵ 100↵ 4↵ 1,1,1↵ 1,100,1↵ 2,1,1↵ 2,100,1↵	1秒	64M	0

 

#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#define MAXSIZE 9999   
#define MAXRC 9999  
   
typedef struct{  
    int i,j; //该非零元行下标、列下标   
    int e;  //值   
}Triple;  
  
typedef struct{  
    Triple data[MAXSIZE+1];  
    int rpos[MAXRC+1];  
    int mu,nu,tu;  
}RLSMatrix;  
  
void MultSMatrix(RLSMatrix a,RLSMatrix b,RLSMatrix &c,int anum[],int bnum[] ){  
    if(a.nu!=b.mu) return;  
    c.mu=a.mu;  
    c.nu=b.nu;  
    c.tu=0;  //c初始化  
    int arow,ctemp[10000],tp,p,q,brow,t,ccol,i;  
    if(a.tu*b.tu!=0)  //c为非零矩阵   
    {  
        for(arow=1;arow<=a.mu;++arow)  //处理a的每一行   
        {  
            if(anum[arow]==0) continue;   
            for(i=0;i<10000;i++) ctemp[i]=0;  //当前行各元素累加器清零   
            c.rpos[arow]=c.tu+1;   
            if(arow<a.mu) tp=a.rpos[arow+1];  //tp记录（a矩阵前arow行的非零元的数量+1）   
            else tp=a.tu+1;  
            for(p=a.rpos[arow];p<tp;++p)  //对a矩阵当前行中每一个非零元   
            {                     
                brow=a.data[p].j;       //找到对应元在b矩阵中的行号   
                    if(bnum[brow]==0) continue;   
                if(brow<b.mu) t=b.rpos[brow+1];    //t记录（b矩阵前brow行的非零元的数量+1）   
                else t=b.tu+1;  
                for(q=b.rpos[brow];q<t;++q)  // 对b矩阵当前行中每一个非零元   
                {  
                  
                    ccol=b.data[q].j;       //乘积元素在c中的列号   
                    ctemp[ccol] += a.data[p].e*b.data[q].e;  
                    //printf("ctemp[%d]:%d %d*%d\n",ccol,ctemp[ccol],a.data[p].e,b.data[q].e);            
                }  
            }  
            for(ccol=1;ccol<=c.nu;++ccol)  
            {  
                if(ctemp[ccol])  
                {  
                    c.tu++;  
                    c.data[c.tu].i=arow;  
                    c.data[c.tu].j=ccol;  
                    c.data[c.tu].e=ctemp[ccol];  
                    //printf("(%d,%d) %d\n",arow,ccol,ctemp[ccol]);  
                }  
                  
            }   
                  
        }  
     }   
     return;  
}   
  
int main(){  
    RLSMatrix a,b,c;  
    scanf("%d\n%d\n%d\n",&a.mu,&a.nu,&a.tu);  
    int i;  
    for(i=1;i<=a.tu;++i)  
    {  
        scanf("%d%d%d",&a.data[i].i,&a.data[i].j,&a.data[i].e);  
    }  
    scanf("%d\n%d\n%d\n",&b.mu,&b.nu,&b.tu);  
    for(i=1;i<=b.tu;++i)  
    {  
        scanf("%d%d%d",&b.data[i].i,&b.data[i].j,&b.data[i].e);  
    }  
      
    int anum[a.mu+1],bnum[b.mu+1],row,t;  
      
    for(row=1;row<=a.mu;++row)   anum[row]=0;  
    for(t=1;t<=a.tu;++t)   
    {  
        ++anum[a.data[t].i];  
    }  
    int u=1;  
    while(anum[u]<0) u++;  
    a.rpos[u]=1;  
    for(row=u+1;row<=a.mu;++row)   
    {  
        //if(anum[row]==0) break;  
        a.rpos[row]=a.rpos[row-1]+anum[row-1];  
        //printf("A %d\n",a.rpos[row]);  
    }  
      
    for(row=1;row<=b.mu;++row)   bnum[row]=0;  
    for(t=1;t<=b.tu;++t) ++bnum[b.data[t].i];  
    u=1;  
    while(bnum[u]<0) u++;  
    b.rpos[u]=1;  
    for(row=u+1;row<=b.mu;++row)   
    {  
        //if(bnum[row]==0) break;  
        b.rpos[row]=b.rpos[row-1]+bnum[row-1];  
        //printf("A %d\n",b.rpos[row]);  
    }  
      
    MultSMatrix(a,b,c,anum,bnum);  
    printf("%d\n%d\n%d\n",c.mu,c.nu,c.tu);  
    for(i=1;i<=c.tu;++i)  
    {  
        printf("%d,%d,%d\n",c.data[i].i,c.data[i].j,c.data[i].e);  
    }  
}