【数据结构】数组和字符串（七）：特殊矩阵的压缩存储：三元组表的转置、加法、乘法操作

news2024/9/28 9:21:26

文章目录

  • 4.2.1 矩阵的数组表示
  • 4.2.2 特殊矩阵的压缩存储
    • a. 对角矩阵的压缩存储
    • b~c. 三角、对称矩阵的压缩存储
    • d. 稀疏矩阵的压缩存储——三元组表
    • 4.2.3三元组表的转置、加法、乘法、操作
      • 转置
      • 加法
      • 乘法
      • 算法测试
      • 实验结果
      • 代码整合

4.2.1 矩阵的数组表示

【数据结构】数组和字符串（一）：矩阵的数组表示

4.2.2 特殊矩阵的压缩存储

  矩阵是以按行优先次序将所有矩阵元素存放在一个一维数组中。但是对于特殊矩阵，如对称矩阵、三角矩阵、对角矩阵和稀疏矩阵等, 如果用这种方式存储，会出现大量存储空间存放重复信息或零元素的情况，这样会造成很大的空间浪费。为节约存储空间和算法（程序）运行时间，通常会采用压缩存储的方法。

  • 对角矩阵：指除了主对角线以外的元素都为零的矩阵，即对 任意 i ≠ j (1≤ i , j ≤n)，都有M(i, j)=0。由于只有主对角线上有非零元素，只需存储主对角线上的元素即可。
  • 三角矩阵：指上三角或下三角的元素都为零的矩阵。同样地，只需存储其中一部分非零元素，可以节省存储空间。
  • 对称矩阵：指矩阵中的元素关于主对角线对称的矩阵。由于对称矩阵的非零元素有一定的规律，可以只存储其中一部分元素，从而减少存储空间。
  • 稀疏矩阵：指大部分元素为零的矩阵。传统的按行优先次序存储方法会浪费大量空间来存储零元素，因此采用压缩存储的方法更为合适。常见的压缩存储方法有：压缩稠密行（CSR）、压缩稠密列（CSC）、坐标列表（COO）等。

a. 对角矩阵的压缩存储

【数据结构】数组和字符串（二）：特殊矩阵的压缩存储：对角矩阵——一维数组

b~c. 三角、对称矩阵的压缩存储

【数据结构】数组和字符串（三）：特殊矩阵的压缩存储：三角矩阵、对称矩阵——一维数组

d. 稀疏矩阵的压缩存储——三元组表

  对于稀疏矩阵的压缩存储，由于非零元素的个数远小于零元素的个数，并且非零元素的分布没有规律，无法简单地利用一维数组和映射公式来实现压缩存储。针对稀疏矩阵，通常采用特定的数据结构来进行压缩存储，以减少存储空间的占用。

  一种常见的稀疏矩阵压缩存储方法是使用"三元组"表示法，也称为COO（Coordinate）格式，只存储非零元素的值以及它们的行列坐标。通过使用三元组（Triplet）来表示非零元素的位置和值，每个三元组包含三个信息：非零元素的行索引、非零元素的列索引以及非零元素的值。

【数据结构】数组和字符串（四）：特殊矩阵的压缩存储：稀疏矩阵——三元组表

4.2.3三元组表的转置、加法、乘法、操作

转置

  假设稀疏矩阵存储在一个三元组表a中，且A的非零元素个数为count，算法Transpose求A的转置矩阵并将其保存在三元组表b中。

  • 算法的主要思想是针对每个列号k（k=0, 2,… , n-1）对a进行扫描，考察a中是否有列号为k的结点（注意：列号为k的结点可能不止一个），若有，记为a[u]（假定a[u]在a中的行号为i ），将a[u]依次保存在b的b[w] 中，则row(b[w])=k，col(b[w])=i，value(b[w]) =value(a[u]).
    在这里插入图片描述
