DNA序列编辑距离 | 豆包MarsCode AI刷题

用户122386023121
34 阅读5分钟

问题描述

小R正在研究DNA序列，他需要一个函数来计算将一个受损DNA序列（dna1）转换成一个未受损序列（dna2）所需的最少编辑步骤。编辑步骤包括：增加一个碱基、删除一个碱基或替换一个碱基。

测试样例

样例1：

输入：dna1 = "AGT",dna2 = "AGCT"
输出：1

样例2：

输入：dna1 = "AACCGGTT",dna2 = "AACCTTGG"
输出：4

样例3：

输入：dna1 = "ACGT",dna2 = "TGC"
输出：3

样例4：

输入：dna1 = "A",dna2 = "T"
输出：1

样例5：

输入：dna1 = "GGGG",dna2 = "TTTT"
输出：4

好的，让我们来分析一下这个问题。

问题理解

你需要计算将一个DNA序列 dna1 转换成另一个DNA序列 dna2 所需的最少编辑步骤。编辑步骤包括：

  1. 增加一个碱基
  2. 删除一个碱基
  3. 替换一个碱基

数据结构选择

由于我们需要计算最小编辑距离，动态规划（Dynamic Programming, DP）是一个非常合适的选择。我们可以使用一个二维数组 dp 来存储中间结果。

算法步骤

  1. 初始化：

    • 创建一个 (len1+1) x (len2+1) 的二维数组 dp，其中 len1 和 len2 分别是 dna1 和 dna2 的长度。
    • dp[i][j] 表示将 dna1 的前 i 个字符转换成 dna2 的前 j 个字符所需的最小编辑距离。

  2. 边界条件：

    • 当 j = 0 时，dp[i][0] = i，即将 dna1 的前 i 个字符转换成空字符串需要 i 次删除操作。
    • 当 i = 0 时，dp[0][j] = j，即将空字符串转换成 dna2 的前 j 个字符需要 j 次增加操作。

  3. 状态转移：

    • 如果 dna1[i-1] == dna2[j-1]，则 dp[i][j] = dp[i-1][j-1]，即不需要任何编辑操作。
    • 否则，dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1，即选择删除、增加或替换操作中的最小值，并加上一次操作。

  4. 最终结果：

    • dp[len1][len2] 即为将 dna1 转换成 dna2 所需的最小编辑距离。

总结

通过动态规划，我们可以有效地计算出将一个DNA序列转换成另一个DNA序列所需的最小编辑距离。希望这些思路能帮助你更好地理解问题并编写代码。

# 动态规划

def solution(dna1, dna2):
    len1 = len(dna1)
    len2 = len(dna2)
    # dp: dna1的前i个修改为dna2个前j个的最短编辑距离 
    dp =[ [0 for _ in range(len2+1)] for _ in range(len1+1)]
    
    for i in range(len1+1):
        dp[i][0]=i
    for j in range(len2+1):
        dp[0][j]=j
    
    for i in range(1, len1+1):  
        for j in range(1, len2+1): 
            # 字符相同，不需要编辑
            if dna1[i - 1] == dna2[j - 1]:  
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1

    return dp[len1][len2]

if __name__ == "__main__":
    #  You can add more test cases here
    print(solution("AGCTTAGC", "AGCTAGCT") == 2 )
    print(solution("AGCCGAGC", "GCTAGCT") == 4)

这段代码实现了一个使用动态规划的方法来计算两个DNA序列之间的最短编辑距离（Levenshtein距离）。编辑距离是指将一个字符串转换成另一个字符串所需的最少操作次数，包括插入、删除和替换操作。以下是对代码的详细解释：

代码解释

  1. 初始化:

    len1 = len(dna1)
len2 = len(dna2)
dp = [[0 for _ in range(len2 + 1)] for _ in range(len1 + 1)]

    这里首先获取两个DNA序列的长度（len1 和 len2），并创建一个二维列表dp来存储中间结果。dp[i][j]表示将dna1的前i个字符转换为dna2的前j个字符所需的最小编辑距离。

  2. 边界条件:

    for i in range(len1 + 1):
    dp[i][0] = i
for j in range(len2 + 1):
    dp[0][j] = j
    • dp[i][0] = i 表示将dna1的前i个字符转换为空字符串需要的操作，就是删除i个字符。
    • dp[0][j] = j 表示将空字符串转换为dna2的前j个字符需要的操作，就是插入j个字符。

  3. 动态规划计算:

    for i in range(1, len1 + 1):
    for j in range(1, len2 + 1):
        if dna1[i - 1] == dna2[j - 1]:
            dp[i][j] = dp[i - 1][j - 1]
        else:
            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
    • 外层循环i表示dna1的字符位置，内层循环j表示dna2的字符位置。
    • 如果dna1[i-1]和dna2[j-1]相同，则不需要进行额外操作，直接使用dp[i-1][j-1]的值。
    • 如果不同，则需要考虑三种操作：
      • 插入一个字符（dp[i][j-1] + 1）
      • 删除一个字符（dp[i-1][j] + 1）
      • 替换一个字符（dp[i-1][j-1] + 1）
    • 选择这三种操作中代价最小的作为当前的dp[i][j]的值。

  4. 返回结果:

    return dp[len1][len2]

    函数返回dp[len1][len2]，即将整个dna1转换为dna2所需的最小编辑距离。

主程序部分

if __name__ == "__main__":
    print(solution("AGCTTAGC", "AGCTAGCT") == 2 )
    print(solution("AGCCGAGC", "GCTAGCT") == 4)
  • 在主程序中，调用solution()函数进行测试，输出两组测试用例的结果，检查计算的编辑距离是否正确。

总结

这个算法使用动态规划的方式有效地计算了两个DNA序列间的最短编辑距离，以便在生物信息学等领域进行比较和分析。

avatar
文章
阅读
粉丝