精华内容
下载资源
问答
  • 稀疏矩阵乘法运算
    2022-08-13 10:27:05

    【问题描述】

    稀疏矩阵可以以压缩方式进行存储,即:用一个n行3列矩阵只存储非零元素。每行存储一个非零元素,每行第一个为非零元素行标;第二个为非零元素列标;第三个为非零元素本身。如下左边为一个稀疏矩阵,右边是其存储形式。编写程序实现用上述压缩存储方式输入的稀疏矩阵的乘法,稀疏矩阵最大为9*9。以压缩方式输出结果矩阵。行标和列标都从0开始计数。

    0   0   0   10    0 3 10
    2   0   0   0      1 0 2
    0   0   3   1      2 2 3
    1   0   0   0      2 3 1
                           3 0 1

    【输入形式】

    先从控制台输入第一个矩阵的非零元素个数,再以压缩方式输入第一个矩阵的元素,即:分行输入非零元素的行标、列标和非零元素数据本身,以一个空格分隔行标、列标和非零元素。然后以同样方式输入第二个矩阵。

    【输出形式】

    在标准输出上以压缩方式分行输出结果矩阵,即:每行分别输出结果矩阵中非零元素的行标、列标和非零元素数据本身,行标、列标和非零数据之间以一个空格分隔,但每行最后一个数据后没有空格。先输出行标小的元素,若行标相同,则先输出列标小的元素。若没有非零元素,则不输出任何信息。

    【输入样例】

     
    

    5
    0 3 10
    1 0 2
    2 2 3
    2 3 1
    3 0 1
    2
    0 1 200
    2 2 -5

    【输出样例】

     
    

    1 1 400
    2 2 -15
    3 1 200

    【样例说明】

    输入的两个矩阵中的行、列最大下标均为3,所以可以看成是4*4的矩阵,即输入的两个矩阵分别为:

     
    

    0   0   0   10
    2   0   0   0
    0   0   3   1
    1   0   0   0


    0   200   0   0
    0   0     0   0
    0   0     -5  0
    0   0     0   0

    两矩阵相乘的结果为:

     
    

    0   0    0   0
    0   400  0   0
    0   0    -15 0
    0   200  0   0

    #include <stdio.h>
    #include <stdlib.h>
    #define maxn  15
    //定义节点
    typedef struct  node {
        int row, col, v;
    } node;
    //定义三元组存储稀疏矩阵
    struct T {
        node Node[maxn];
        int MAXrow, MAXcol, MAXsize;
    } TA, TB, TC;
    
    int main() {
    	int num1,num2,i,j,k,sum,p,q;
        scanf("%d", &num1);//输入a矩阵
    	TA.MAXsize = num1;
    	for(i=0;i<num1;i++)
    	{
    		scanf("%d%d%d",&TA.Node[i].row,&TA.Node[i].col,&TA.Node[i].v);
    	}
    	TA.MAXrow = maxn;
        TA.MAXcol = maxn;
    	
        scanf("%d", &num2);//输入b矩阵
    	TB.MAXsize = num2;
    	for(k=0;k<num2;k++)
    	{
    		scanf("%d%d%d",&TB.Node[k].row,&TB.Node[k].col,&TB.Node[k].v);
    	}
    	TB.MAXrow = maxn;
        TB.MAXcol = maxn;
    
    
    	TC.MAXsize = 0;
        TC.MAXrow = maxn;
        TC.MAXrow = maxn;
        for(i = 0; i < maxn; i++) {//计算c矩阵
            for(j = 0; j < maxn; j++) {
                sum = 0;
                for(p = 0; p < TA.MAXsize ; p++) {
                    if(TA.Node[p].row != i) continue;
                    for(q = 0; q < TB.MAXsize; q++) {
                        if(TB.Node[q].col != j) continue;
                        if(TA.Node[p].col == TB.Node[q].row) {
                            sum += TA.Node[p].v * TB.Node[q].v;
                        }
                    }
                }
                if(sum != 0) {
                    TC.Node[TC.MAXsize].row = i;
                    TC.Node[TC.MAXsize].col = j;
                    TC.Node[TC.MAXsize].v = sum;
                    TC.MAXsize++;
                }
            }
        }
    	
    
    	for(i=0;i<TC.MAXsize;i++)
    	{
    		printf("%d %d %d\n",TC.Node[i].row,TC.Node[i].col,TC.Node[i].v);
    	}
    	
    
        return 0;
    }

    更多相关内容
  • 本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100. 输入 第1个稀疏矩阵的行数 列数 非零元个数(三个数都大于0) 三元组 第2个稀疏矩阵的行数 列数 非零元个数(三个数都大于0) 三元组 以...

    问题

    描述

    • 数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。
      本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100.

    输入

    • 第1个稀疏矩阵的行数
      列数
      非零元个数(三个数都大于0)
      三元组
      第2个稀疏矩阵的行数
      列数
      非零元个数(三个数都大于0)
      三元组
      以行为主序输入稀疏矩阵三元组表

    输出

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

    测试用例

    • 测试输入

    • 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↵

    在这里插入图片描述

    解题

    基本思想

    • 每次计算Q中的一行元素,当前行号为arrow。

    • 设临时变量ctemp[ ]保存该行元素,将其清零。

    • 计算每行元素:

    • M中第arrow行的每一个元素(arrow, j)分别与N中第j行的元素(j, ccol)相乘,其结果累加到ctemp[ccol]中。

    • 计算完后将该行元素压缩存储到Q的三元组中

    代码

    #include<iostream>
    #include<cstring>
    #include<cstdlib>
    using namespace std;
    
    // 三元组节点
    typedef struct node{
        int i;  // 行
        int j;   //列
        int data;   //数据值
    }NODE;
    
    NODE *multmatrix(NODE *mam, NODE m[], NODE *man, NODE n[],NODE *q,NODE *qtu){
        int a,b,d;
        // 新矩阵的列数由n的列数决定
        int temp[man->j];
        int index=0;
        qtu->data=0;
        // 遍历属于m每一行的元素
        for(a=1;a<=mam->i;a++){
            
            // 初始化
            for(b=0;b<man->j;b++){
                
                temp[b]=0;
            }
            // 遍历三元组m中每一个元素
            for(b=0;b<mam->data;b++){
    
                // 找到属于m中正在操作的这一行的元素
                if(m[b].i==a){                
                    // 遍历n中每一个元素
                    for(d=0;d<man->data;d++){
                        // 找到n的行和m的列相同的元素
                        if(n[d].i==m[b].j){
                            //累加
                            temp[(n[d].j)-1]+=m[b].data * n[d].data;
                        }
                    }
                }
            }
            //把临时数组里的值存进去
            for(b=0;b<man->j;b++){
                if(temp[b]!=0){
                    q[index].i=a;
                    q[index].j=b+1;
                    q[index].data = temp[b];
                    index ++;
                }
                
            }
    
        }
        qtu->data=index;
    
        return qtu;
    }
    
    int main(){
        int index;
        // 矩阵的行、列、非零元个数刚好是三个数据,可以利用
        NODE matrixm,matrixn;
        //freopen("file in.txt","r",stdin); 
        // 输入m的行、列、非零元个数
        cin>>matrixm.i>>matrixm.j>>matrixm.data;
        NODE mtriplet[matrixm.data];
        for(index=0;index<matrixm.data;index++){
            cin>>mtriplet[index].i>>mtriplet[index].j>>mtriplet[index].data;
        }
        cin>>matrixn.i>>matrixn.j>>matrixn.data;
        NODE ntriplet[matrixn.data];
        for(index=0;index<matrixn.data;index++){
            cin>>ntriplet[index].i>>ntriplet[index].j>>ntriplet[index].data;
        }
    
        // 矩阵可以相乘的条件
        if(matrixm.j!=matrixn.i){
            return 0;
        }
    
        NODE result[matrixm.i * matrixn.j];
        NODE matrixresult;
    
        matrixresult.i = matrixm.i;
        matrixresult.j = matrixn.j;
        // 如果是个空矩阵,返回
        if(matrixresult.i * matrixresult.j ==0){
            return 0;
        }
        multmatrix(&matrixm,mtriplet,&matrixn,ntriplet,result,&matrixresult);
    
        cout<<matrixresult.i<<endl;
        cout<<matrixresult.j<<endl;
        cout<<matrixresult.data<<endl;
        for(index=0;index<matrixresult.data;index++){
            cout<<result[index].i<<",";
            cout<<result[index].j<<",";
            cout<<result[index].data<<endl;
        }
        return 0;
    }
    
    

    小结

    1. 变量使用之前千万要初始化
    2. 动态数组不能在声明的同时进行初始化,初始化需要在声明完成之后
    展开全文
  • 稀疏矩阵乘法运算

    千次阅读 2020-10-28 15:42:14
    稀疏矩阵乘法运算题目信息输入输出测试样例解答想法 题目信息 数据压缩是提高传输、存储效率一种技术。 本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100. 输入 第1个稀疏矩阵的行数,列...

    题目信息

    数据压缩是提高传输、存储效率一种技术。
    本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100.

    输入

    第1个稀疏矩阵的行数,列数,非零元个数(三个数都大于0),三元组
    第2个稀疏矩阵的行数,列数,非零元个数(三个数都大于0),三元组
    以行为主序输入稀疏矩阵三元组表

    输出

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

    测试样例

    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
    

    解答

    #include<stdio.h>
    
    typedef struct
    {
        int i, j;
        int e;
    } Node;
    typedef struct
    {
        Node nodes[105];
        int rpos[105];//各行第一个非零元的位置表
        int m, n, t;
    } Matrix;
    
    int main()
    {
        //freopen("/Users/zhj/Downloads/test.txt", "r", stdin);
        Matrix A, B;
    
        scanf("%d%d%d", &A.m, &A.n, &A.t);
        for (int i = 1; i <= A.t; i++)
        {
            scanf("%d%d%d", &A.nodes[i].i, &A.nodes[i].j, &A.nodes[i].e);
        }
        int num[1000];
        for (int col = 1; col <= A.m; col++)
        {
            num[col] = 0;
        }
        for (int i = 1; i <= A.t; i++)
        {
            num[A.nodes[i].i]++;
        }
        A.rpos[1] = 1;
        for (int col = 2; col <= A.m; col++)
        {
            A.rpos[col] = A.rpos[col - 1] + num[col - 1];
        }
    
        scanf("%d%d%d", &B.m, &B.n, &B.t);
        for (int i = 1; i <= B.t; i++)
        {
            scanf("%d%d%d", &B.nodes[i].i, &B.nodes[i].j, &B.nodes[i].e);
        }
        for (int col = 1; col <= B.m; col++)
        {
            num[col] = 0;
        }
        for (int i = 1; i <= B.t; i++)
        {
            num[B.nodes[i].i]++;
        }
        B.rpos[1] = 1;
        for (int col = 2; col <= B.m; col++)
        {
            B.rpos[col] = B.rpos[col - 1] + num[col - 1];
        }
    
        Matrix Q;
        Q.m = A.m;
        Q.n = B.n;
        Q.t = 0;//创建答案矩阵
    
        if (A.t * B.t != 0)
        {//Q是非零矩阵
            for (int arow = 1; arow <= A.m; arow++)
            {//处理A的每一行
                int ctemp[105] = {0};
                Q.rpos[arow] = Q.t + 1;
    
                int tp;//tp是下一行元素在nodes表中位置
                if (arow < A.m)
                {
                    tp = A.rpos[arow + 1];
                }
                else
                {
                    tp = A.t + 1;
                }
                for (int p = A.rpos[arow]; p < tp; p++)
                {//对当前行中每一个非零元,既从当前在nodes表中位置找到下一行元素在nodes表的位置
                    int brow = A.nodes[p].j;//此为A表中的纵向位置值,在B表中找相应的行号即可
    
                    int t;//t仍然为下一行的位置
                    if (brow < B.m)
                    {
                        t = B.rpos[brow + 1];
                    }
                    else
                    {
                        t = B.t + 1;
                    }
                    for (int q = B.rpos[brow]; q < t; q++)
                    {
                        int ccol = B.nodes[q].j;//Q中的纵坐标是以B元素中的j来说话的
                        ctemp[ccol] += A.nodes[p].e * B.nodes[q].e;
                    }
                }
    
                for (int ccol = 1; ccol <= Q.n; ccol++)
                {//压缩存储该行的非零元
                    if (ctemp[ccol])
                    {//如果此处有值的话
                        Q.t++;//Q的非零元素多了一个
                        Q.nodes[Q.t].i = arow;//行号为此时遍历的A的行号
                        Q.nodes[Q.t].j = ccol;//列号为此时正在进行压缩所遍历到有值的地方
                        Q.nodes[Q.t].e = ctemp[ccol];//累计的和拷贝过来
                    }
                }
            }
        }
    
        printf("%d\n", Q.m);
        printf("%d\n", Q.n);
        printf("%d\n", Q.t);
        for (int i = 1; i <= Q.t; i++)
        {
            printf("%d,%d,%d\n", Q.nodes[i].i, Q.nodes[i].j, Q.nodes[i].e);
        }
        return 0;
    }
    

    想法

    在这里插入图片描述
    对于A中每个元素A.nodes[p](p=1,2,...,A.t),找到N中所有满足条件A.nodes[p].j = B.nodes.i的元素B.nodes[q],求得A.nodes[p].vB.nodes[q].v的乘积.
    乘积矩阵Q中每个元素的值是个累积和,这个乘积A.nodes[p].v * B.nodes[q],v只是Q[i][j]中的一部分.为便于操作,应对每个元素设一累计和的变量,其初值为零,然后扫面数组A,求得相应元素的乘积并累加到适当的求累计和的变量上

    展开全文
  • 数据结构课程设计《稀疏矩阵乘法运算的十字链表实现》
  • 【问题描述】 ...编写程序实现用上述压缩存储方式输入的稀疏矩阵乘法稀疏矩阵最大为9*9。以压缩方式输出结果矩阵。行标和列标都从0开始计数。 0 0 0 10 0 3 10 2 0 0 0 1 0 2 0 0 3 1 2 2 3 1 0

    【问题描述】

    稀疏矩阵可以以压缩方式进行存储,即:用一个n行3列矩阵只存储非零元素。每行存储一个非零元素,每行第一个为非零元素行标;第二个为非零元素列标;第三个为非零元素本身。如下左边为一个稀疏矩阵,右边是其存储形式。编写程序实现用上述压缩存储方式输入的稀疏矩阵的乘法,稀疏矩阵最大为9*9。以压缩方式输出结果矩阵。行标和列标都从0开始计数。

    0 0 0 10 0 3 10
    2 0 0 0 1 0 2
    0 0 3 1 2 2 3
    1 0 0 0 2 3 1
    3 0 1

    【输入形式】

    先从控制台输入第一个矩阵的非零元素个数,再以压缩方式输入第一个矩阵的元素,即:分行输入非零元素的行标、列标和非零元素数据本身,以一个空格分隔行标、列标和非零元素。然后以同样方式输入第二个矩阵。

    【输出形式】

    在标准输出上以压缩方式分行输出结果矩阵,即:每行分别输出结果矩阵中非零元素的行标、列标和非零元素数据本身,行标、列标和非零数据之间以一个空格分隔,但每行最后一个数据后没有空格。先输出行标小的元素,若行标相同,则先输出列标小的元素。若没有非零元素,则不输出任何信息。

    【输入样例】

    5
    0 3 10
    1 0 2
    2 2 3
    2 3 1
    3 0 1
    2
    0 1 200
    2 2 -5

    【输出样例】

    1 1 400
    2 2 -15
    3 1 200

    【样例说明】

    输入的两个矩阵中的行、列最大下标均为3,所以可以看成是4*4的矩阵,即输入的两个矩阵分别为:

    0 0 0 10
    2 0 0 0
    0 0 3 1
    1 0 0 0

    0 200 0 0
    0 0 0 0
    0 0 -5 0
    0 0 0 0

    两矩阵相乘的结果为:
    0 0 0 0
    0 400 0 0
    0 0 -15 0
    0 200 0 0

    算法说明

    在解决此题时采取了比较直观的解决方法。

    1. 读取输入到数组中
    2. 将输入形成的数组还原为正常的矩阵形式(取两矩阵行列数最大值作为矩阵行列数)
    3. 将第一个矩阵的每一行与第二个矩阵的每一列相乘并输出运算结果
      代码如下:
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        int n1,n2,i,j,m,n,k;
    
        scanf("%d",&n1);    //读取第一个稀疏矩阵
        int a1[n1][3];
        int y1_max=0;
        for(i=0;i<n1;i++){
            scanf("%d",&a1[i][0]);
            scanf("%d",&a1[i][1]);
            scanf("%d",&a1[i][2]);
            if(a1[i][1] > y1_max)
                y1_max = a1[i][1];  //矩阵一最大列数
        }
        int x1_max = a1[n1-1][0];  //矩阵一最大行数
    
        scanf("%d",&n2);//读取第二个稀疏矩阵
        int a2[n2][3];
        int y2_max=0;
        for(j=0;j<n2;j++){
            scanf("%d",&a2[j][0]);
            scanf("%d",&a2[j][1]);
            scanf("%d",&a2[j][2]);
            if(a2[j][1]>y2_max)
                y2_max = a2[j][1];  //矩阵二最大列数
        }
        int x2_max = a2[n2-1][0];   //矩阵二最大行数
    
        //取两矩阵行数列数最大值,作为生成矩阵的行列数
        int max = x1_max;
        if(y1_max>max)
            max = y1_max;
        if(x2_max>max)
            max = x2_max;
        if(y2_max>max)
            max = y2_max;
    
        max+=1;
    
        int x1,y1,t1,x2,y2,t2;
        int x[max][max];  //按行数还原为矩阵
        int y[max][max];  //按列数还原为矩阵
    
        for(m=0;m<max;m++) //矩阵初始化
            for(n =0;n<max;n++){
                x[m][n]=0;
                y[m][n]=0;
        }
    
        for(i=0;i<n1;i++){   //计算两矩阵相乘结果
            x1 = a1[i][0];
            y1 = a1[i][1];
            t1 = a1[i][2];
            x[x1][y1]=t1;
        }
        for(j=0;j<n2;j++){
            x2 = a2[j][0];
            y2 = a2[j][1];
            t2 = a2[j][2];
            y[y2][x2] = t2;
        }
    
        //计算矩阵乘积
        int total;
        for(m=0;m<max;m++)
            for(n=0;n<max;n++){
                total = 0;
                for(k=0;k<max;k++){
                    total+=x[m][k]*y[n][k];
                }
                if(total != 0)
                    printf("%d %d %d\n",m,n,total);
        }
        return 0;
    }
    
    

    明天学习一下效率更高的算法再贴上来。

    展开全文
  • 采用三元组表示稀疏矩阵,并实现基本运算的实验报告。
  • 十五、稀疏矩阵乘法运算

    千次阅读 2020-10-30 18:51:40
    十五、稀疏矩阵乘法运算 文章目录十五、稀疏矩阵乘法运算题目描述解题思路上机代码 题目描述 数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。 本实验要求实现两个稀疏矩阵相...
  • 1 import threading, time 2 import numpy as np 3 res = [] 4 class MyThread(threading.Thread): 5 def __init__(self,i,j,m1,m2): 6 threading.Thread.__init__(self) 7 se...
  • 稀疏矩阵相乘运算 一、目的 1.了解稀疏矩阵相乘运算特点 2.知道稀疏矩阵存储,创建,显示,转置方法 二、设计要求 1.问题描述 利用稀疏的特点进行存储和计算可大大节省存储空间,并实现稀疏矩阵相乘运算 2.需求分析 ...
  • 这个资源仅供参考!希望大家提提意见!希望大家支持支持!也我从别的地方找来的!
  • 稀疏矩阵乘积描述给定两个N × N的稀疏矩阵A和B,其中矩阵A有P个元素非0,矩阵B有Q个元素非0。请计算两个矩阵的乘积C = A × B并且输出C中所有非0的元素。输入第一行包含三个整数N, P, Q以下P行每行三个整数i, j, k...
  • 用C++编写的稀疏矩阵乘法运算,稀疏矩阵采用十字链表存储及计算
  • 三元组方法:主要的特点就是最后的结果矩阵均由三元组的形式来表达,调用函数再以矩阵形式输出(1)稀疏矩阵加法(下图参考懒猫老师《数据结构》课程相关笔记)(2)稀疏矩阵乘法(稀疏矩阵(顺序).h--用来实现稀疏...
  • 今天小编就为大家分享一篇关于C++稀疏矩阵的各种基本运算并实现加法乘法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • (五)1.1_稀疏矩阵乘法的快速运算

    万次阅读 多人点赞 2018-11-30 01:01:41
      有矩阵M和N,都是用三元组压缩存储,设计高效率算法求矩阵M*N得到的矩阵Q(也用三元组压缩存储). 二.思路分析 假设矩阵M*N=Q 如下 那么得到的矩阵Q有三行三列,第一列中的元素有这样的关系 所以我们可以...
  • Matlab 矩阵运算

    千次阅读 2021-04-22 03:29:59
    Copyright 2008说明:这一段时间用Matlab做了LDPC码的性能仿真,过程中涉及了大量的矩阵运算,本文记录了Matlab中矩阵的相关知识,特别的说明了稀疏矩阵和有限域中的矩阵。Matlab的运算是在矩阵意义下进行的,这里所...
  • 稀疏矩阵运算

    2017-03-14 22:48:22
    printf("输入稀疏矩阵A的行数,列数和非零元个数:"); scanf("%d %d %d",&A.m,&A.n,&A.t); for(k=1;k;k++) { printf("输入第%d个非0元素的行数,列数和值:",k); scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&...
  • 稀疏矩阵乘法

    千次阅读 2019-06-26 11:01:34
    1492.稀疏矩阵乘法 时限:1000ms 内存限制:10000K 总时限:3000ms 描述 计算两个稀疏矩阵乘法 输入 首先输入第一个矩阵的行数和列数,再输入该矩阵的三元组形式,以0 0 0结束  然后输入第二个矩阵的行数和列数...
  • 8. 稀疏矩阵乘法运算 成绩 10 开启时间 2018年10月22日 星期一 18:00 折扣 0.8 折扣时间 2018年11月22日 星期四 23:55 允许迟交 否 关闭时间 2018年12月1日 星期六 23:55   ...
  • 稀疏矩阵的加法和乘法运算 上节学了类的友元,这节开始矩阵加法和乘法运算: (一)加法: 在这里插入代码片 在这里插入代码片
  • 适合初学者使用,Java多线程技术实现矩阵乘积计算
  • 实现一个能进行稀疏矩阵基本运算运算器,具体功能有:以“带行逻辑链接信息”的三元组顺序表示稀疏矩阵,实现两个稀疏矩阵相加、相减、相乘的功能。稀疏矩阵的输入形式采用三元组表示,而运算结果的矩阵则以通常的...
  • 矩阵乘法运算

    千次阅读 2019-11-24 16:35:42
    矩阵乘法运算的问题 最近在研究导航算法,涉及到一些位置之间的可达性。需要用到矩阵的传递闭包特性。所以中间需要用到很多关联矩阵的乘法运算。随着位置的数量的增多,他们的关联矩阵的尺寸会以n2n^2n2倍的速度...
  • 一个用Java写的多线程相乘代码,及其测试。
  • 问题描述: 稀疏矩阵是指那些多数元素为零的矩阵。... 实现矩阵的加、减和乘法运算。 我写的这个稀疏矩阵运算器代码非常完整,功能也都能正确实现,绝对不会让你们失望的,有需要的朋友们赶紧下载吧!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,973
精华内容 2,789
关键字:

稀疏矩阵乘法运算

友情链接: wuxiang.rar