[Algorithms] Longest Common Substring

最新推荐文章于 2021-02-26 15:01:59 发布

转载最新推荐文章于 2021-02-26 15:01:59 发布 · 63 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jcliBlogger/p/4574263.html

本文介绍了一种利用动态规划求解两字符串最长公共子串的经典算法，并提供了两种实现方式：一种为时间复杂度O(m*n)，空间复杂度O(m*n)的原始实现；另一种为优化后的时间复杂度O(m*n)，空间复杂度O(min(m,n))的高效实现。

The Longest Common Substring (LCS) problem is as follows:

Given two strings s and t, find the length of the longest string r, which is a substring of both s and t.

This problem is a classic application of Dynamic Programming. Let's define the sub-problem (state) P[i][j] to be the length of the longest substring ends at i of s and j of t. Then the state equations are

P[i][j] = 0 if s[i] != t[j];
P[i][j] = P[i - 1][j - 1] + 1 if s[i] == t[j].

This algorithm gives the length of the longest common substring. If we want the substring itself, we simply find the largest P[i][j] and return s.substr(i - P[i][j] + 1, P[i][j]) or t.substr(j - P[i][j] + 1, P[i][j]).

Then we have the following code.

 1 string longestCommonSubstring(string s, string t) {
 2     int m = s.length(), n = t.length();
 3     vector<vector<int> > dp(m, vector<int> (n, 0));
 4     int start = 0, len = 0;
 5     for (int i = 0; i < m; i++) {
 6         for (int j = 0; j < n; j++) {
 7             if (i == 0 || j == 0) dp[i][j] = (s[i] == t[j]);
 8             else dp[i][j] = (s[i] == t[j] ? dp[i - 1][j - 1] + 1: 0);
 9             if (dp[i][j] > len) {
10                 len = dp[i][j];
11                 start = i - len + 1;
12             }
13         }
14     }
15     return s.substr(start, len);
16 }

The above code costs O(m*n) time complexity and O(m*n) space complexity. In fact, it can be optimized to O(min(m, n)) space complexity. The observations is that each time we update dp[i][j], we only need dp[i - 1][j - 1], which is simply the value of the above grid before updates.

Now we will have the following code.

 1 string longestCommonSubstringSpaceEfficient(string s, string t) {
 2     int m = s.length(), n = t.length();
 3     vector<int> cur(m, 0);
 4     int start = 0, len = 0, pre = 0;
 5     for (int j = 0; j < n; j++) {
 6         for (int i = 0; i < m; i++) {
 7             int temp = cur[i];
 8             cur[i] = (s[i] == t[j] ? pre + 1 : 0);
 9             if (cur[i] > len) {
10                 len = cur[i];
11                 start = i - len + 1;
12             }
13             pre = temp;
14         }
15     }
16     return s.substr(start, len);
17 }

In fact, the code above is of O(m) space complexity. You may choose the small size for cur and repeat the same code using if..else.. to save more spaces :)

转载于:https://www.cnblogs.com/jcliBlogger/p/4574263.html