TripletTable matrixTranspose(TripletTable* table) {
    TripletTable result;
    initTable(&result, table->cols, table->rows);  // 转置后的矩阵行列互换
    int j = 0;
    for (int k = 0; k < table->cols; k++) {
        for (int i = 0; i < table->length; i++) {
            Triple* element = &(table->data[i]);
            if (element->col == k) {
                insertElement(&result, k, element->row, element->value);
//                result.data[j].row = k;  // 该元素在result中的行号应为k
//                result.data[j].col = element->row;  // 该元素在result中的列号应为其在table中的行号
//                result.data[j].value = element->value;
                j++;  // 考察result中的下一个结点
                result.length = j;  // 更新result的长度
            }
        }
//        printf("\n");
//        displayMatrix(&result);
    }
    return result;
}

   matrixTranspose函数实现稀疏矩阵的转置操作：

  • 首先，创建一个新的TripletTable变量result，用于存储输入矩阵的转置。
  • 使用initTable函数初始化result，将其行数设置为输入矩阵的列数，列数设置为输入矩阵的行数。
  • 使用一个循环遍历输入矩阵的所有元素：
    • 对于每个元素，将其行号作为转置后矩阵中的列号，列号作为转置后矩阵中的行号，并将值保持不变。
    • 将转置后的元素插入到result中。
  • 返回result作为输入矩阵的转置。

加法

TripletTable matrixAddition(TripletTable* table1, TripletTable* table2) {
    TripletTable result;
    initTable(&result, table1->rows, table1->cols);

    int i = 0, j = 0;
    while (i < table1->length && j < table2->length) {
        Triple* element1 = &(table1->data[i]);
        Triple* element2 = &(table2->data[j]);

        if (element1->row < element2->row || (element1->row == element2->row && element1->col < element2->col)) {
            insertElement(&result, element1->row, element1->col, element1->value);
            i++;
        } else if (element1->row > element2->row || (element1->row == element2->row && element1->col > element2->col)) {
            insertElement(&result, element2->row, element2->col, element2->value);
            j++;
        } else {
            int sum = element1->value + element2->value;
            if (sum != 0) {
                insertElement(&result, element1->row, element1->col, sum);
            }
            i++;
            j++;
        }
    }

    while (i < table1->length) {
        Triple* element1 = &(table1->data[i]);
        insertElement(&result, element1->row, element1->col, element1->value);
        i++;
    }

    while (j < table2->length) {
        Triple* element2 = &(table2->data[j]);
        insertElement(&result, element2->row, element2->col, element2->value);
        j++;
    }

    return result;
}

   matrixAddition函数实现稀疏矩阵的加法操作：

  • 创建一个新的TripletTable变量result，用于存储两个输入矩阵的和。
  • 使用initTable函数初始化result，将其行数和列数设置为与输入矩阵相同。
  • 使用两个指针i和j分别指向两个输入矩阵的元素。
  • 通过比较当前元素的行号和列号，以及使用循环遍历的方式，将两个输入矩阵的元素逐个比较并进行相应的操作：
    • 如果第一个矩阵的元素在行号和列号上小于第二个矩阵的元素，将第一个矩阵的元素插入到result中，并增加指向第一个矩阵元素的指针i。
    • 如果第一个矩阵的元素在行号和列号上大于第二个矩阵的元素，将第二个矩阵的元素插入到result中，并增加指向第二个矩阵元素的指针j。
    • 如果两个矩阵的元素在行号和列号上相等，将它们的值相加，并将结果插入到result中。然后，增加指向两个矩阵元素的指针i和j。
  • 处理完所有元素后，将剩余的未处理元素插入到result中。
  • 返回result作为两个输入矩阵的和。

乘法

TripletTable matrixMultiplication(TripletTable* table1, TripletTable* table2) {
    TripletTable result;
    initTable(&result, table1->rows, table2->cols);

    int matrix[table1->rows][table2->cols];
    for (int i = 0; i < table1->rows; i++) {
        for (int j = 0; j < table2->cols; j++) {
            matrix[i][j] = 0;
        }
    }

    for (int i = 0; i < table1->length; i++) {
        Triple* element1 = &(table1->data[i]);

        for (int j = 0; j < table2->length; j++) {
            Triple* element2 = &(table2->data[j]);

            if (element1->col == element2->row) {
                matrix[element1->row][element2->col] += element1->value * element2->value;
            }
        }
    }

    for (int i = 0; i < table1->rows; i++) {
        for (int j = 0; j < table2->cols; j++) {
            if (matrix[i][j] != 0) {
                insertElement(&result, i, j, matrix[i][j]);
            }
        }
    }

    return result;
}

   matrixMultiplication函数实现稀疏矩阵的乘法操作：

  • 创建一个新的TripletTable变量result，用于存储两个输入矩阵的乘积。
  • 使用initTable函数初始化result，将其行数设置为第一个输入矩阵的行数，列数设置为第二个输入矩阵的列数。
  • 创建一个临时的二维数组matrix，用于存储两个输入矩阵相乘的结果。
  • 将matrix中的所有元素初始化为0。
  • 使用两个嵌套的循环遍历第一个输入矩阵的所有元素：
    • 对于每个元素，使用另一个嵌套的循环遍历第二个输入矩阵的所有元素。
    • 如果第一个矩阵的元素的列号等于第二个矩阵的元素的行号，将它们的值相乘，并将结果累加到matrix中对应位置的元素上。
  • 遍历matrix中的所有元素，将非零元素插入到result中。
  • 返回result作为两个输入矩阵的乘积。

