矩陣轉置演算法加密

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. 還有更復雜的我就不說了，自行網路。