什么是编辑距离
编辑距离是指将一个字符串转化为另外一个字符串，需要的最少的编辑操作次数，这些操作包括增加、删除或者替换某个字符。可以看出，编辑距离越大，说明两个字符串的相似度越小；相反，编辑距离越小，说明这两个字符串的相似程度越大。两个字符串的编辑距离为0则说明这两个字符串相同。
计算编辑距离的方法
编辑距离的计算方式比较多，比较著名的有莱文斯坦距离（Levenshten distance）和最长公共子串长度（Longest common substring length）。
- 莱文斯坦距离允许的操作：增加、删除、替换字符三种编辑操作。表示的是两个字符串差异度大小。
- 最长公共子串长度的操作：只允许增加、删除字符这两个编辑操作。表示的是两个字符串相似度大小。
比如：字符串mitcmu和mtacnu的莱文斯坦距离是3，最长公共子串长度是4.
如何计算莱文斯坦距离
莱文斯坦距离就是找出两个字符串之间的差异度，即最小的编辑次数。
回溯思想计算莱文斯坦距离
这个问题其实可以使用回溯来解决，看你能否想到，思路如下：
依次考察一个字符串中的每个字符，跟另一个字符串中的字符是否匹配，比如a[i]和b[j]如果匹配，则继续考察a[i+1]和b[j+1].但如果a[i]和b[j]不匹配呢？如果不匹配，则有以下几种方式来处理：
- 可以删除a[i]，然后递归考察a[i+1]和b[i]
- 可以删除b[j],然后递归考察a[i]和b[j+1]
- 可以在a[i]前边添加一个跟b[j]相同的字符，然后递归考察a[i]和b[j+1]
- 可以在b[j]前边添加一个跟a[i]相同的字符，然后递归考察a[i+1]和b[j];
- 可以将a[i]替换成b[j]或者将b[j]替换成a[j],然后递归考察a[i+1]和b[j+1]
其实回溯计算的过程如果没有重复子问题则直接就用回溯就可以了，但是如果有较多的重复子问题动态规划则是更高效的方式。
DP思想计算莱文斯坦距离
DP思想解决问题的关键其实找到状态转移方式，而莱文斯坦距离的DP状态转移方式其实有三种，比如对于长度分别是n和m的字符数组a和b来说:
如果：a[i]!=b[j]，那么：min_edist(i, j) 就等于：
min(min_edist(i-1,j)+1, min_edist(i,j-1)+1, min_edist(i-1,j-1)+1)
如果：a[i]==b[j]，那么：min_edist(i, j) 就等于：
min(min_edist(i-1,j)+1, min_edist(i,j-1)+1，min_edist(i-1,j-1))
其中，min_edit(i,j)表示考察到a[i]和b[j]时经过的最小的编辑距离；min 表示求三数中的最小值。
试着理解下:
无论是min_edist(i-1,j)还是min_edist(i,j-1)，下一个状态如果是min_edist(i,j)必定是其中一个且仅是一个字符串往后移动了一个下标到达的min_edist(i,j)。这说明发生了编辑，编辑距离加一了。
当a[i]!=b[j]时, min_edist(i-1,j-1)需要加1容易理解因为a[i]和b[j]不等需要编辑。
当a[i]==b[j]时，min_edist(i-1,j-1)不需要加1，因为字符a[i]和b[j]相等不需要编辑。
这里有点难理解：
min_edist(i,j-1)或者min_edist(i-1,j)转移到min_edist(i,j)应该加1，因为min_edist(i,j-1)或者min_edist(i-1,j)表示的是编辑距离，而编辑距离表示的是达到次数x时两个字符串相等。既然相等就肯定同时往后移动下标，所以不能简单理解为编辑距离，而应该思考min_edist(i-1,j)和min_edist(i,j)之间的状态转移关系。
minDist[i-1][j]或minDist[i][j-1]到minDist[i][j]的转移，就是在字符串中增加了一个字符
比如hello和hllo，当i指向e，j指向l的时候，往hllo中加入字符e成为hello，那么此时j-1就是e，
j是l，就相当于是minDist[i][j-1]到minDist[i][j]的转移.
于是he和hel的编辑距离minDist[i][j]为minDist[i][j-1]+1
动态规划计算公共子串长度
思路：
如果 a[i] 与 b[j] 互相匹配，我们将最大公共子串长长度加一，并且继续考察 a[i+1] 和 b[j+1]
如果 a[i] 与 b[j] 不匹配，最长公共子串长度不变，此时如下两种处理方式：
- 删除 a[i]，或者在 b[j] 前面加上一个字符 a[i].继续考察a[i+1]和b[j]
- 删除 b[j]，或者在 a[i] 前面加上一个字符 b[j].继续考察a[i]和b[j+1]
状态转移公式：
如果：a[i]==b[j]，那么：max_lcs(i, j) 就等于： max(max_lcs(i-1,j-1)+1, max_lcs(i-1, j), max_lcs(i, j-1))；
如果：a[i]!=b[j]，那么：max_lcs(i, j) 就等于： max(max_lcs(i-1,j-1), max_lcs(i-1, j), max_lcs(i, j-1))；
其中 max 表示求三数中的最大值。
代码实现
package com.study.algorithm.dp;
/**
* @Auther: JeffSheng
* @Date: 2019/10/21 16:02
* @Description: 编辑距离的实现
*
*/
public class EditDistance {
private char[] a = "mitcmu".toCharArray();
private char[] b = "mtacnu".toCharArray();
private int n = 6;
private int m = 6;
/**
* 存储结果
*/
private int minDist = Integer.MAX_VALUE;
/**
* 回溯思想实现编辑距离
* 调用方式 lwstBT(0, 0, 0);
* @return
*/
public void lwstBT(int i, int j, int edist) {
if (i == n || j == m) {
if (i < n){
edist += (n-i);
}
if (j < m) {
edist += (m - j);
}
if (edist < minDist) {
minDist = edist;
}
return;
}
// 两个字符匹配
if (a[i] == b[j]) {
lwstBT(i+1, j+1, edist);
} else { // 两个字符不匹配
// 删除 a[i] 或者 b[j] 前添加一个字符
lwstBT(i + 1, j, edist + 1);
// 删除 b[j] 或者 a[i] 前添加一个字符
lwstBT(i, j + 1, edist + 1);
// 将 a[i] 和 b[j] 替换为相同字符
lwstBT(i + 1, j + 1, edist + 1);
}
}
/**
* 动态规划思想解决编辑距离问题
* 即由前一个状态决定后一个状态
* @param a 字符数组a
* @param n a的长度n
* @param b 字符数组b
* @param m b的长度m
* @return
*/
public int lwstDP(char[] a, int n, char[] b, int m) {
int[][] minDist = new int[n][m];
// 初始化第 0 行:a[0..0] 与 b[0..j] 的编辑距离
for (int j = 0; j < m; ++j) {
if (a[0] == b[j]){
minDist[0][j] = j;
}else if (j != 0){
minDist[0][j] = minDist[0][j-1]+1;
}else{
minDist[0][j] = 1;
}
}
// 初始化第 0 列:a[0..i] 与 b[0..0] 的编辑距离
for (int i = 0; i < n; ++i) {
if (a[i] == b[0]){
minDist[i][0] = i;
}
else if (i != 0) {
minDist[i][0] = minDist[i-1][0]+1;
}
else{
minDist[i][0] = 1;
}
}
// 按行填表
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
if (a[i] == b[j]){
minDist[i][j] = min(
minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]);
}else {
minDist[i][j] = min(
minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]+1);
}
}
}
return minDist[n-1][m-1];
}
private int min(int x, int y, int z) {
int minv = Integer.MAX_VALUE;
if (x < minv){
minv = x;
}
if (y < minv){
minv = y;
}
if (z < minv){
minv = z;
}
return minv;
}
/**
* 动态规划思想+最长公共子串长度法来计算编辑距离
* @param a
* @param n
* @param b
* @param m
* @return
*/
public int lcs(char[] a, int n, char[] b, int m) {
int[][] maxlcs = new int[n][m];
// 初始化第 0 行：a[0..0] 与 b[0..j] 的 maxlcs
for (int j = 0; j < m; ++j) {
if (a[0] == b[j]){
maxlcs[0][j] = 1;
}else if (j != 0) {
maxlcs[0][j] = maxlcs[0][j-1];
}else{
maxlcs[0][j] = 0;
}
}
// 初始化第 0 列：a[0..i] 与 b[0..0] 的 maxlcs
for (int i = 0; i < n; ++i) {
if (a[i] == b[0]){
maxlcs[i][0] = 1;
}else if (i != 0) {
maxlcs[i][0] = maxlcs[i-1][0];
}else{
maxlcs[i][0] = 0;
}
}
// 填表
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
if (a[i] == b[j]){
/**
* 比如maxlcs[i-1][j]肯定是a[i-1]和b[j]不匹配，否则就是maxlcs[i][j+1]了，
* 所以说maxlcs[i-1][j], maxlcs[i][j-1]都不需要给公共长度加1，只有maxlcs[i-1][j-1]的a[i-1]和b[j-1]是相等的，i和j都同时加1
*/
maxlcs[i][j] = max(
maxlcs[i-1][j], maxlcs[i][j-1], maxlcs[i-1][j-1]+1);
}
else{
//a[i]和b[j]既然不等，那么直接取前一个状态的最大值即可表示公共长度
maxlcs[i][j] = max(
maxlcs[i-1][j], maxlcs[i][j-1], maxlcs[i-1][j-1]);
}
}
}
return maxlcs[n-1][m-1];
}
private int max(int x, int y, int z) {
int maxv = Integer.MIN_VALUE;
if (x > maxv){
maxv = x;
}
if (y > maxv){
maxv = y;
}
if (z > maxv){
maxv = z;
}
return maxv;
}
public static void main(String[] args) {
EditDistance ed = new EditDistance();
ed.lwstBT(0, 0, 0);
System.out.println(ed.minDist);
}
}