算法测试

int main() {
    TripletTable matrixA, matrixB;
    initTable(&matrixA, 3, 3);
    initTable(&matrixB, 3, 3);

    // Insert elements into matrix A
    insertElement(&matrixA, 0, 0, 1);
    insertElement(&matrixA, 0, 2, 2);
    insertElement(&matrixA, 1, 1, 3);
    insertElement(&matrixA, 2, 0, 4);
    insertElement(&matrixA, 2, 2, 5);

    // Insert elements into matrix B
    insertElement(&matrixB, 0, 1, 6);
    insertElement(&matrixB, 1, 0, 7);
    insertElement(&matrixB, 1, 2, 8);
    insertElement(&matrixB, 2, 1, 9);

    printf("Matrix A:\n");
    displayMatrix(&matrixA);

    printf("\nMatrix B:\n");
    displayMatrix(&matrixB);

    TripletTable matrixC = matrixAddition(&matrixA, &matrixB);
    printf("\nMatrix A + B:\n");
    displayMatrix(&matrixC);

    TripletTable matrixD = matrixTranspose(&matrixA);
    printf("\nTranspose of Matrix A:\n");
    displayMatrix(&matrixD);

    TripletTable matrixE = matrixMultiplication(&matrixA, &matrixB);
    printf("\nMatrix A * B:\n");
    displayMatrix(&matrixE);
    return 0;
}

实验结果

在这里插入图片描述

代码整合

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 10

typedef struct {
    int row;
    int col;
    int value;
} Triple;

typedef struct {
    Triple data[MAX_SIZE];
    int rows;
    int cols;
    int length;
} TripletTable;

void initTable(TripletTable* table, int rows, int cols) {
    table->rows = rows;
    table->cols = cols;
    table->length = 0;
    memset(table->data, 0, sizeof(Triple) * MAX_SIZE);  // 新添加
}

void insertElement(TripletTable* table, int row, int col, int value) {
    if (table->length >= MAX_SIZE) {
        printf("Table is full. Cannot insert more elements.\n");
        return;
    }

    Triple* element = &(table->data[table->length]);
    element->row = row;
    element->col = col;
    element->value = value;

    table->length++;
}

