Python Tutorial

A subsequence is a sequence that can be created by removing part or all of the items from another sequence while maintaining the order of the remaining components. The longest subsequence that appears in all of them is the longest common subsequence of two or more strings.

Here is a Python implementation of finding the longest common subsequence among two given strings using dynamic programming:

def lcs(str1, str2):
    m = len(str1)
    n = len(str2)
    # initialize the table with 0's
lcs_table = [[0]*(n+1) for i in range(m+1)]

    # fill the table using dynamic programming
    for i in range(1, m+1):
        for j in range(1, n+1):
            if str1[i-1] == str2[j-1]:
lcs_table[i][j] = lcs_table[i-1][j-1] + 1
            else:
lcs_table[i][j] = max(lcs_table[i][j-1], lcs_table[i-1][j])

    # find the longest common subsequence by backtracking the table
    lcs = ""
i = m
    j = n
    while i> 0 and j > 0:
        if str1[i-1] == str2[j-1]:
            lcs = str1[i-1] + lcs
i -= 1
            j -= 1
eliflcs_table[i-1][j] >lcs_table[i][j-1]:
i -= 1
        else:
            j -= 1
    return lcs
def lcs_multiple(str_list):
    if len(str_list) == 0:
        return ""
eliflen(str_list) == 1:
        return str_list[0]
    else:
lcs_result = lcs(str_list[0], str_list[1])
        for i in range(2, len(str_list)):
lcs_result = lcs(lcs_result, str_list[i])
        return lcs_result
# Example usage
str_list = ["ABCD", "ACDF", "ACDE", "ACEF"]
print(lcs_multiple(str_list)) 

Output:

AC

Explanation:

The lcs function computes the longest common subsequence between two strings of length m and n, respectively. It uses a dynamic programming approach to fill a table of size (m+1) x (n+1). As a result, this function has an O(mn) time complexity and an O(mn) space complexity.

The lcs_multiple function computes the longest common subsequence among multiple strings. It does this by repeatedly calling the lcs function on pairs of strings, and then updating the result with the new longest common subsequence. For k strings, this function requires k-1 calls to the lcs function, each with a pair of strings of length m and n. As a result, this function has an O((k-1)mn) time complexity and an O(m*n) space complexity.

Overall, the time complexity of the algorithm is dominated by the lcs_multiple function, which is O((k-1)mn). However, in practice, the actual time complexity will depend on the specific strings being compared and the size of their longest common subsequence. Large strings may be problematic due to the algorithm's O(m*n) space complexity.

Using Divide and Conquer Algorithm

Another approach is the divide-and-conquer algorithm, which is a recursive algorithm that divides the set of input strings into smaller subsets and computes the longest common subsequence of each subset.

Divide the set of input strings into two subsets.
Recursively compute the longest common subsequence of each subset.
Merge the two longest common subsequences to obtain the longest common subsequence of the entire set.

Code:

def lcs(str1, str2):
    m = len(str1)
    n = len(str2)
    # initialize the table with 0's
lcs_table = [[0]*(n+1) for i in range(m+1)]

    # fill the table using dynamic programming
    for i in range(1, m+1):
        for j in range(1, n+1):
            if str1[i-1] == str2[j-1]:
lcs_table[i][j] = lcs_table[i-1][j-1] + 1
            else:
lcs_table[i][j] = max(lcs_table[i][j-1], lcs_table[i-1][j])

    # find the longest common subsequence by backtracking the table
    lcs = ""
i = m
    j = n
    while i> 0 and j > 0:
        if str1[i-1] == str2[j-1]:
            lcs = str1[i-1] + lcs
i -= 1
            j -= 1
eliflcs_table[i-1][j] >lcs_table[i][j-1]:
i -= 1
        else:
            j -= 1

    return lcs

def lcs_multiple(str_list):
    if len(str_list) == 0:
        return ""
eliflen(str_list) == 1:
        return str_list[0]
eliflen(str_list) == 2:
        return lcs(str_list[0], str_list[1])
    else:
        mid = len(str_list) // 2
left_lcs = lcs_multiple(str_list[:mid])
right_lcs = lcs_multiple(str_list[mid:])
        return lcs(left_lcs, right_lcs)

# Example usage
str_list = ["ABCD", "ACDF", "ACDE", "ACEF"]
print(lcs_multiple(str_list)) 

Output:

AC

Explanation:

The lcs_multiple function first checks if there are 0 or 1 strings in the input list and returns an empty string or the single string if that is the case. If there are two strings in the list, it simply computes their longest common subsequence using the lcs function. If there are more than two strings, it divides the list into two halves, recursively computes the longest common subsequence of each half, and then merges the two longest common subsequences to obtain the longest common subsequence of the entire set.

The time complexity of the divide-and-conquer algorithm is O(k * n * log k), where k is the number of input strings and n is the length of the longest input string. The space complexity of the algorithm is also O(k * n * log k).

Next TopicParenthesized Context Managers Python

← prev next →