密匙单词加密（加密问题）

题目要求：

一种Playfair密码变种加密方法如下：首先选择一个密钥单词（称为pair）（字母不重复，且都为小写字母），然后与字母表中其他字母一起填入至一个5x5的方阵中，填入方法如下：

1.首先按行填入密钥串。

2.紧接其后，按字母序按行填入不在密钥串中的字母。

3.由于方阵中只有25个位置，最后剩下的那个字母则不需变换。

如果密钥为youandme，则该方阵如下：  

y o u a n

d m e b c

f g h i j

k l p q r

s t v w x

在加密一对字母时，如am，在方阵中找到以这两个字母为顶点的矩形（红色字体）：

y o u a n

d m e b c

f g h i j

k l p q r

s t v w x

这对字母的加密字母为该矩形的另一对顶点，如本例中为ob。

请设计程序，使用上述方法对输入串进行加密，并输出加密后的串。

另外有如下规定：

1、一对一对取字母，如果最后只剩下一个字母，则不变换，直接放入加密串中；

2、如果一对字母中的两个字母相同，则不变换，直接放入加密串中；

3、如果一对字母中有一个字母不在正方形中，则不变换，直接放入加密串中；

4、如果字母对出现在方阵中的同一行或同一列，如df或hi，则只需简单对调这两个字母，即变换为fd或ih；

5、如果在正方形中能够找到以字母对为顶点的矩形，假如字母对为am，则该矩形的另一对顶点字母中，与a同行的字母应在前面，在上例中应是ob；同样若待变换的字母对为ta，则变换后的字母对应为wo；

6、本程序中输入串均为小写字母，并不含标点、空格或其它字符。

解密方法与加密相同，即对加密后的字符串再加密，将得到原始串。

要求输入形式如下：

从控制台输入两行字符串，第一行为密钥单词（长度小于等于25），第二行为待加密字符串（长度小于等于50），两行字符串末尾都有一个回车换行符，并且两行字符串均为小写字母，不含其它字符。

在标准输出上输出加密后的字符串。

例如，若输入：

youandme

welcometohangzhou

则表示输入的密钥单词为youandme，形成的正方形如上所示；待加密字符串为welcometohangzhou。在正方形中可以找到以第一对字母we为顶点的矩形，对应另一对顶点字母为vb，因此加密后为vb，同理可找到与字母对lc,et,oh,ho对应的顶点字母对。而字母对om位于上述正方形中的同一列，所以直接以颠倒这两个字母来加密，即为mo，字母对an同理。字母对gz中的z不在上述正方形中，因此原样放到加密串中。最后剩一个字母u也原样输出。

因此输出的结果为：

vbrmmomvugnagzguu

输入：
youandme
vbrmmomvugnagzguu
输出：
welcometohangzhou

输入：
meandyou
ahugeuvcdtgwhnewhndwhneivfnag
输出：
haohaoxuexitiantianxiangshang


输入：
m
zhnoggyjmgeohog
输出：
zhongguobeijing


输入：
zyxwvutsrqponmlkjihgfedcb（注意：长度大于25）
wknoggtpebjinihgaiidan
输出：
zhongguobeijinghaidian


输入：
az
adtxyabyy
输出：
daxtyabyy

程序如下：

import java.util.Scanner;

/*加密*/
public class SecretWord {

    private static char[][] a=new char[5][5];//方阵
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();//密匙单词
        String s2=sc.nextLine();//待加密字符串
        //给方阵放入数据
        int len=s.length();
        int f=0;
        int i=0,j=0;
        //将满一行的字母放入方阵
        if(len<25)//密匙单词小于25
        {
            for( i=0;i<len/5;i++)
            {
                for(j=0;j<5;j++)
                {
                    a[i][j]=s.charAt(f++);
                }
            }
            //将不满一行的那一行放入方阵
            int t=0;
            for(int l=f;l<len;l++,t++)
            {
                a[i][t]=s.charAt(l);   
            }
            //将不满一行补满
            char c='a';
            for(int t2=t;t2<5;t2++)
            {
                for(;c<='z';c++)
                {
                    if(s.contains(c+"")==false)
                        break;
                }
                a[i][t2]=c;
                c++;
            }
            //将剩下的行补满
            for(int t2=i+1;t2<5;t2++)
            {
                for(int t3=0;t3<5;t3++)
                {
                    for(;c<='z';c++)
                    {
                        if(s.contains(c+"")==false)
                            break;
                    }
                    a[t2][t3]=c;
                    c++;
                }    
            }
        }
        else// 密匙单词大于25
        {
            len=25;
            for( i=0;i<len/5;i++)
            {
                for(j=0;j<5;j++)
                {
                    a[i][j]=s.charAt(f++);
                }
            }
        }
        //输出方阵
        for(int l1=0;l1<5;l1++)
        {
            for(int l2=0;l2<5;l2++)
            {
                System.out.print(a[l1][l2]);
            }
            System.out.println();    
        }
        //加密
        jiaMi(s2);
    }

    //  待加密字符串
    public static void jiaMi(String s2)
    {
        String result="";//保存加密后的字符串
        int le=0;
        boolean b=false;//标记需要加密的字符串长度是否为奇数
        if(s2.length()%2==0)
            le=s2.length();
        else
        {
            b=true;
            le=s2.length()-1;
        }   
        for(int i=0;i<le;i+=2)//没两个字母一组开始加密
        {
            char c1=s2.charAt(i);
            char c2=s2.charAt(i+1);
            if(c1==c2)//两个字母相同
            {
                result+=c1;
                result+=c2;
                continue;
            }
            int c1x=-1,c1y=-1,c2x=-1,c2y=-1;
            //查找c1的位置
            for(int l=0;l<5;l++)
            {
                for(int m=0;m<5;m++)
                {
                    if(a[l][m]==c1)
                    {
                        c1x=l;
                        c1y=m;
                    }
                }
            }
            //查找c2的位置
            for(int l=0;l<5;l++)
            {
                for(int m=0;m<5;m++)
                {
                    if(a[l][m]==c2)
                    {
                        c2x=l;
                        c2y=m;
                    }
                }
            }
            if(c1x==-1||c2x==-1)//两个字母中有一个字母不在方阵中
            {
                result+=c1;
                result+=c2;
                continue;
            }
            if(c1x==c2x||c1y==c2y)//两字母出现在同一行或同一列
            {
                result+=c2;
                result+=c1;
            }
            else//两个位置可以构成一个矩形，那么加密的另两个字符是原来的位置列不
                //变行互换的字母，同行的替换同行的
            {
                //列不变行互换
                int temp=c1x;
                c1x=c2x;
                c2x=temp;
                result+=a[c2x][c2y];
                result+=a[c1x][c1y];   
            }
            
            
        }
        if(b)//需要加密的长度是奇数需要处理最后一个
        {
            result+=s2.charAt(s2.length()-1);
        }
        //输出结果
        System.out.println(result);
        
    }
    
}