青训营X豆包MarsCode 技术训练营：古生物DNA序列血缘分析Python3题解｜豆包MarsCode AI 刷题

古生物DNA序列血缘分析

问题描述

小U是一位古生物学家，正在研究不同物种之间的血缘关系。为了分析两种古生物的血缘远近，她需要比较它们的DNA序列。DNA由四种核苷酸A、C、G、T组成，并且可能通过三种方式发生变异：添加一个核苷酸、删除一个核苷酸或替换一个核苷酸。小U认为两条DNA序列之间的最小变异次数可以反映它们之间的血缘关系：变异次数越少，血缘关系越近。

你的任务是编写一个算法，帮助小U计算两条DNA序列之间所需的最小变异次数。

dna1: 第一条DNA序列。
dna2: 第二条DNA序列。

测试样例

样例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序列之间的最小变异次数。变异可以通过三种方式发生：添加一个核苷酸、删除一个核苷酸或替换一个核苷酸。这个问题可以转化为计算两个字符串之间的编辑距离（Edit Distance）。

数据结构的选择

我们可以使用动态规划（Dynamic Programming）来解决这个问题。动态规划的核心思想是将问题分解为子问题，并存储子问题的解以避免重复计算。

算法步骤

定义状态：
- 我们使用一个二维数组 dp，其中 dp[i][j] 表示 dna1 的前 i 个字符和 dna2 的前 j 个字符之间的最小变异次数。
初始化：
- dp[0][0] 应该是 0，因为两个空序列之间的变异次数为 0。
- dp[i][0] 应该是 i，因为将 dna1 的前 i 个字符变为空序列需要 i 次删除操作。
- dp[0][j] 应该是 j，因为将 dna2 的前 j 个字符变为空序列需要 j 次删除操作。
状态转移：
- 如果 dna1[i-1] == dna2[j-1]，那么 dp[i][j] = dp[i-1][j-1]，因为不需要变异。
- 否则，dp[i][j] 应该是以下三种情况的最小值：
  - dp[i-1][j] + 1：删除 dna1 的第 i 个字符。
  - dp[i][j-1] + 1：在 dna1 中插入 dna2 的第 j 个字符。
  - dp[i-1][j-1] + 1：替换 dna1 的第 i 个字符为 dna2 的第 j 个字符。
最终结果：
- dp[len(dna1)][len(dna2)] 就是 dna1 和 dna2 之间的最小变异次数。

Python3代码（通过豆包Marscode测试）

def solution(dna1, dna2):
    m, n = len(dna1), len(dna2)
    # 创建一个 (m+1) x (n+1) 的二维数组 dp
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    # 初始化 dp 数组
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
    
    # 填充 dp 数组
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if dna1[i - 1] == dna2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
    
    return dp[m][n]

if __name__ == "__main__":
    # 你可以添加更多测试用例
    print(solution("AGT", "AGCT") == 1)
    print(solution("", "ACGT") == 4)
    print(solution("GCTAGCAT", "ACGT") == 5)

时间复杂度

初始化：
- 初始化 dp 数组的时间复杂度是 O(m + n)，其中 m 和 n 分别是 dna1 和 dna2 的长度。
填充 dp 数组：
- 填充 dp 数组的时间复杂度是 O(m * n)，因为我们需要遍历 dp 数组中的每一个元素。

因此，总的时间复杂度是 O(m * n)。

空间复杂度

dp 数组：
- dp 数组的大小是 (m+1) x (n+1)，因此空间复杂度是 O(m * n)。

总结

时间复杂度：O(m * n)
空间复杂度：O(m * n)

优化空间复杂度

如果你希望进一步优化空间复杂度，可以考虑使用滚动数组（rolling array）技术。由于在计算 dp[i][j] 时，我们只需要 dp[i-1][j-1]、dp[i-1][j] 和 dp[i][j-1] 这三个值，因此我们可以只使用两行数组来存储这些值，从而将空间复杂度优化到 O(n)。

滚动数组技术是一种优化动态规划问题空间复杂度的方法。它的核心思想是利用数组的滚动特性，只保留当前和前一行的状态，从而减少空间的使用。

滚动数组技术的原理

在动态规划问题中，通常我们需要一个二维数组 dp 来存储状态。例如，在计算两个字符串的编辑距离时，dp[i][j] 表示 dna1 的前 i 个字符和 dna2 的前 j 个字符之间的最小变异次数。

如果我们仔细观察状态转移方程：

dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1

我们可以发现，计算 dp[i][j] 时，我们只需要 dp[i-1][j]、dp[i][j-1] 和 dp[i-1][j-1] 这三个值。这意味着我们并不需要整个二维数组 dp，而只需要当前行和前一行的状态。

如何实现滚动数组

定义状态：
- 我们只需要一个大小为 2 x (n+1) 的二维数组 dp，其中 dp[0] 和 dp[1] 分别表示当前行和前一行的状态。
初始化：
- 初始化 dp[0][j] 和 dp[1][j] 的边界条件。
状态转移：
- 在计算 dp[i][j] 时，我们只需要使用 dp[(i-1) % 2][j]、dp[i % 2][j-1] 和 dp[(i-1) % 2][j-1] 这三个值。
滚动更新：
- 在每一轮迭代中，我们通过 i % 2 来决定当前行和前一行的索引，从而实现滚动更新。

滚动数组技术优化后的代码（通过豆包Marscode 测试）

def solution(dna1, dna2):
    m, n = len(dna1), len(dna2)
    # 创建一个 2 x (n+1) 的二维数组 dp
    dp = [[0] * (n + 1) for _ in range(2)]
    
    # 初始化 dp 数组
    for j in range(n + 1):
        dp[0][j] = j
    
    # 填充 dp 数组
    for i in range(1, m + 1):
        dp[i % 2][0] = i
        for j in range(1, n + 1):
            if dna1[i - 1] == dna2[j - 1]:
                dp[i % 2][j] = dp[(i - 1) % 2][j - 1]
            else:
                dp[i % 2][j] = min(dp[(i - 1) % 2][j], dp[i % 2][j - 1], dp[(i - 1) % 2][j - 1]) + 1
    
    return dp[m % 2][n]

if __name__ == "__main__":
    # 你可以添加更多测试用例
    print(solution("AGT", "AGCT") == 1)
    print(solution("", "ACGT") == 4)
    print(solution("GCTAGCAT", "ACGT") == 5)

空间复杂度分析

原始空间复杂度：O(m * n)
优化后的空间复杂度：O(n)

通过使用滚动数组技术，我们将空间复杂度从 O(m * n) 降低到了 O(n)，其中 n 是 dna2 的长度。

优化后的复杂度

时间复杂度：O(m * n)
空间复杂度：O(n)

心得体会

动态规划的核心思想是将问题分解为子问题，并存储子问题的解以避免重复计算。滚动数组技术通过只保留当前行和前一行的状态，减少了空间的使用。这种技术在动态规划问题中非常有效，尤其是在状态转移方程只依赖于前一行或前几行状态的情况下。

青训营X豆包MarsCode 技术训练营：古生物DNA序列血缘分析Python3题解｜ 豆包MarsCode AI 刷题