void displayMatrix(TripletTable* table) {
    int matrix[table->rows][table->cols];
    for (int i = 0; i < table->rows; i++) {
        for (int j = 0; j < table->cols; j++) {
            matrix[i][j] = 0;
        }
    }
//    printf("Row\tColumn\tValue\n");
    for (int i = 0; i < table->length; i++) {
        Triple* element = &(table->data[i]);
//        printf("%d\t%d\t%d\n", element->row, element->col, element->value);
        matrix[element->row][element->col] = element->value;
    }

//    printf("Matrix:\n");
    for (int i = 0; i < table->rows; i++) {
        for (int j = 0; j < table->cols; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
}
TripletTable matrixAddition(TripletTable* table1, TripletTable* table2) {
    TripletTable result;
    initTable(&result, table1->rows, table1->cols);

    int i = 0, j = 0;
    while (i < table1->length && j < table2->length) {
        Triple* element1 = &(table1->data[i]);
        Triple* element2 = &(table2->data[j]);

        if (element1->row < element2->row || (element1->row == element2->row && element1->col < element2->col)) {
            insertElement(&result, element1->row, element1->col, element1->value);
            i++;
        } else if (element1->row > element2->row || (element1->row == element2->row && element1->col > element2->col)) {
            insertElement(&result, element2->row, element2->col, element2->value);
            j++;
        } else {
            int sum = element1->value + element2->value;
            if (sum != 0) {
                insertElement(&result, element1->row, element1->col, sum);
            }
            i++;
            j++;
        }
    }

    while (i < table1->length) {
        Triple* element1 = &(table1->data[i]);
        insertElement(&result, element1->row, element1->col, element1->value);
        i++;
    }

    while (j < table2->length) {
        Triple* element2 = &(table2->data[j]);
        insertElement(&result, element2->row, element2->col, element2->value);
        j++;
    }

    return result;
}



TripletTable matrixMultiplication(TripletTable* table1, TripletTable* table2) {
    TripletTable result;
    initTable(&result, table1->rows, table2->cols);

    int matrix[table1->rows][table2->cols];
    for (int i = 0; i < table1->rows; i++) {
        for (int j = 0; j < table2->cols; j++) {
            matrix[i][j] = 0;
        }
    }

    for (int i = 0; i < table1->length; i++) {
        Triple* element1 = &(table1->data[i]);

        for (int j = 0; j < table2->length; j++) {
            Triple* element2 = &(table2->data[j]);

            if (element1->col == element2->row) {
                matrix[element1->row][element2->col] += element1->value * element2->value;
            }
        }
    }

    for (int i = 0; i < table1->rows; i++) {
        for (int j = 0; j < table2->cols; j++) {
            if (matrix[i][j] != 0) {
                insertElement(&result, i, j, matrix[i][j]);
            }
        }
    }

    return result;
}

TripletTable matrixTranspose(TripletTable* table) {
    TripletTable result;
    initTable(&result, table->cols, table->rows);  // 转置后的矩阵行列互换
    int j = 0;
    for (int k = 0; k < table->cols; k++) {
        for (int i = 0; i < table->length; i++) {
            Triple* element = &(table->data[i]);
            if (element->col == k) {
                insertElement(&result, k, element->row, element->value);
//                result.data[j].row = k;  // 该元素在result中的行号应为k
//                result.data[j].col = element->row;  // 该元素在result中的列号应为其在table中的行号
//                result.data[j].value = element->value;
                j++;  // 考察result中的下一个结点
                result.length = j;  // 更新result的长度
            }
        }
//        printf("\n");
//        displayMatrix(&result);

    }
    return result;
}


int main() {
    TripletTable matrixA, matrixB;
    initTable(&matrixA, 3, 3);
    initTable(&matrixB, 3, 3);

    // Insert elements into matrix A
    insertElement(&matrixA, 0, 0, 1);
    insertElement(&matrixA, 0, 2, 2);
    insertElement(&matrixA, 1, 1, 3);
    insertElement(&matrixA, 2, 0, 4);
    insertElement(&matrixA, 2, 2, 5);

    // Insert elements into matrix B
    insertElement(&matrixB, 0, 1, 6);
    insertElement(&matrixB, 1, 0, 7);
    insertElement(&matrixB, 1, 2, 8);
    insertElement(&matrixB, 2, 1, 9);

    printf("Matrix A:\n");
    displayMatrix(&matrixA);

    printf("\nMatrix B:\n");
    displayMatrix(&matrixB);

    TripletTable matrixC = matrixAddition(&matrixA, &matrixB);
    printf("\nMatrix A + B:\n");
    displayMatrix(&matrixC);

    TripletTable matrixD = matrixTranspose(&matrixA);
    printf("\nTranspose of Matrix A:\n");
    displayMatrix(&matrixD);

    TripletTable matrixE = matrixMultiplication(&matrixA, &matrixB);
    printf("\nMatrix A * B:\n");
    displayMatrix(&matrixE);
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1140754.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux | 进程地址空间

Linux | 进程地址空间

目录 前言 一、初始进程地址空间 1、实验引入 2、虚拟地址空间 二、什么是进程地址空间 1、基本概念 2、深入理解进程地址空间 3、进程地址空间的本质 4、遗留问题解决 三、为什么要有进程地址空间 1、知识扩展 2、进程地址空间存在意义 3、重新理解挂起 前言 本…
阅读更多...
[SQL开发笔记]SQL 别名：为表名称或列名称指定别名

[SQL开发笔记]SQL 别名：为表名称或列名称指定别名

一、功能描述&#xff1a; 通过使用 SQL&#xff0c;可以为表名称或列名称指定别名。基本上&#xff0c;创建别名是为了让列名称的可读性更强。 二、SQL 别名语法详解&#xff1a; &#xff08;1&#xff09;列的 SQL 别名语法&#xff1a; Select column_name AS alias_nam…
阅读更多...
X86（32位）汇编指令与机器码转换原理

X86（32位）汇编指令与机器码转换原理

X86&#xff08;32位&#xff09;汇编指令与机器码转换原理 1 32位寻址形式下的ModR/M字节2 汇编指令转机器码2.1 mov ecx,[eaxebx*2]2.1.1 查Opcode和ModR/M2.1.2 查SIB 2.2 mov ecx,[eaxebx*210h]2.3 mov ecx,[eaxebx*200000100h] 本文属于《 X86指令基础系列教程》之一&…
阅读更多...
Spring Cloud Gateway + Knife4j 4.3 接口文档整合和网关聚合

Spring Cloud Gateway + Knife4j 4.3 接口文档整合和网关聚合

目录 前言Spring Cloud 整合 Knife4jpom.xmlapplication.ymlSwaggerConfig.java访问单服务接口文档 Spring Cloud Gateway 网关聚合pom.xmlapplication.yml访问网关聚合接口文档 接口测试**登录认证**获取登录用户信息 结语源码 前言 youlai-mall 开源微服务商城新版本基于 Sp…
阅读更多...
数据库SqlServer笔试题

数据库SqlServer笔试题

数据库SqlServer笔试题 一、数据库基础知识&#xff08;通用&#xff09;篇 1.说说主键、外键、超键、候选键 超键&#xff1a;在关系中能唯一标识元组的属性集称为关系模式的超键。一个属性可以为作为一个超键&#xff0c;多个属 性组合在一起也可以作为一个超键。超键包含…
阅读更多...
CSGO游戏搬砖的10个冷知识，90%的人还不知道

CSGO游戏搬砖的10个冷知识，90%的人还不知道

敲黑板了&#xff0c;同学们&#xff0c;很多人号一多就蒙圈&#xff0c;接下来解释一下buff号、Steam号、选品软件、识别码&#xff0c;桌面令牌&#xff0c;手机令牌&#xff0c;几者的关系: 1、前期一套实名只能绑定两个buff号&#xff0c;steam账号无需实名&#xff0c;后期…
阅读更多...
安装和配置Maven，IDEA中配置Maven

安装和配置Maven，IDEA中配置Maven

一、安装 Maven 首先创建一个空的文件夹&#xff0c;文件夹不能是中文或者其他特殊字符&#xff0c;然后将maven文件解压到这个空的文件夹 解压 二、配置环境变量 电脑右键 高级系统设置 输入以下内容 编辑好之后一直点击确定 验证是否安装成功&#xff0c;winR输入cmd进入命令…
阅读更多...
docker 部署 若依 Ruoyi springboot+vue分离版

docker 部署 若依 Ruoyi springboot+vue分离版

本篇从已有虚拟机/服务器 安装好dokcer为基础开始讲解 1.部署mysql 创建conf data init三个文件夹 conf目录存放在mysql配置文件 init目录存放着若依数据库sql文件&#xff08;从navicat导出的并非若依框架自带sql&#xff09; 创建一个属于本次若依部署的网段&#xff08;只…
阅读更多...
nc65单据穿透

nc65单据穿透

nc65单据穿透 jych项目 1.支出合同台账合同号字段可以穿透到对应的单据上 一个合同号穿透到一个物质设备采购合同上 1.支出合同台账单据模板合同号字段卡片下和列表下高级属性勾选是否超链接 2.支出合同台账中增加监听类 HeadItemLinkListener.java package nc.ui.jych.…
阅读更多...
如何处理 Python 报错 can‘t multiply sequence by non-int of type float

如何处理 Python 报错 can‘t multiply sequence by non-int of type float

大多数时候&#xff0c;当你在编程时遇到错误&#xff0c;你可以在错误信息中发现错误发生的原因以及如何解决它。 Python 错误 “TypeError: can’t multiply sequence by non-int of type float” 也不例外。 我准备了这篇文章&#xff0c;向你展示这个错误发生的原因以及如…
阅读更多...
目标检测及锚框、IoU

目标检测及锚框、IoU

1. 目标检测 物体检测&#xff08;目标检测&#xff09;是计算机视觉和数字图像处理的热门方向&#xff0c;意在判断一幅图像上是否存在感兴趣物体&#xff0c;并给出物体分类及位置等&#xff08;What and Where&#xff09;。本文主要进行物体检测研究背景、发展脉络、相关算…
阅读更多...
MySQL的概念和sql语句

MySQL的概念和sql语句

数据库的概念 数据库的概念&#xff1a;数据库是用来组织&#xff08;各个数据之间是有关联&#xff0c;是按规则组织起来的&#xff09;&#xff0c;存储和管理&#xff08;增&#xff0c;删&#xff0c;改&#xff0c;查&#xff09;的仓库 数据库管理系统&#xff08;DBMS&…
阅读更多...
写保护设置——三、I2C EEPROM

写保护设置——三、I2C EEPROM

三、I2C EEPROM I2C通讯的EEPROM只有硬保护&#xff0c;没有软保护。 以AT24C01A/02/04/16型EEPROM和AT24C02A/04A/08A/16A型EEPROM为例&#xff0c;管脚定义和写保护WP功能分别如下。 &#xff08;1&#xff09;AT24C01A/02/04/16型EEPROM 规格书&#xff1a; AT24C01A/02…
阅读更多...
软件测试行情不好，我还是啃下了27K的offer

软件测试行情不好，我还是啃下了27K的offer

o “会代码吗&#xff1f;” o “会&#xff0c;Java、Python我都会一些&#xff01;” o “有没有用代码开发过一些测试工具平台呢&#xff1f;” o “额。。。这个。。。没做过。。。” o “那你回去等消息吧” 软件测试行业发展到今天&#xff0c;测试人员会代码&#x…
阅读更多...
Jtti：Apache服务的反向代理及负载均衡怎么配置

Jtti：Apache服务的反向代理及负载均衡怎么配置

配置Apache服务的反向代理和负载均衡可以帮助您分散负载并提高应用程序的可用性和性能。下面是一些通用的步骤&#xff0c;以配置Apache反向代理和负载均衡。 1. 安装和配置Apache&#xff1a; 确保您已经安装了Apache HTTP服务器。通常&#xff0c;Apache的配置文件位于/etc…
阅读更多...
城中村智能水电表改造，提升居民生活品质

城中村智能水电表改造，提升居民生活品质

随着我国城市化进程的加快&#xff0c;城中村成为了城市发展的焦点。然而&#xff0c;由于历史原因&#xff0c;城中村的水电设施普遍存在老化、破损等问题&#xff0c;给居民生活带来诸多不便。为了提升城中村居民的生活品质&#xff0c;智能水电表的推广和改造已成为当务之急…
阅读更多...
css：button实现el-radio效果

css：button实现el-radio效果

先看最终效果&#xff1a; ​​​ 思路&#xff1a; 一、 首先准备好按钮内容&#xff1a;const a [one,two,three] 将按钮循环展示出来&#xff0c;并设置一些样式&#xff0c;将按钮背景透明&#xff1a; <button v-for"(item,index) in a" :key"in…
阅读更多...
创造健康、造福一方，强强联合共筑新疆妇幼健康梦

创造健康、造福一方，强强联合共筑新疆妇幼健康梦

改善优生优育全程服务&#xff0c;提供优质生育全程医疗保健服务&#xff0c;强化孕前优生健康检查、产前筛查以及不孕不育诊治服务等&#xff0c;是国家《“十四五”国民健康规划》的重要内容。为向全疆群众提供国内一流的妇幼保健诊疗服务&#xff0c;满足群众“生的出、生的…
阅读更多...
【威联通】共享文件夹设置

【威联通】共享文件夹设置

1. 前期准备 下载 QNAPQsyncClient 然后安装此软件&#xff0c;安装的目标文件夹可以更换到其他盘&#xff0c;如下图所示 点击 确定 点击 完成 弹出框中选择 中国 然后点击 套用 点击 跳过 点击 完成 勾选方框&#xff0c;然后点击 确定 第一个框中输入需要同步的 NAS IP 地址…
阅读更多...
MFA-Conformer

MFA-Conformer

基于多尺度特征聚合Conformer说话人识别模型的创新与应用 论文&#xff1a;https://arxiv.org/abs/2203.15249 代码&#xff1a;GitHub - zyzisyz/mfa_conformer 收录于 INTERSPEECH 2022 1. 简介 本文由清华大学与腾讯科技&#xff08;北京&#xff09;有限公司、台湾大学…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023