矩阵转置算法加密

A. 在c#中如何用矩阵在加密解密中

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

//矩阵数据结构
//二维矩阵
class _Matrix
{
public int m;
public int n;
public float[] arr;

//初始化
public _Matrix()
{
m = 0;
n = 0;
}

public _Matrix(int mm,int nn)
{
m = mm;
n = nn;
}

//设置m
public void set_mn(int mm,int nn)
{
m = mm;
n = nn;
}

//设置m
public void set_m(int mm)
{
m = mm;
}

//设置n
public void set_n(int nn)
{
n = nn;
}

//初始化
public void init_matrix()
{
arr = new float[m * n];
}

//释放
public void free_matrix()
{
//delete [] arr;
}

//读取i,j坐标的数据
//失败返回-31415,成功返回值
public float read(int i,int j)
{
if (i >= m || j >= n)
{
return -31415;
}

//return *(arr + i * n + j);
return arr[i * n + j];
}

//写入i,j坐标的数据
//失败返回-1,成功返回1
public int write(int i,int j,float val)
{
if (i >= m || j >= n)
{
return -1;
}

arr[i * n + j] = val;
return 1;
}
};

//二维运算类
class _Matrix_Calc
{
//初始化
public _Matrix_Calc()
{

}

//C = A + B
//成功返回1,失败返回-1
public int add(ref _Matrix A,ref _Matrix B,ref _Matrix C)
{
int i = 0;
int j = 0;

//判断是否可以运算
if (A.m != B.m || A.n != B.n ||
A.m != C.m || A.n != C.n)
{
return -1;
}
//运算
for (i = 0;i < C.m;i++)
{
for (j = 0;j < C.n;j++)
{
C.write(i,j,A.read(i,j) + B.read(i,j));
}
}

return 1;
}

//C = A - B
//成功返回1,失败返回-1
public int subtract(ref _Matrix A,ref _Matrix B, ref _Matrix C)
{
int i = 0;
int j = 0;

//判断是否可以运算
if (A.m != B.m || A.n != B.n ||
A.m != C.m || A.n != C.n)
{
return -1;
}
//运算
for (i = 0;i < C.m;i++)
{
for (j = 0;j < C.n;j++)
{
C.write(i,j,A.read(i,j) - B.read(i,j));
}
}

return 1;
}

//C = A * B
//成功返回1,失败返回-1
public int multiply(ref _Matrix A, ref _Matrix B, ref _Matrix C)
{
int i = 0;
int j = 0;
int k = 0;
float temp = 0;

//判断是否可以运算
if (A.m != C.m || B.n != C.n ||
A.n != B.m)
{
return -1;
}
//运算
for (i = 0;i < C.m;i++)
{
for (j = 0;j < C.n;j++)
{
temp = 0;
for (k = 0;k < A.n;k++)
{
temp += A.read(i,k) * B.read(k,j);
}
C.write(i,j,temp);
}
}

return 1;
}

//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
public float det(ref _Matrix A)
{
float value = 0;

//判断是否可以运算
if (A.m != A.n || (A.m != 2 && A.m != 3))
{
return -31415;
}
//运算
if (A.m == 2)
{
value = A.read(0,0) * A.read(1,1) - A.read(0,1) * A.read(1,0);
}
else
{
value = A.read(0,0) * A.read(1,1) * A.read(2,2) +
A.read(0,1) * A.read(1,2) * A.read(2,0) +
A.read(0,2) * A.read(1,0) * A.read(2,1) -
A.read(0,0) * A.read(1,2) * A.read(2,1) -
A.read(0,1) * A.read(1,0) * A.read(2,2) -
A.read(0,2) * A.read(1,1) * A.read(2,0);
}

return value;
}

//求转置矩阵,B = AT
//成功返回1,失败返回-1
public int transpos(ref _Matrix A,ref _Matrix B)
{
int i = 0;
int j = 0;

//判断是否可以运算
if (A.m != B.n || A.n != B.m)
{
return -1;
}
//运算
for (i = 0;i < B.m;i++)
{
for (j = 0;j < B.n;j++)
{
B.write(i,j,A.read(j,i));
}
}

return 1;
}

//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
public int inverse(ref _Matrix A, ref _Matrix B)
{
int i = 0;
int j = 0;
int k = 0;
_Matrix m = new _Matrix(A.m,2 * A.m);
float temp = 0;
float b = 0;

//判断是否可以运算
if (A.m != A.n || B.m != B.n || A.m != B.m)
{
return -1;
}

/*
//如果是2维或者3维求行列式判断是否可逆
if (A.m == 2 || A.m == 3)
{
if (det(A) == 0)
{
return -1;
}
}
*/

//增广矩阵m = A | B初始化
m.init_matrix();
for (i = 0;i < m.m;i++)
{
for (j = 0;j < m.n;j++)
{
if (j <= A.n - 1)
{
m.write(i,j,A.read(i,j));
}
else
{
if (i == j - A.n)
{
m.write(i,j,1);
}
else
{
m.write(i,j,0);
}
}
}
}

//高斯消元
//变换下三角
for (k = 0;k < m.m - 1;k++)
{
//如果坐标为k,k的数为0,则行变换
if (m.read(k,k) == 0)
{
for (i = k + 1;i < m.m;i++)
{
if (m.read(i,k) != 0)
{
break;
}
}
if (i >= m.m)
{
return -1;
}
else
{
//交换行
for (j = 0;j < m.n;j++)
{
temp = m.read(k,j);
m.write(k,j,m.read(k + 1,j));
m.write(k + 1,j,temp);
}
}
}

//消元
for (i = k + 1;i < m.m;i++)
{
//获得倍数
b = m.read(i,k) / m.read(k,k);
//行变换
for (j = 0;j < m.n;j++)
{
temp = m.read(i,j) - b * m.read(k,j);
m.write(i,j,temp);
}
}
}
//变换上三角
for (k = m.m - 1;k > 0;k--)
{
//如果坐标为k,k的数为0,则行变换
if (m.read(k,k) == 0)
{
for (i = k + 1;i < m.m;i++)
{
if (m.read(i,k) != 0)
{
break;
}
}

B. 矩阵的转置怎么算

设矩阵a经过初等行变换之后，化为上三角矩阵b，则a等价于b

矩阵a'经过初等列变换之后，可化为下三角矩阵c，则a'等价于c

显然，b的转置矩阵b'=c

因为，转置之后对角线上的元素不变，所以，b和c的对角线元素相等。

因为，三角形行列式的值等于对角线上元素的乘积

又因为，|λi-a|=|λi-b|=对角线上元素的乘积，

|λi-a'|=|λi-c|=对角线上元素的乘积

所以，|λi-a|=|λi-a'|

所以，矩阵a与矩阵a的转置矩阵的特征值相同

(2)矩阵转置算法加密扩展阅读：

化成三角形行列式法：先把行列式的某一行（列）全部化为 1 ，再利用该行（列）把行列式化为三角形行列式，从而求出它的值，这是因为所求行列式有如下特点：

1、各行元素之和相等；

2 各列元素除一个以外也相等。

充分利用行列式的特点化简行列式是很重要的。

根据行列式的特点，利用行列式性质把某行（列）化成只含一个非零元素，然后按该行（列）展开。展开一次，行列式降低一阶，对于阶数不高的数字行列式本法有效。

C. 矩阵怎么进行转置操作

【矩阵转置操作】设A为m×n阶矩阵（即m行n列），第i 行j 列的元素是a（i，j），即：A=a（i，j），定义A的转置为这样一个n×m阶矩阵B，满足B=a（j，i），即 b (i,j)=a （j，i）（B的第i行第j列元素是A的第j行第i列元素），记A'=B。(有些书记为AT=B，这里T为A的上标）直观来看，将A的所有元素绕着一条从第1行第1列元素出发的右下方45度的射线作镜面反转，即得到A的转置。

【矩阵】英文：Matrix，本意是子宫、控制中心的母体、孕育生命的地方。在数学上，矩阵是指纵横排列的二维数据表格，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。矩阵概念在生产实践中也有许多应用，比如矩阵图法以及保护个人帐号的矩阵卡系统（由深圳网域提出）等等。“矩阵”的本意也常被应用，比如监控系统中负责对前端视频源与控制线切换控制的模拟设备也叫矩阵。

D. 稀疏矩阵的转置算法有什么用

稀疏矩阵是某个固定值元素比较多的矩阵，使用三元组存储是为了减少存储该矩阵的存储空间，而其转置算法就是为了解决矩阵的基本转制功能。这个涉及线性数学，如果您对转置有什么需要了解的可以看看。矩阵可以解决很多的多项式问题，同时也是对图的一种描述方法，因此其转置功能作为矩阵的基本特性也就很重要。

E. 转置矩阵的C++算法

#include <stdio.h>

#define M 10
#define N 10

int main ()
{
int a[M][N],b[N][M];
int i, j;
printf("In put a[M][N]");
for(i=0;i<M;i++)
for(j=0;j<N;j++)
scanf("%d",a);
for(i=0;i<M;i++)
{
for(j=0;j<N;j++) {
/*b[j][i] = a[i][j];*/ /*数组方式*/
*(*(b+j)+i) = *(*(a+i)+j);/*指针方式*/
}
}
for(i=0;i<M;i++)
{
for(j=0;j<N;j++) {
printf("%d ",*(*(b+i)+j));
}
printf("\n");
}
return 0;
}
和C++差不多吧
改一下就可以了

F. 求稀疏矩阵快速转置算法及代码

typedef struct
{ int row ; /* 行下标 */
int col ; /* 列下标 */
elemtype value; /* 元素值 */
}Triple ;
typedef struct
{ int rn ; /* 行数 */
int cn ; /* 列数 */
int tn ; /* 非0元素个数 */
Triple data[MAX_SIZE] ;
}TMatrix ;
快速转置的算法
算法思想：直接按照稀疏矩阵A的三元组表a.data的次序依次顺序转换，并将转换后的三元组放置于三元组表b.data的恰当位置。
前提：若能预先确定原矩阵A中每一列的(即B中每一行)第一个非0元素在b.data中应有的位置，则在作转置时就可直接放在b.data中恰当的位置。因此，应先求得A中每一列的非0元素个数。
附设两个辅助向量num[ ]和cpot[ ] 。
◆ num[col]：统计A中第col列中非0元素的个数；
◆ cpot[col] ：指示A中第一个非0元素在b.data中的恰当位置。
显然有位置对应关系：
cpot[1]=1
cpot[col]=cpot[col-1]+num[col-1] 2≦col≦a.cn
快速转置算法如下：
void FastTransMatrix(TMatrix a, TMatrix b)
{ int p , q , col , k ;
int num[MAX_SIZE] , copt[MAX_SIZE] ;
b.rn=a.cn ; b.cn=a.rn ; b.tn=a.tn ;
/* 置三元组表b.data的行、列数和非0元素个数 */
if (b.tn==0) printf(“ The Matrix A=0\n” ) ;
else
{ for (col=1 ; col<=a.cn ; ++col) num[col]=0 ;
/* 向量num[]初始化为0 */
for (k=1 ; k<=a.tn ; ++k)
++num[ a.data[k].col] ;
/* 求原矩阵中每一列非0元素个数 */
for (cpot[0]=1, col=2 ; col<=a.cn ; ++col)
cpot[col]=cpot[col-1]+num[col-1] ;
/* 求第col列中第一个非0元在b.data中的序号 */
for (p=1 ; p<=a.tn ; ++p)
{ col=a.data[p].col ; q=cpot[col] ;
b.data[q].row=a.data[p].col ;
b.data[q].col=a.data[p].row ;
b.data[q].value=a.data[p].value ;
++cpot[col] ; /*至关重要!!当本列中 */
}
}
}

G. 稀疏矩阵与转置算法

#include<stdio.h>
#include<stdlib.h>

typedefstruct{
introw;
intcol;
intdata;
}xishu;//存储稀疏矩阵的结构(行，列，值)


#defineMAX_COL10
//staticvoidtranspose(xishua[],xishub[]);//普通算法

staticvoidfasttranspose(xishua[],xishub[]);//改进的算法

staticvoidcreate(inta[][6],intm,intn,xishub[],int*count);
staticvoidprint(int*count,xishua[]);

intmain(intargc,char**argv)
{
inta[6][6]={{0,0,0,22,0,-1},{0,71,0,0,0,0},{0,0,0,88,0,0},
{0,0,-9,0,0,0},{0,0,0,0,0,0},{0,0,0,0,0,7}};
xishub[10],c[10];
intcount=0,i,k;

for(i=0;i<10;i++){
b[i].row=c[i].row=0;
b[i].col=c[i].col=0;
b[i].data=c[i].data=0;
}//初始化


create(a,6,6,b,&count);//建立一个以xishu为元素的数组来表示一个稀疏矩阵

printf("
beforetranpose
");
print(&count,b);//打印建立好的稀疏矩阵


//transpose(b,c);

fasttranspose(b,c);//建立转置矩阵

printf("
aftertranspos
");
print(&count,c);//打印转置矩阵

exit(0);
}

staticvoidprint(int*count,xishua[])
{
intk;

for(k=1;k<=*count;k++){
printf("%d	%d	%d
",a[k].row,a[k].col,a[k].data);
}
}

staticvoidcreate(inta[][6],intm,intn,xishub[],int*count)
{
inti,j;

*count=0;
b[0].row=m;
b[0].col=n;

for(i=0;i<m;i++){
for(j=0;j<n;j++){
if(a[i][j]!=0){
(*count)++;
b[*count].row=i;
b[*count].col=j;
b[*count].data=a[i][j];
}
}
}
b[0].data=*count;
}

/***
staticvoidtranspose(xishua[],xishub[])
{
//该算法的时间代价为O(a[0].data*a[0].data)

intcount=0;
inti,col;

b[0].row=a[0].col;
b[0].col=a[0].row;
b[0].data=a[0].data;
printf("%d,%d,%d
",b[0].row,b[0].col,b[0].data);
printf("%d,%d,%d
",a[0].row,a[0].col,a[0].data);

for(col=0;col<a[0].col;col++){
for(i=1;i<=a[0].data;i++){
if(a[i].col==col){
count++;
b[count].row=a[i].col;
b[count].col=a[i].row;
b[count].data=a[i].data;
}
}
}
}
***/
staticvoidfasttranspose(xishua[],xishub[])
{
//改进的算法，该算法的时间代价为O(a[0].col+a[0].data)

inti,pos;
introw_num[MAX_COL];
intstart_pos[MAX_COL];

b[0].row=a[0].col;
b[0].col=a[0].row;
b[0].data=a[0].data;

for(i=0;i<a[0].col;i++){
row_num[i]=0;
}
for(i=1;i<=a[0].data;i++){
row_num[a[i].col]++;
}

start_pos[0]=1;
for(i=1;i<a[0].col;i++){
start_pos[i]=start_pos[i-1]+row_num[i-1];
}

for(i=1;i<=a[0].data;i++){
pos=start_pos[a[i].col];
while(b[pos].data!=0){
pos++;
}
b[pos].row=a[i].col;
b[pos].col=a[i].row;
b[pos].data=a[i].data;
}
}

H. 求C语言编程代码和注释。

读写文件这些我就不说了，自行网络吧。

我说一下加密，我猜老师的意图只是要你们练习文件读写，所以要你们设计（或者实现）的加密算法不会太复杂。

简单的加密算法：

1. 置换加密：将字符转换为另一个字符，比如说123，1对应a，2对应r，3对应w、，那么123加密后就是a，r，w。

2. 转置加密：变换明文的字符顺序，比如说157asdwe5，把它看成3*3矩阵，把它转置后为1aw5se7d5

3. 回合加密：以上两者混合

4. 还有更复杂的我就不说了，自行网络。