hill算法

Ⅰ 为什么说加法密码、乘法密码、仿射密码、置换密码、Hill密码以及Vigenere密码

加法密码就是真典密码学中的恺撒密码格式是：密文=(明文+密钥)mod26,剩法密码是恺撒密码发展出来，格式是：密文=明文x实钥mon26；置换密码就是在简单的纵行换位密码中，明文以固定的宽度水平的写在一张图表纸上，密文按垂直方向读出，解密就是密文按相同的宽度垂直的写在图表纸上，然后水平的读出明文。希尔密码（Hill Cipher）是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果MOD26；Vigenere是恺撒密码演变而来。使用一系列凯撒密码组成密码字母表的加密算法，属于多表密码的一种简单形式。
有兴趣可以了解一下古典密码学，这里面都有。

Ⅱ 希尔密码原理

希尔密码（Hill Cipher）是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果MOD26。

中文名
希尔密码
外文名
Hill Cipher
原理
基本矩阵论
类别
替换密码
提出者
Lester S. Hill
快速
导航
产生原因

原理

安全性分析

例子
简介
希尔密码是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。
每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。
注意用作加密的矩阵（即密匙）在必须是可逆的，否则就不可能解码。只有矩阵的行列式和26互质，才是可逆的。
产生原因
随着科技的日新月异和人们对信用卡、计算机的依赖性的加强，密码学显得愈来愈重要。密码学是一门关于加密和解密、密文和明文的学科。若将原本的符号代换成另一种符号，即可称之为广义的密码。狭义的密码主要是为了保密，是一种防止窃文者得知内容而设的另一种符号文字，也是一般人所熟知的密码。
使用信用卡、网络账号及密码、电子信箱、电子签名等都需要密码。为了方便记忆，许多人用生日、电话号码、门牌号码记做密码，但是这样安全性较差。
为了使密码更加复杂，更难解密，产生了许多不同形式的密码。密码的函数特性是明文对密码为一对一或一对多的关系，即明文是密码的函数。传统密码中有一种叫移位法，移位法基本型态是加法加密系统C=P+s(mod m)。一般来说，我们以1表示A，2表示B，……，25表示Y，26表示Z，以此类推。由于s=0时相当于未加密，而0≤s≤m-1（s≥m都可用0≤s≤m-1取代），因此，整个系统只有m-1种变化。换言之，只要试过m-1次，机密的信息就会泄漏出去。
由此看来，日常生活中的密码和传统的密码的可靠性较差，我们有必要寻求一种容易将字母的自然频度隐蔽或均匀化，从而有利于统计分析的安全可靠的加密方法。希尔密码能基本满足这一要求。
原理
希尔加密算法的基本思想是，将d个明文字母通过线性变换将它们转换为d个密文字母。解密只要作一次逆变换就可以了，密钥就是变换矩阵本身。[1]
希尔密码是多字母代换密码的一种。多字母代换密码可以利用矩阵变换方便地描述，有时又称为矩阵变换密码。令明文字母表为Z，若采用L个字母为单位进行代换，则多码代换是映射f：Z→Z。若映射是线性的，则f是线性变换，可以用Z上的L×L矩阵K表示。若是满秩的，则变换为一一映射，且存在有逆变换K。将L个字母的数字表示为Z上的L维矢量m，相应的密文矢量c，且mK=c，以K作为解密矩阵，可由c恢复出相应的明文c·K=m。
在军事通讯中，常将字符（信息）与数字对应（为方便起见，我们将字符和数字按原有的顺序对应，事实上这种对应规则是极易被破解的）：
abcde…x y z
12345…242526
如信息“NOSLEEPPING”对应着一组编码14,15,19,12,5,5,16,16,9,14,7。但如果按这种方式直接传输出去，则很容易被敌方破译。于是必须采取加密措施，即用一个约定的加密矩阵K乘以原信号B，传输信号为C=KB（加密），收到信号的一方再将信号还原（破译）为B=KC。

Ⅲ c语言编写hill密码

