算法学习（十七）

学习内容：

动态规划算法：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。
在查找有很多重叠子问题的情况的最优解有效。动态规划保存子问题的解，避免重复计算。

学习产出：

字符串编辑

动态规划

解决动态规划问题的关键是找到状态转移方程，这样就可以通过计算和存储子问题的解来解决最终问题。

LeetCode72 编辑距离

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/edit-distance
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
         

题解

定义一个二维数组dp[i][j]，表示将第一个字符串到位置i为止，和第二个字符串到位置j为止最多需要几步编辑。当第i位和第j位对应字符相同，则dp[i][j]等于dp[i-1][j-1]；当二者对应的字符不同时，修改消耗dp[i-1][j-1]+1，插入i位置、删除j位置则是dp[i][j-1]+1，插入j位置、删除i位置则是p[i-1][j]+1

代码（python）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m,n = len(word1),len(word2)
        dp = [[0]*(n+1) for _ in range(m+1)]
        for i in range(m+1):
            for j in range(n+1):
                if i == 0:
                    dp[i][j] = j
                elif j == 0:
                    dp[i][j] = i
                else:
                    if word1[i-1] == word2[j-1]:
                        a = 0
                    else: a = 1
                    dp[i][j] = min(dp[i-1][j-1]+a,min(dp[i-1][j]+1,dp[i][j-1]+1))
        return dp[m][n]
        

LeetCode650 只有两个键的键盘

最初在一个记事本上只有一个字符 ‘A’。你每次可以对这个记事本进行两种操作：

Copy All (复制全部) : 你可以复制这个记事本中的所有字符(部分的复制是不允许的)。
Paste (粘贴) : 你可以粘贴你上一次复制的字符。
给定一个数字 n 。你需要使用最少的操作次数，在记事本中打印出恰好 n 个 ‘A’。输出能够打印出 n 个 ‘A’ 的最少操作次数。

示例 1:

输入: 3
输出: 3
解释:
最初, 我们只有一个字符 'A'。
第 1 步, 我们使用 Copy All 操作。
第 2 步, 我们使用 Paste 操作来获得 'AA'。
第 3 步, 我们使用 Paste 操作来获得 'AAA'。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/2-keys-keyboard
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    

题解

由于粘贴操作是倍数增加，因此需要乘除法计算位置，定义dp数组，其中位置i表示延展到长度i的最少操作次数。对于每个位置j，如果j可以被i整除，那么长度i就可以由j操作得到，其操作等价于把长度为1的A延展到长度为i/j。因此状态转移公式dp[i]=dp[j]+dp[i/j]

代码（python）

class Solution:
    def minSteps(self, n: int) -> int:
        dp = [0]*(n+1)
        h = int(n**0.5)
        for i in range(2,n+1):
            dp[i] = i
            for j in range(2,h+1):
                if i%j == 0:
                    dp[i] = dp[j] + dp[i//j]
                    break
        return dp[n]