动态编程 - 字符串、子字符串和最低成本

Question

尊敬的计算机科学专家，

我有一个关于动态规划 (DP) 的问题。问题是我得到了一个字符的句子和一个包含句子子字符串列表及其成本的 cost_list，目标是找到最低成本。假设cost_list包含句子中的所有子串。

例如，假设我有以下参数，

句子 = "xxxyyzz"

cost_list = [["x", 1], ["xx", 3], ["y", 3], ["yy", 1], ["z", 2]]

所以句子可以是[xx][x][yy][z][z]，所以总成本是3 + 1 + 1 + 2 + 2 = 9

但我也可以以不同的方式选择句子中的子字符串，我们有 [x][x][x][yy][z][z]，这给了我们 1 + 1 + 1 + 1 + 2 + 2 = 8，成本最低。

问题是构造一个动态规划算法find_lowest_cost(sentence, cost_list)。

下面是我创建的这个问题的递归函数，我已经测试过了，它是正确的，

def find_lowest_cost(sentence, cost_list):
   if len(sentence) == 0:
       return 0
   else:
       result = []
       possible_substrings = []
       possible_costs = []
       for c in cost_list:
           current_substring = c[0]
           current_cost = c[1]

           if current_substring == sentence[0:len(current_substring)]:
               possible_substrings.append(current_substring)
               possible_costs.append(current_cost)

       for i in range(0, len(possible_substrings)):
           result.append(possible_costs[i] + find_lowest_cost(sentence[len(possible_substrings[i]):], cost_list))

       return min(result)


sentence = "xxxyyzz"
cost_list = [["x", 1], ["xx", 3], ["y", 3], ["yy", 1], ["z", 2]]
print(find_lowest_cost(sentence, cost_list))

我对如何将递归转换为动态编程 (DP) 感到困惑。

问题1：对于DP表，我的列是sentence的字符。我的行应该如何？我的想法是它不能是“x”、“xx”、“y”、“yy”和“z”的行，因为我们如何将“yy”与句子中的“y”进行比较？

问题2：假设行和列都算出来了，在当前单元格中，当前单元格应该建立在什么基础上？我的概念是单元格是建立在先前单元格的最低值之上的，例如单元格[row][col-1]、单元格[row-1][col] 和单元格[row-1][col-1]？

谢谢！

Answer 1

一旦您能够获得递归解决方案，然后尝试查找有多少变量正在发生变化。解析递归方法：

我们需要找到一个解决方案，例如，当字符串的长度为 1 时，最小成本是多少，然后是 2，以此类推...对于从 0 到第 k 个索引的子字符串会重复计算，所以我们需要存储所有计算的结果为单个 dp，以便我们可以给出已经计算的任何第 k 个索引的答案。 下面是我的 Java 解决方案。

import java.util.HashMap;
public class MyClass {
    private static Integer[] dp;
    public static void main(String args[]) {
        // cost_list = [["x", 1], ["xx", 3], ["y", 3], ["yy", 1], ["z", 2]]
        HashMap<String, Integer> costmp = new HashMap();
        costmp.put("x", 1);
        costmp.put("xx", 3);
        costmp.put("y", 3);
        costmp.put("yy", 1);
        costmp.put("z", 2);
        
        String sentence = "xxxyyzz";
        // String sentence = "xxyyzzxxxxyyyyxxxyxxyyyxxyyyzzzyyyxxxyyyyzzzyyyyxxxyyyzzzyyxxxxxxxxxxxxxxyyxyxyzzzzxxyyxx";
        // String sentence = "xxxyyzzxxxxyyyyxxxyxxyyyxxyyyzzzyyyxxxyyyyzzzy";
        dp = new Integer[sentence.length()+1];
        int res = find_lowest_cost(sentence, costmp, 0);
      System.out.println("find_lowest_cost = " + res);
    }


    private static int find_lowest_cost(String sentence, HashMap<String, Integer> costmp, int st)
    {
        if(st == sentence.length())
            return 0;
        int mincost = Integer.MAX_VALUE;
        if(dp[st] != null)
            return dp[st];
        String str = new String();
        for(int i = st;i < sentence.length(); i++)
        {
            str+=sentence.charAt(i);
            if(!costmp.containsKey(str))
                break;
            int cost = costmp.get(str);
            mincost = Math.min(mincost, cost+find_lowest_cost(sentence, costmp, i+1));
        }
        dp[st] = mincost;
        return mincost;
    }
}