码迷,mamicode.com
首页 > 其他好文 > 详细

单词错误纠正功能 编辑距离 最大公共字串 两个字符串的相似度 差异度

时间:2019-12-11 09:19:42      阅读:79      评论:0      收藏:0      [点我收藏+]

标签:子串   虚拟   system   i++   bsp   纠正   input   dex   删掉   

 

莱文氏距离

i指向a字符串中的字符
j指向b字符串中的字符
s[][]存储第a中第i个字符和b中第j个字符相比较后,最小的莱文氏距离值

状态的转移对应2种,其中字符不相等时有3种情况
1.a[i]==b[j] ,那么 i++ j++ ,距离值保持上一状态的
2.a[i]!=b[j] ,需要增加距离值,那么需要考虑是下面3种情况的哪一种(能得到最小的距离值增量,所以需要做穷举组合处理)
  2.1. i++ (表示a中当前字母当删除处理,或者在b中虚拟添加一个和a[i]一样的字符,处理后,距离值+1,然后i自增指向到下一个a中字符)
  2.2. j++ (和 上例相同,不过是对b处理,或对a中添加一个一样的字符)
  2.3. i++ j++ (将a中的i个字符替换成和b中j一样的,或这 b中的j替换成和a中的i一样(不用真的去操作,只需要距离值+1,然后移动i,j就可以了),距离值需要+1,然后i,j各自增1)

状态转移公式
s[i][j] = min(s[i-1][j-1],s[i-1][j],s[i][j-1]) + (a[i]==b[j] ? 0:1 );

 

//2个字符串之间的编辑距离
//1.莱文氏距离(不同字符的编辑最少编辑次数)
//2.最长公共子串(相同公共字符的最大长度)???
public class EditDst {
    //莱文氏距离
    //逐个比较a,b2个字符串中的字符是否相等
    //若不相等,那么通过往a或b中虚拟的进行 新增字符,删除字符,替换为相同字符 这3个操作,将指向a的下标i,或指向b的下标j,向后直接略过1位字符(此时需要增加编辑次数 +1)
    //比较完所有字符后,将所需编辑的最小次数作为莱文氏距离返回

    //动态规划,莱文氏距离
    //时间 O(n*w)
    //空间 O(n*w)
    //状态转移公式  : s[i][j] = min(s[i-1][j-1],s[i-1][j],s[i][j-1]) + (a[i]==b[j] ? 0:1 );
    public static int lwsDP(char[] a, int alen, char[] b, int blen) {
        int[][] state = new int[alen][blen]; //[i][j]=编辑次数  i->a[i],j->b[j]
        //第一个字母
        state[0][0] = a[0] == b[0] ? 0 : 1;
        //第一列(b[0]和所有a的单个字母比较)
        for (int i = 1; i < alen; i++) {
            state[i][0] = state[i - 1][0] + (a[i] == b[0] ? 0 : 1);
        }
        //第一行(a[0]和所有b的单个字母比较)
        for (int j = 1; j < blen; j++) {
            state[0][j] = state[0][j - 1] + (a[0] == b[j] ? 0 : 1);
        }
        //其余
        for (int i = 1; i < alen; i++) {
            for (int j = 1; j < blen; j++) {
                int prvMin = state[i - 1][j - 1];
                prvMin = prvMin < state[i - 1][j] ? prvMin : state[i - 1][j];
                prvMin = prvMin < state[i][j - 1] ? prvMin : state[i][j - 1];
                state[i][j] = prvMin + (a[i] == b[j] ? 0 : 1);
            }
        }
        return state[alen - 1][blen - 1];
    }


    //动态规划,最长公共子串
    //时间 O(n*w)
    //空间 O(n*w)
    //1. a[i]==b[j] 时,最大公共子串数值+1,进入下一状态 i++ j++
    //2. a[i]!=b[j] 时,最大公共子串数值不变,进入下一状态
    // 2.1. i++ j不变 ,相当于a中当前第i个字b符被虚拟删掉(略过),或相当于在b中虚拟插入一个a[i]相同的字符(并不需要真的插入),然后考察下一字符:i++ j不变
    // 2.2. i不变 j++ , 相当于b中当前第j个字符被虚拟删掉(略过),或相当于在a中虚拟插入一个b[j]相同的字符(并不需要真的插入),然后考察下一字符:i不变 j++
    //
    //和上面莱文氏距离的代码非常相似,只改了10个字符
    //状态转移公式  : s[i][j] = max(s[i-1][j-1],s[i-1][j],s[i][j-1]) + (a[i]==b[j] ? 1:0 );
    public static int lcsDP(char[] a, int alen, char[] b, int blen) {
        int[][] state = new int[alen][blen]; //[i][j]=编辑次数  i->a[i],j->b[j]
        //第一个字母
        state[0][0] = a[0] == b[0] ? 1 : 0;
        //第一列(b[0]和所有a的单个字母比较)
        for (int i = 1; i < alen; i++) {
            state[i][0] = state[i - 1][0] + (a[i] == b[0] ? 1 : 0);
        }
        //第一行(a[0]和所有b的单个字母比较)
        for (int j = 1; j < blen; j++) {
            state[0][j] = state[0][j - 1] + (a[0] == b[j] ? 1 : 0);
        }
        //其余
        for (int i = 1; i < alen; i++) {
            for (int j = 1; j < blen; j++) {
                int prvMax = state[i - 1][j - 1];
                prvMax = prvMax > state[i - 1][j] ? prvMax : state[i - 1][j];
                prvMax = prvMax > state[i][j - 1] ? prvMax : state[i][j - 1];
                state[i][j] = prvMax + (a[i] == b[j] ? 1 : 0);
            }
        }
        return state[alen - 1][blen - 1];
    }

