LeetCode //C - 1143. Longest Common Subsequence

1143. Longest Common Subsequence

Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

• For example, “ace” is a subsequence of “abcde”.

A common subsequence of two strings is a subsequence that is common to both strings.
 

Example 1:

Input: text1 = “abcde”, text2 = “ace”
Output: 3
Explanation: The longest common subsequence is “ace” and its length is 3.

Example 2:

Input: text1 = “abc”, text2 = “abc”
Output: 3
Explanation: Explanation: The longest common subsequence is “abc” and its length is 3.

Example 3:

Input: text1 = “abc”, text2 = “def”
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints:

• 1 <= text1.length, text2.length <= 1000
• text1 and text2 consist of only lowercase English characters.

From: LeetCode
Link: 1143. Longest Common Subsequence

---

Solution:

Ideas：

This function first calculates the lengths of the two input strings. It then initializes a 2D array dp where dp[i][j] represents the length of the longest common subsequence between the first i characters of text1 and the first j characters of text2.

The first row and first column of dp are initialized to 0, representing the cases where one of the strings is empty. The function then fills the dp table by comparing characters from text1 and text2. If the current characters match, the function takes the value from the previous characters in both strings (diagonal in the dp table) and adds one. If the characters do not match, it takes the maximum value from either the left or the top cell, representing not including the current character from either text1 or text2.

Finally, the function returns the value in dp[len1][len2], which represents the length of the longest common subsequence between the entire text1 and text2.

Caode:

int longestCommonSubsequence(char* text1, char* text2) {
    int len1 = strlen(text1);
    int len2 = strlen(text2);
    int dp[len1 + 1][len2 + 1];
    
    // Initialize the first row and first column to 0
    for (int i = 0; i <= len1; i++) {
        dp[i][0] = 0;
    }
    for (int j = 0; j <= len2; j++) {
        dp[0][j] = 0;
    }
    
    // Fill the dp table
    for (int i = 1; i <= len1; i++) {
        for (int j = 1; j <= len2; j++) {
            if (text1[i - 1] == text2[j - 1]) {
                // Characters match, take the value from the diagonal + 1
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                // Characters do not match, take the max from left or above
                dp[i][j] = dp[i - 1][j] > dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
            }
        }
    }
    
    return dp[len1][len2];
}