满足给定条件的最长子序列

在编程中，我们经常需要找到满足一定条件的最长子序列。这些问题通常可以用动态规划解决。

最长递增子序列

在一个整数序列中，找到一个子序列，使得这个子序列是递增的，并且长度最长。这个问题被称为最长递增子序列问题。

动态规划解法

可以使用动态规划来解决最长递增子序列问题。假设有一个长度为n的序列a，dp[i]表示以a[i]结尾的最长递增子序列的长度。则可以得到状态转移方程：dp[i] = max(dp[j] + 1)，其中j<i且a[j]<a[i]。

然后，可为每个位置i计算dp[i]的值，最终dp数组中的最大值即为结果。

def longest_increasing_subsequence(a):
    n = len(a)
    dp = [1]*n
    for i in range(n):
        for j in range(i):
            if a[j] < a[i]:
                dp[i] = max(dp[i], dp[j]+1)
    return max(dp)

时间复杂度

动态规划算法的时间复杂度是O(n^2)。

最长公共子序列

最长公共子序列问题是找到两个序列中共同的最长的子序列。可以通过动态规划来解决最长公共子序列问题。

动态规划解法

假设有两个长度分别为n和m的序列a和b，L[i][j]表示a[:i]和b[:j]的最长公共子序列长度。则可得到状态转移方程：

• 如果a[i-1]==b[j-1]，则L[i][j] = L[i-1][j-1]+1
• 如果a[i-1]!=b[j-1]，则L[i][j] = max(L[i-1][j], L[i][j-1])

然后，就可以为每个位置i和j计算L[i][j]的值。最终L[n][m]即为结果。

def longest_common_subsequence(a, b):
    n = len(a)
    m = len(b)
    L = [[0]*(m+1) for i in range(n+1)]
    for i in range(1, n+1):
        for j in range(1, m+1):
            if a[i-1] == b[j-1]:
                L[i][j] = L[i-1][j-1] + 1
            else:
                L[i][j] = max(L[i-1][j], L[i][j-1])
    return L[n][m]

时间复杂度

动态规划算法的时间复杂度是O(nm)。

结论

最长递增子序列问题和最长公共子序列问题都可以使用动态规划算法来解决。这些算法的时间复杂度都比较高，但却可以处理大规模的数据。