    //纠错,对输入单词a,找到词库中与之对应最接近的单词(莱文氏距离最小的),若莱文氏距离同样小,选最大公共子串值最大的
    public static char[] errorCorrection(char[] a, List<char[]> list) {
        int minlws = Integer.MAX_VALUE;
        int maxlcs = Integer.MIN_VALUE;
        int index = -1;
        for (int i = 0; i < list.size(); i++) {
            int tmplws = lwsDP(a, a.length, list.get(i), list.get(i).length);
            int tmplcs = lcsDP(a, a.length, list.get(i), list.get(i).length);
//            System.out.println("错误纠正 最小差异度:" + tmplws + " , 最大相同度:" + tmplcs + " - " + new String(a) + " - " + new String(list.get(i)));
            if (tmplws < minlws) {
                minlws = tmplws;
                index = i;
            }
            if(tmplcs > maxlcs) {
                maxlcs = tmplcs;
                index = i;
            }
        }
        if (index != -1) {
            System.out.println("错误纠正 最小差异度:" + minlws + " , 最大相同度:" + maxlcs);
            return list.get(index);
        }
        return "".toCharArray();
    }

    public static void main(String[] ar) {
        char[] a = "abcdef".toCharArray();
        char[] b = "abdxf".toCharArray();

        //1.莱文氏距离(差异度)
        System.out.println("===== 莱文氏距离(差异度) =====");
        int lws = lwsDP(a, a.length, b, b.length);
        System.out.println("莱文氏距离 lws :" + lws);

        //2.最大公共子串(相同度)
        System.out.println("\n===== 最大公共子串(相同度) =====");
        int lcs = lcsDP(a, a.length, b, b.length);
        System.out.println("最大公共子串 lcs :" + lcs);

        //3.单词错误纠正
        System.out.println("\n===== 单词错误纠正 =====");
        List<char[]> list = new LinkedList<>();
        list.add("hello".toCharArray());
        list.add("here".toCharArray());
        list.add("hex".toCharArray());
        list.add("her".toCharArray());
        list.add("hill".toCharArray());
        list.add("毛子".toCharArray());
        list.add("毛熊子".toCharArray());
        list.add("熊孩子".toCharArray());
        char[] input1 = "herro".toCharArray();
        System.out.println("输入 [" + new String(input1) + "] 被纠正为 [" + new String(errorCorrection(input1, list)) + "]");
        input1 = "h".toCharArray();
        System.out.println("输入 [" + new String(input1) + "] 被纠正为 [" + new String(errorCorrection(input1, list)) + "]");
        input1 = "子".toCharArray();
        System.out.println("输入 [" + new String(input1) + "] 被纠正为 [" + new String(errorCorrection(input1, list)) + "]");
        input1 = "熊".toCharArray();
        System.out.println("输入 [" + new String(input1) + "] 被纠正为 [" + new String(errorCorrection(input1, list)) + "]");
    }
}

 

 

 


输出

===== 莱文氏距离(差异度) =====
莱文氏距离 lws :2

===== 最大公共子串(相同度) =====
最大公共子串 lcs :4

===== 单词错误纠正 =====
错误纠正 最小差异度:1 , 最大相同度:4
输入 [herro] 被纠正为 [here]
错误纠正 最小差异度:2 , 最大相同度:1
输入 [h] 被纠正为 [hex]
错误纠正 最小差异度:1 , 最大相同度:1
输入 [子] 被纠正为 [毛子]
错误纠正 最小差异度:2 , 最大相同度:1
输入 [熊] 被纠正为 [毛熊子]

 

单词错误纠正功能 编辑距离 最大公共字串 两个字符串的相似度 差异度

标签:子串   虚拟   system   i++   bsp   纠正   input   dex   删掉   

原文地址:https://www.cnblogs.com/cyy12/p/12020154.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!