注意：目前该代码还是Wrong Answer，正在寻找问题所在，欢迎帮我一起寻找。

描述

我们说两个字符串是非常相似的,当且仅当它们的编辑距离小于等于1.

现在我们有两个字符串A和B, 每个单位时间你可以交换字符串A的相邻的两个字符.

问最少需要多少时间,你可以让A和B变得非常相似?保证存在一种这样的方案.

输入
第一行一个字符串,表示A.

第二行一个字符串,表示B.

所有字符串都仅有英文小写字母组成.

A和B的长度都不超过100.

输出
一行表示最少需要的时间.

样例输入

nwlrb
rclwnb

样例输出

6

整体思路：

1、 统计各个字符出现的次数，其中仅可能出现四种情况：
a) 如果B比A多一个字符，那么删除这个多出来的字符，进行后续操作。
b) 如果Ａ比Ｂ多一个字符，则给B在各个位置尝试增加一个字符，然后进行后续操作。
c) 如果A和B长度相同，且各个字母出现次数相同，不加处理直接进行后续操作即可。
d) 如果A和B长度相同，但有两个字母出现次数不同，则有A的某个字母比B的某个字母多一个，另一个字母比B少一个，则依次尝试将B中的该字母换成另一个字母后，进行后续操作。
2、 题目给出的对A串的操作只有交换两个相邻的字符，由优化思想可以知道，如果两个相邻的字符是相同的，则没有必要交换，所以说相同的字符之间的相对顺序是不会改变的，于是当B串固定时，A串变为B串的一一对应关系是确定的，也就是说A串中第k个a一定变到B串种第k个a的位置上。这样问题就转换为求逆序对数量的问题了。第一步中的后续操作指的就是求逆序对的数量。
3、 这里的逆序对的意思是：把B看成有序的，对于任意两个字母，在A中的顺序与在B中的顺序不同，即为逆序。

代码：

import java.util.Scanner;

public class Main {
    public static int cal(String a,String b)//给出两个等长数组，计算步数即计算逆序对的数量
    {
        int step=0;
        int i=0,j=0;
        int[] ach=new int[26];
        int[] bch=new int[26];
        for(i=0;i<a.length();i++)
        {
            ach[a.charAt(i)-'a']++;
        }
        for(i=0;i<b.length();i++)
        {
            bch[b.charAt(i)-'a']++;
        }
        for(i=0;i<26;i++)
            if(ach[i]!=bch[i])
                return Integer.MAX_VALUE;

        int[] num=new int[a.length()];
        char[] chara=a.toCharArray();
        char[] charb=b.toCharArray();
        for(i=0;i<a.length();i++)
        {
            for(j=0;j<a.length();j++)
            {
                if(charb[j]==chara[i])
                {
                    num[i]=j;
                    charb[j]=' ';//防止第二次查找到它，把它设置成空
                    break;
                }
            }
        }
        //然后计算逆序对的数量
        for(i=0;i<a.length();i++)
            for(j=i;j<a.length();j++)
                if(num[i]>num[j])
                    step++;

        return step;
    }
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        String temp;
        String stra=sc.nextLine();
        String strb=sc.nextLine();
        int[] ach= new int[26];//这样数组内容默认都是0
        int[] bch= new int[26];
        int step=Integer.MAX_VALUE;
        if(stra.length()<strb.length())
        {
            for(int i=0;i<strb.length();i++)
            {
                    temp=strb.substring(0, i)+strb.substring(i+1);//此步就是删除了b字符串中的某个字母
                    step=step<cal(stra,temp)?step:cal(stra,temp);
            }   
        }
        if(stra.length()>strb.length())
        {
            for(int i=0;i<strb.length();i++)
            {
                for(char j='a';j<='z';j++)
                {
                    temp=strb.substring(0,i)+j+strb.substring(i);
                    step=step<cal(stra,temp)?step:cal(stra,temp);
                }
            }
        }   
        if(stra.length()==strb.length())
        {
            step=step<cal(stra,strb)?step:cal(stra,strb);
            for(int i=0;i<strb.length();i++)
            {
                for(char j='a';j<='z';j++)
                {
                    temp=strb.substring(0, i)+j+strb.substring(i+1);
                    step=step<cal(stra,temp)?step:cal(stra,temp);
                }
            }
        }
        System.out.println(step);
    }
}