// 希尔算法的加密与解密
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
#include <memory.h>// nDime为全部变量，可逆矩阵的维数
int nDime;
int index = 0;// MAXN为明文的最大长度
const int MAXN = 256;// 矩阵相乘，a是一个列为1的矩阵
void MultiplyMatrix(int a[], int b[][10], int *text)
{
int i, j, t; for (i = 0; i < nDime; i++)
{
t = 0;
for (j = 0;j < nDime; j++)
t += b[i][j] * a[j];
text[index++] = t;
}
}// 求行列式的值
int determinant(int m[][10], int size)
{
int row, column;
int temp1[10], temp2[10], t; for (column = 0; column < size; column++)
{
temp1[column] = m[0][column];
temp2[column] = m[0][column];
}
for (row = 1; row < size; row++)
{
for (column = 0; column < size; column++)
{
int diff = column - row;
int sum = column + row;
if (diff < 0)
diff += size;
if (sum >= size)
sum %= size;
temp1[diff] *= m[row][column];
temp2[sum] *= m[row][column];
}
}
t = 0;
for (row = 0; row < size; row++)
t += temp1[row] - temp2[row]; return t;
}// 求矩阵中某一元素的代数余子式
int func(int matrix[][10], const int i, const int j)
{
int row, column, m, n;
int NewMatrix[10][10]; m = n = 0;
for (row = 0; row < nDime; row++)
{
if (i == row)
continue;
for (column = 0; column < nDime; column++)
{
if (j == column)
continue;
NewMatrix[m++][n++] = matrix[row][column];
}
}

printf ("New Array:\n");
for (row = 0; row < nDime - 1; row++)
{
for (column = 0; column < nDime - 1; column++)
printf("%d ", NewMatrix[row][column]);
printf("\n");
} int sign = (!((i + j) % 2)) ? 1 : -1;
return sign * determinant(NewMatrix, nDime - 1);
}// 对矩阵求逆，cm矩阵与m矩阵互逆
void ConverseMatrix(int m[][10], int cm[][10])
{
// 矩阵求逆，利用数学公式A（逆）= (1 / |A|)乘以A*
// 其中，|A|表示行列式A的值，而A*表示矩阵A的伴随矩阵
int row, column;
int StarMat[10][10]; // StarMat表示m的伴随矩阵
int t; // 初始化伴随矩阵
for (row = 0; row < 10; row++)
for (column = 0; column < 10; column++)
StarMat[row][column] = 0; // 求伴随矩阵
for (row = 0; row < nDime; row++)
for (column = 0; column < nDime; column++)
{
StarMat[row][column] = func(m, row, column);
printf("伴随矩阵：%d", StarMat[row][column]);
} // 求行列式的值
t = determinant(m, nDime); // 求出逆向矩阵
for (row = 0; row < nDime; row++)
for (column = 0; column < nDime; column++)
cm[row][column] = StarMat[row][column] / t;
// 输出逆向矩阵
for (row = 0; row < nDime; row++)
for (column = 0; column < nDime; column++)
printf("%d ", cm[row][column]);
printf("\n");
}// 希尔加密及解密算法
void ShellPassword(int *OText, int TextLen, int matrix[][10], int *text)
{
int i, j, n, a[10];

// 判断要将OText分成几部分
n = TextLen / nDime;
if (TextLen % nDime)
n++; // 矩阵相乘
// 将OText分成的几部分分别与matrix矩阵相乘
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
a[j] = 0;
for (j = 0; j < nDime; j++)
a[j] = OText[i * nDime + j];
MultiplyMatrix(a, matrix, text);
}
}
int main(void)
{
int i, temp, row, column;
// matrix存放加密或解密矩阵，Password为加密后的结果
// OText存放原文转换为普通数字，如A~1，Z~26
int matrix[10][10], ConMatrix[10][10], OText[MAXN], Password[MAXN], OriText[MAXN];
char text[MAXN];
char sel; printf("=================================================\n");
putchar('\n');
printf(" SHELL加密解密器\n");
putchar('\n');
printf("=================================================\n"); while (1)
{
// 初始化矩阵
for (row = 0; row < 10; row++)
for (column = 0; column < 10; column++)
matrix[row][column] = 0; putchar('\n');
printf("1.加密\n");
printf("2.解密\n");
printf("0.退出\n");
printf("请输入你的选择:\n");
sel = getche(); switch (sel)
{
case '1':
printf("\n请输入原文:\n");
memset(text, '\0', sizeof(text) / sizeof(char));
memset(Password, 0, sizeof(Password) / sizeof(int));
gets(text); printf("输入加密矩阵的维数，维数不能超过10维:\n");
scanf("%d", &nDime);
printf("输入矩阵，该矩阵必须为可逆矩阵，否则将不能进行解密:\n");
// 可逆矩阵即，设A为n阶矩阵，如果存n在阶矩阵B使得AB=BA=1
// 则矩阵A是可逆的，称B是A的逆矩阵
for (row = 0; row < nDime; row++)
for (column = 0; column < nDime; column++)
scanf("%d", &matrix[row][column]);
// 将小写字母转换为大写字母
for (i = 0; text[i] != '\0'; i++)
if (islower(text[i]))
text[i] |= 0x20;
// OText存放将字母转换为相应数，如A~1，Z~26
for (i = 0; i < MAXN; i++)
OText[i] = 0;
for (i = 0; text[i] != '\0'; i++)
OText[i] = text[i] - 'A' + 1;
// 加密
ShellPassword(OText, strlen(text), matrix, Password);
// 将加密后的内容打印出来
printf("加密后的内容为:\n");
for (i = 0; i < strlen(text); i++)
printf("%d ", Password[i]);
putchar('\n');
break;
case '2':
break;
case '0':
return 0;
default:
break;
}
getchar();
} return 0;
} 译码算法我会在明天上传上来，你的加密密钥是一个三阶的数组，密文C是：1729 2514 811 1659 2472 858 1739 2514 849 1902 2736 905 1659 2472 858

