Recursion 序列比对的递归代码方法

我正在寻找序列对齐问题的递归代码。经过一次搜索，我找到了Needleman-Wunsch算法，但是矩阵表的构建是通过两个for循环实现的，不同的是，我找不到任何在正常时间执行该操作的递归代码。有没有关于递归代码实现的想法？

---

谢谢

为什么需要递归算法

---

看起来序列比对问题可以通过动态规划来解决——Needleman-Wunsch算法就是这样做的。在维基百科页面（）中，有一个用于解决该问题的循环。这是一个递归解决方案。但是，此递归解决方案反复执行相同的子问题计算。动态规划解决方案通过自下而上解决问题，并通过两个for循环存储计算以备将来查找（记忆）。

为什么需要递归算法

看起来序列比对问题可以通过动态规划来解决——Needleman-Wunsch算法就是这样做的。在维基百科页面（）中，有一个用于解决该问题的循环。这是一个递归解决方案。但是，此递归解决方案反复执行相同的子问题计算。动态编程解决方案通过自下而上解决问题，并通过两个for循环存储计算以备将来查找（记忆）。

带缓存的递归实现 索引变得有点混乱，因为我在基于0的数组和 跳跃但很好，这与复发非常相似。 在二次alg中分配堆栈帧 然而，对于不支持尾部调用的VM来说，prob不是一个好主意吗 一个不是尾部递归的实现

运行时间：O（n*m）

迭代实现 （便于比较） 典型的DP风格。但要注意这些指数；他们可能很狡猾

public static int solve(String n, String m) {
  int nlen = n.length();
  int mlen = m.length();
  int[][] maxAlign = new int[nlen + 1][mlen + 1];

  for(int q = 0; q <= nlen; q++) 
    maxAlign[q][0] = q * gapPenalty;

  for(int r = 0; r <= mlen; r++) 
    maxAlign[0][r] = r * gapPenalty;

  for(int i = 1; i <= nlen; i++) {
    for(int j = 1; j <= mlen; j++) {
        int matchScore = (n.charAt(i-1) == m.charAt(j-1)) ? matchBenefit : mismatchPenalty;

        int leaveIt = maxAlign[i-1][j-1] + matchScore;
        int addGapN = maxAlign[i-1][j] + gapPenalty;
        int addGapM = maxAlign[i][j-1] + gapPenalty;

        maxAlign[i][j] = Math.max(leaveIt, Math.max(addGapN, addGapM));
    }
  }

  return maxAlign[nlen][mlen];
}

publicstaticintsolve（字符串n，字符串m）{
int nlen=n.长度（）；
int mlen=m.长度（）；
int[]maxallign=new int[nlen+1][mlen+1]；
对于（int q=0；q）带缓存的递归实现
索引变得有点混乱，因为我在基于0的数组和
当然了，但这和复发的情况非常相似。
在二次alg中分配堆栈帧
然而，对于不支持尾部调用的VM来说，prob不是一个好主意吗
一个不是尾部递归的实现

运行时间：O（n*m）

迭代实现
（便于比较）
典型的DP风格。不过要注意那些索引，它们可能很棘手

public static int solve(String n, String m) {
  int nlen = n.length();
  int mlen = m.length();
  int[][] maxAlign = new int[nlen + 1][mlen + 1];

  for(int q = 0; q <= nlen; q++) 
    maxAlign[q][0] = q * gapPenalty;

  for(int r = 0; r <= mlen; r++) 
    maxAlign[0][r] = r * gapPenalty;

  for(int i = 1; i <= nlen; i++) {
    for(int j = 1; j <= mlen; j++) {
        int matchScore = (n.charAt(i-1) == m.charAt(j-1)) ? matchBenefit : mismatchPenalty;

        int leaveIt = maxAlign[i-1][j-1] + matchScore;
        int addGapN = maxAlign[i-1][j] + gapPenalty;
        int addGapM = maxAlign[i][j-1] + gapPenalty;

        maxAlign[i][j] = Math.max(leaveIt, Math.max(addGapN, addGapM));
    }
  }

  return maxAlign[nlen][mlen];
}

publicstaticintsolve（字符串n，字符串m）{
int nlen=n.长度（）；
int mlen=m.长度（）；
int[]maxallign=new int[nlen+1][mlen+1]；
对于（int q=0；q），您需要编写代码。当您遇到stuckStack溢出时，我们会提供帮助，而不是要求人们提供解决问题的完整代码。不过，我们可以帮助您调试您拥有的代码。（请注意：我从未见过序列对齐的递归实现，因为迭代DP解决方案更节省空间、更快、更干净。）我不是在寻找完整的代码，我只是在寻找一个想法！你编写代码。当你遇到stuckStack溢出时，我们会提供帮助，而不是要求人们提供解决问题的完整代码。不过，我们可以帮助你调试你拥有的代码。（请注意：我从未见过序列对齐的递归实现，因为迭代DP解决方案更节省空间、更快、更干净。）我不是在寻找完整的代码，我只是在寻找一个想法！我很难理解needleman wunsch是如何像你所说的那样是一个递归解决方案。代码中没有递归调用，你能解释一下它是如何递归的吗？维基百科文章中给出的递归是F{I，j}=max（F{I-1，j-1}+S（a{I}，B{j}），F{I，j-1}+d，F{i-1，j}+d）这个递归解非常慢，因为它会一遍又一遍地重新计算相同的东西。这也是一种自上而下的方法。相反，他们会自下而上地计算所有的F{i，j}值（例如，从F{0,0}开始）通过for循环。如果您不熟悉动态编程，我建议您仔细阅读-。所有动态编程问题都是固有的递归问题。我很难理解needleman wunsch是如何像您所说的那样是递归解决方案。代码中没有递归调用，您能解释一下它是如何递归的吗？recurr维基百科文章中给出的结果是F{i，j}=max（F{i-1，j-1}+S（A{i}，B{j}），F{i，j-1}+d，F{i-1，j}+d），这种递归解决方案非常慢，因为它一遍又一遍地重复计算相同的事情。这也是一种自上而下的方法。相反，它们自下而上计算所有的F{i，j}值（例如，从F{0,0}开始）通过for循环。如果你不熟悉动态编程，我建议你读一下-。所有的动态编程问题本质上都是递归的。