Informations sur le sujet

La compression de données est une technique permettant d'améliorer l'efficacité de la transmission et du stockage.
Cette expérience nécessite la réalisation d'un algorithme pour le produit de deux matrices creuses. Le nombre d'éléments non nuls dans la matrice creuse est inférieur à 100.

entrer

Le nombre de lignes, de colonnes et le nombre d'éléments différents de zéro de la première matrice creuse (les trois nombres sont supérieurs à 0), le
nombre de lignes, de colonnes et le nombre d'éléments différents de zéro de la deuxième matrice creuse du triplet (trois nombres Sont supérieurs à 0), les triplets sont
entrés dans la table des triplets à matrice creuse dans la séquence principale de lignes

Production

Le nombre de
lignes et de colonnes de la matrice du produit Le nombre d'
éléments non nuls (les trois nombres sont supérieurs à 0)
triplets

Échantillon de test

3
2
3
1,2,6
2,1,-1
3,2,4

répondre

#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;
}

idée

Insérez la description de l'image ici
Pour chaque élément de A A.nodes[p](p=1,2,...,A.t), trouver tous satisfont à la condition N A.nodes[p].j = B.nodes.iéléments B.nodes[q], est obtenu A.nodes[p].vet B.nodes[q].vle produit. La
valeur de chaque élément de la matrice de produit Q est accumulée et ce produit A.nodes[p].v * B.nodes[q], v n'est qu'une Q[i][j]partie de. Définissez une variable de somme cumulative pour chaque élément, et sa valeur initiale est zéro, puis balayez le tableau A pour trouver le produit de l'élément correspondant et l'ajouter à la variable de somme cumulative appropriée

Multiplication de la matrice clairsemée