Ⅳ 爬山算法（Hill Climbing）解决旅行商问题（TSP）

旅行商问题 TSP（Travelling Salesman Problem）是数学领域中着名问题之一。

TSP问题被证明是 NP完全问题 ，这类问题不者宽腔能用精确算法实现，而需要使用相似算法。

TSP问题分为两类： 对称TSP （Symmetric TSP）以及 非对称TSP （Asymmetric TSP）

本文解决的是对称TSP
假设：A表示城市A，B表示城市B，D(A->B)为城市A到城市B的距离，同理D(B->A)为城市B到城市A的距离
对称TSP中，D(A->B) = D(B->A)，城巧升市间形成无向图
非对称TSP中，D(A->B) ≠ D(B->A)，城市间形成有向图

现实生活中，可能出现单行线、交通事故、机票往返价格不同等情况，均可以打破对称性。

爬山算法是一种局部择优的方法，采用启发式方法。直观的解释如下图：

爬山算法，顾名思义就是 爬山 ，找到第一个山峰的时候就停止，作为算法的输出结果。所以，爬首衫山算法容易把局部最优解A作为算法的输出，而我们的目的是找到全局最优解B。

如下图所示，尽管在这个图中的许多局部极大值，仍然可以使用 模拟退火算法（Simulated Annealing） 发现全局最大值。

必要解释详见注释

此处根据经纬度计算城市间距离的公式，请参考 Calculate distance between two latitude-longitude points? (Haversine formula)

此处初始化数据源可以使用 TSPLIB 中所提供的数据，此程序大致阐述爬山算法的实现。

编写于一个失眠夜

菜鸟一枚，欢迎评论区相互交流，加速你我成长•ᴗ•。

Ⅳ 传统的加密方法有哪些

本文只是概述几种简单的传统加密算法，没有DES,没有RSA，没有想象中的高端大气上档次的东东。。。但是都是很传统很经典的一些算法

首先，提到加密，比如加密一段文字，让其不可读，一般人首先会想到的是将其中的各个字符用其他一些特定的字符代替，比如，讲所有的A用C来表示，所有的C用E表示等等…其中早的代替算法就是由Julius Caesar发明的Caesar，它是用字母表中每个字母的之后的第三个字母来代替其本身的（C=E(3，p)=（p+3) mod 26)，但是，这种加密方式，很容易可以用穷举算法来破解，毕竟只有25种可能的情况..

为了改进上诉算法，增加其破解的难度，我们不用简单的有序的替代方式，我们让替代无序化，用其中字母表的一个置换（置换：有限元素的集合S的置换就是S的所有元素的有序排列，且每个元素就出现一次，如S={a,b}其置换就只有两种:ab,ba），这样的话，就有26！种方式，大大的增加了破解的难度，但是这个世界聪明人太多，虽然26！很多，但是语言本身有一定的特性，每个字母在语言中出现的相对频率可以统计出来的，这样子，只要密文有了一定数量，就可以从统计学的角度，得到准确的字母匹配了。

上面的算法我们称之为单表代替，其实单表代替密码之所以较容易被攻破，因为它带有原始字母使用频率的一些统计学特征。有两种主要的方法可以减少代替密码里明文结构在密文中的残留度，一种是对明文中的多个字母一起加密，另一种是采用多表代替密码。

先说多字母代替吧，最着名的就是playfair密码，它把明文中的双字元音节作为一个单元并将其转换成密文的双字元音节，它是一个基于由密钥词构成的5*5的字母矩阵中的，一个例子，如密钥为monarchy，将其从左往右从上往下填入后，将剩余的字母依次填入剩下的空格，其中I/J填入同一个空格:

对明文加密规则如下：
1 若p1 p2在同一行，对应密文c1 c2分别是紧靠p1 p2 右端的字母。其中第一列被看做是最后一列的右方。
2 若p1 p2在同一列，对应密文c1 c2分别是紧靠p1 p2 下方的字母。其中第一行被看做是最后一行的下方。
3 若p1 p2不在同一行，不在同一列，则c1 c2是由p1 p2确定的矩形的其他两角的字母，并且c1和p1， c2和p2同行。
4 若p1 p2相同，则插入一个事先约定的字母，比如Q 。
5 若明文字母数为奇数时，则在明文的末端添加某个事先约定的字母作为填充。

虽然相对简单加密，安全性有所提高，但是还是保留了明文语言的大部分结构特征，依旧可以破解出来，另一个有意思的多表代替密码是Hill密码，由数学家Lester Hill提出来的，其实就是利用了线性代数中的可逆矩阵，一个矩阵乘以它的逆矩阵得到单位矩阵，那么假设我们对密文每m个字母进行加密，那么将这m个字母在字母表中的序号写成矩阵形式设为P（如abc，[1,2,3])，密钥就是一个m阶的矩阵K，则C=P*K mod26，，解密的时候只要将密文乘上K的逆矩阵模26就可以了。该方法大大的增加了安全性。