如何通过Levenshtein算法使用动态编程（Javascript）

我试图通过Levenshtein算法来理解动态规划，但我已经在这方面停留了几个小时了。我知道我对以下问题的尝试是“暴力”问题。我将如何使用“动态规划”来改变我的方法？我迷路了

问题：给定长度为n和m的两个字符串s和t，创建一个 函数，该函数返回以下字符串之一：“insert C”if 字符串t可以通过插入字符C“delete C”从s中获得 （与上述逻辑相同）如果字符串t可以从 通过交换显示在中的两个相邻字符（c和d）来设置字符串 原始字符串中的顺序。如果未执行任何操作，则为“无” 如果上述任何一项都不起作用，则需要“不可能”，即LevenShtein距离大于1

这是我的暴力企图。“tuple”变量的名称有误，因为我最初想将索引和值推送到矩阵中，但却被卡住了

function levenshtein(str1, str2) {
  var m = str1.length,
    n = str2.length,
    d = [],
    i, j,
    vals = [],
    vals2 = [];


  for (i = 0; i <= m ; i++) {

    var tuple = [str1[i]];
    //console.log(tuple);
    // console.log(tuple);
    d[i] = [i];
    // console.log(str1[i]);
    vals.push(tuple);

  }
    vals = [].concat.apply([], vals);
    vals = vals.filter(function(n){ return n; });
    console.log(vals);

  for (j = 0; j <= n; j++) {
    d[0][j] = j;
    var tuple2 = [str2[j]];
    // console.log(tuple2);
    vals2.push(tuple2);
    // console.log(vals2);
  }


  vals2 = [].concat.apply([], vals2);
    vals2 = vals2.filter(function(n){ return n ;});
    console.log(vals2);
  for (j = 1; j <= n; j++) {
    for (i = 1; i <= m; i++) {
      if (str1[i - 1] == str2[j - 1]) d[i][j] = d[i - 1][j - 1];
      else d[i][j] = Math.min(d[i - 1][j], d[i][j - 1], d[i - 1][j - 1]) + 1;
    }
  }
  var val = d[m][n];

  // console.log(d);
  if(val > 1){
    return "IMPOSSIBLE";
  }
  if(val === 0){
    return "NOTHING";
  }
  //console.log(d);
  if(val === 1){
    //find the missing element between the vals

        //return "INSERT " + missing element
    //find the extra element
        //return "DELETE + " extra element

    //find the out of place element and swap with another
  }

}

console.log(levenshtein("kitten", "mitten"));
// console.log(levenshtein("stop", "tops"));

// console.log(levenshtein("blahblah", "blahblah"));

函数levenshtein（str1、str2）{
var m=str1.1长度，
n=str2.1长度，
d=[]，
i、 j，
VAL=[]，
vals2=[]；
对于（i=0；i所述问题，无法使用动态规划进行优化，因为它只涉及一个决策，而不是一系列决策

请注意，问题明确指出，您应该返回“不可能”当Levenshtein距离大于1时，即不能通过单个操作使字符串相等。如果要应用动态规划，您需要搜索一系列零或多个操作，这些操作累积产生最优解。（这就是当它说您需要“最优子结构”时所说的。）动态规划的“重叠子问题”也适用。）

如果将问题更改为计算两个字符串之间的完整编辑距离，则可以使用动态规划进行优化，因为可以重用选择在字符串中的特定位置执行某些操作的结果，以降低搜索的复杂性


对于给定的问题，您当前的解决方案看起来有点过于复杂。下面是一个简单的方法，您可以学习。此解决方案利用了这样一个事实，即您知道您最多只能执行一个操作，并且您可以根据两个字符串长度之间的差异推断要尝试的操作。我们还知道，它只会es sense在两个字符串不同的点尝试给定的操作，而不是在每个位置


功能级别（s、t）{
//字符串是相等的
如果（s==t）返回“nothing”
//查找字符串长度的差异
var delta=s.length-t.length
//将字符串分解为数组
var arrS=s.split（“”）
var arrT=t.split（“”）
//尝试交换
如果（增量==0）{
对于（var i=0；i