动态规划——编辑距离问题

假设有a，b两个字符串，现对a字符串进行修改使得a字符串与b字符串完全一样；要求是使用最小的操作次数，使a，b字符串相等。操作有三种，分别是插入一个字符，删除一个字符，替换一个字符。

假设：
a字符串内容为horse
b字符串内容为rose

解题思路
枚举a字符串的所有子串转换到b字符串的所有子串的编辑情况

a:[ h o r s e ]
    ↑
    i

b:[ r o s e ]
    ↑
    j

目测将horse 编程rose需要2次操作
将h替换成r，将第二个r删掉。

该题的重复子过程如下：
a:horse – > b:rose

转换	操作次数	步骤
a:h -> b:r	1次操作	将h替换成r
a:h -> b:ro	2次操作	将h替换成r，插入o
a:h -> b:ros	3次操作	将h替换成r，插入o，插入s
a:h -> b:rose	4次操作	将h替换成r，插入o，插入s，插入e

转换	操作次数	步骤
a:ho -> b:r	2次操作	将h替换成r，将o删除
a:ho -> b:ro	1次操作	将h替换成r
a:ho -> b:ros	2次操作	将h替换成r，插入s
a:ho -> b:rose	3次操作	将h替换成r，插入s，插入e

转换	操作次数	步骤
a:hor -> b:r	2次操作	删除h，删除o
a:hor -> b:ro	2次操作	将h替换成r，将第二个r删除
a:hor -> b:ros	2次操作	将h替换成r，将第二个r替换成s
a:hor -> b:rose	3次操作	将h替换成r，将第二个r替换成s，插入e

转换	操作次数	步骤
a:hors -> b:r	3次操作	删除h，删除o，删除s
a:hors -> b:ro	3次操作	将h替换成r，将第二个r删除，删除s
a:hors -> b:ros	2次操作	将h替换成r，将第二个r删除
a:hors -> b:rose	3次操作	将h替换成r，将第二个r删除，插入e

转换	操作次数	步骤
a:horse -> b:r	4次操作	删除h，删除o，删除s，删除e
a:horse -> b:ro	4次操作	将h替换成r，将第二个r删除，删除s，删除e
a:horse -> b:ros	3次操作	将h替换成r，将第二个r删除，删除e
a:horse -> b:rose	2次操作	将h替换成r，将第二个r删除

从a字符串视角，每一组操作，都可以在前一个字符的基础上去删除，插入，替换。
即：
对horse的决策可以从对hors的决策推断出
对hors的决策可以从对hor的决策推断出
对hor的决策可以从ho的决策推断出
对ho的决策可以从对h的决策推断出
对h的决策可以从对空集的决策推断出

这明显的包含了重复的子过程，有重复的子过程，动态规划走起

将表格转换成另一种形式

	‘’	r	o	s	e
‘’	0	1	2	3	4
h	1	1	2	3	4
o	2	2	1	2	3
r	3	2	2	2	3
s	4	3	3	2	3
e	5	4	4	3	2

可见horse -> rose的转换操作，最少次数为2
e->e（无需转换）
s->s（无需转换）
hor->ro（需要转换2次，是从ho->o状态流转过来的）
ho->o（需要转换1次）
h->r（需要转换1次）
所以总共需要转换2次

换一种理解方式
有两个字符串：a，b
若这两个字符串最后一个字符已经相同，则将a转换到b，只需要考虑a去掉最后一个字符，和b去掉最后一个字符这两个字符串。

a:[   |x]
b:[      |x]

如果 a[i-1] 与 b[j-1] 的值相等 
    只需要考虑编辑a[i-1]，b[j-1]之前的字符即可 

若a，b字符串最后一个字符不同

a:[   |x]
b:[      |y]

则有三种情况

1. a删除最后一个字符后的字符串与b高度重合
2. a向末尾插入一个字符后的字符串与b高度重合
3. a替换最后一个字符后的字符串与b高度重合

如果 a[i-1] 与 b[j-1] 的值相等 
    只需要考虑编辑a[i-1]，b[j-1]之前的字符即可 
否则 (潜台词 a[i-1] 与 b[j-1] 的值不相等 )
    考虑删除a的一个字符
    考虑向a的末尾插入一个字符
    考虑替换a末尾的字符    

假设我们有一张二维表，已经缓存过horse 到 rose 转换的部分步骤信息，即可根据以往的信息，推测出下一步的转换计划，此题考查最少的转换步骤，代码如下：

package main

import (
	"fmt"
)

func main() {
	a := "horse"
	b := "rose"
	//fmt.Scan(&a)
	//fmt.Scan(&b)
	dp := make([][]int, len(a)+1)
	for i := 0; i < len(a)+1; i++ {
		dp[i] = make([]int, len(b)+1)
	}
	for i := 0; i < len(a)+1; i++ {
		dp[i][0] = i
	}
	for j := 0; j < len(b)+1; j++ {
		dp[0][j] = j
	}

	for i := 1; i <= len(a); i++ {
		for j := 1; j <= len(b); j++ {
			if a[i-1] == b[j-1] {
				dp[i][j] = dp[i-1][j-1]
			} else {
				dp[i][j] = min3(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
			}
		}
	}
	fmt.Println(dp[len(a)][len(b)])
}

func min3(a, b, c int) int {
	return min(min(a, b), c)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}