当仅使用 2 * min（m， n） 个条目和 o（1） 个额外空间计算 LCS（最长公共子序列）的长度时，我们可以使用滚动数组技术。 此方法的核心思想是仅使用上一行的数据填充 dp 表，因为当前行中的数据仅依赖于上一行中的数据。 这样我们就可以避免存储整个二维数组而只存储一行。
首先，我们创建一个长度为 n + 1 的数组 dp，其中 dp[j] 表示 str1 的前 i 个字符和 str2 的前 j 个字符的 LCS 长度。 由于我们只需要上一行的数据，因此我们可以在计算新行时覆盖旧行的数据。
下面是使用 go 的实现示例：
package main import ( "fmt"） func lcslength（str1， str2 string） int padding dp table for i ：= 1; i <= m;i++ else prev = curr } 返回 lcs 返回 dp[n] }func max（a， b int） int return b } func main（） 的长度。下面是使用 go 的实现示例：
package main import ( "fmt"） func lcslength（str1， str2 string） int 交替更新 i 的 dp 表 ：= 1 使用两个数组交替更新; i <= m;i++ else prev = curr } swap array dp1， dp2 = dp2， dp1 } else return b}func lcslength（x， y int） int c ：= make（int， n+1） for i ：= 0; i <= m; i++ else if x[i-1] == y[j-1] else }return c[n]}func main() y := int fmt.println("length of lcs is", lcslength(x, y))}
在此处插入说明。
在此处插入说明。
我们可以修改前面的 memo 方法，仅使用 2min（m， n） 个条目和 o（1） 个额外的空格。 让我们从创建一个二维数组 c 开始，其中 c[i][j] 存储 x[0....i] 和 y[0....J]. 然后，我们使用两个指针 i 和 j 在 x 和 y 中移动，计算每个 c[i][j] 的值。 移动指针时，我们只需要保留上一行和当前行的条目，这样我们就可以使用 2min（m， n） 个条目。
以下是它在 GO 中的作用：
package main func lcslength(x string, y string, m int, n int) int c := make(int, m+1) for i := range c for i := 1; i <= m; i++ else }return c[m][n]} func max(a, b int) int return b } func main()以下是它在 GO 中的作用：
package main func lcslength(x string, y string, m int, n int) int c := make(int, n+1) for i := 1; i <= m; i++ else if c[j] >right if i > m-j+1 }return right } func max(a, b int) int return b } func main()
在此处插入说明。
在此处插入说明。
在此处插入说明。
首先，让我们解释如何使用 2*min（m， n） 条目和 o（1） 的额外空间计算最长公共子序列 （LCS） 的长度。 这个问题可以使用动态规划来解决。 动态规划是一种将问题分解为更小的子问题并存储这些子问题的解决方案以避免重复计算的方法。
我们可以定义一个二维数组 dp[i][j]，其中 dp[i][j] 表示字符串 x 的前 i 个字符和字符串 y 的前 j 个字符的最长公共子序列的长度。 然后，我们可以根据以下规则填充此数组：
1.如果 x[i] == y[j]，则 dp[i][j] = dp[i-1][j-1] +1。
2.如果 x[i]！= y[j]，则 dp[i][j] = max（dp[i-1][j]， dp[i][j-1]）。
为了仅使用 2*min（m， n） 条目，我们只能将数据存储在 min（m， n） 行和 min（m， n） 列中，因为其他数据可以通过填充规则从这些数据中推导出来。
现在，让我们使用 go 语言来实现这个算法：
package mainimport ( "fmt"func lcslength（x string， y string） int minlen ：= min（m， n） 初始化 dp 数组 dp ：= make（int， minlen+1） for i ：= range dp padding dp array for i ：= 1; i <= m; i++ else }return dp[m][n]}func min(a, b int) int return b}func max(a, b int) int return b}func main()以下是它在 GO 中的作用：
package mainimport ( "fmt"）func lcslength（x string， y string） int minlen ：= min（m， n） 初始化 dp 数组 var dp int dp = make（int， minlen+1） 从后到前填充 dp 数组 i ：= n; i >= 1; i-- else prev =
在此处插入说明。
在此处插入说明。
在此处插入说明。
to compute the length of the longest common subsequence (lcs) using only 2*min(m, n) space plus o(1) additional space, you can use a technique called space optimization in the dp approach. here's a go implementation that demonstrates how to achieve this by only filling in necessary cells in the dp table:
package mainimport "fmt"// lcslength computes the length of the lcs using space optimization.func lcslength(x, y string) int if dp[idx] >0 len1 := lcslength(xidx-1, yidx) len2 := lcslength(xidx, yidx-1) if x[xidx-1] == y[yidx-1] else }// tr**erse the strings in the order that minimizes the space complexity. // this is achieved by starting with the longer string and then the shorter one. if m > n }else }return dp[idx]}// max returns the larger of two integers.func max(a, b int) int return b}func main()to reduce the space usage further, to just min(m, n) space plus o(1) additional space, you can use a stack or a queue to keep track of the indices instead of the dp array. however, this approach would require a more complex recursive function that maintains the stack or queue, which could make the code less clear.
the above code is optimized for space complexity, but due to its recursive nature, it may use more stack space than an iterative version. an iterative implementation with a stack could be used to ensure that the space complexity is truly o(1), but it would be more complex and likely not provide any significant performance improvements unless you are dealing with extremely large strings.
在此处插入说明。
在此处插入说明。
在此处插入说明。
在解释如何使用 2*min（m，n） 条目和表 C 中 O（1） 的额外空间计算 LCS 长度之前，让我们先了解一下 LCS（最长公共子序列）的概念。 以下是基于 2*min（m，n） 个条目和 o（1） 个额外空格的解决方案：
1.初始化分别指向序列 x 和 y 开头的两个指针 i 和 j。 2.创建一个大小为 2*min（m，n） 的数组 c 以保存临时计算结果。 3.对于每个 i 和 j，依次比较 x[i] 和 y[j] 的元素：如果 x[i] 和 y[j] 相等，则将 c[（i-1）%2][j%2] 的值乘以 1，并将 c[i%2][j%2] 更新为 c[（i-1）%2][j%2] 的值。 否则，将 c[i%2][j%2] 更新为 c[i%2][（j-1）%2] 和 c[（i-1）%2][j%2] 中的较大值。 4.返回 C[（M-1）%2][N%2] 作为 LCS 的长度。 下一个解决方案是仅使用 min（m，n） 个条目和 o（1） 个额外的空格：
1.初始化 min（m，n） 的指针 i 和数组 c 以保存临时计算的结果。 2.对于每个 i，依次比较 x[i] 和 y[i] 的元素：如果 x[i] 和 y[i] 相等，则将 c[i] 的值加 1，并将 c[i] 更新为 c[i-1] 的值。 否则，将 c[i] 更新为 c[i-1] 和 c[i] 中的较大值。 3.返回 C[min（m，n）-1] 作为 LCS 的长度。 下面是使用 Go 语言实现上述两种算法的示例：
package mainimport ( "fmt")func lcslengthusing2tables(x, y string, m, n int) int for i := 0; i <= m; i++ else if x[i-1] == y[j-1] else }return c[m%2][n%2]}func lcslengthusing1table(x, y string, m, n int) int else prev = temp } return c[n]}func max(a, b int) int return b}func main()在此处插入说明。
在此处插入说明。
在此处插入说明。
要仅使用 2*min（m， n） 表条目计算 LCS 的长度，您可以使用滚动数组的概念。 这是它在 Go 中的样子：
package mainimport ( "fmt"）func lcslength（x， y string） int c ：= make（int， 2*n+1） 表 c 只需要 2*min（m，n） 个条目 i ：= 0; i <= m; i++ else if x[i-1] == y[j-1] else if c[prevrow*(n+1)+j] >= c[currrow*(n+1)+j-1] else }return c[m%2*(n+1)+n]}func main()要仅使用 min（m， n） 个条目执行相同的工作，并使用 o（1） 的额外空间，您可以使用贪婪算法。 这是它在 Go 中的样子：
package mainimport ( "fmt")func lcslength(x, y string) int currrow := make(int, n+1) prevrow := make(int, n+1) for i := 0; i <= m; i++ else if x[i-1] == y[j-1] else if prevrow[j] >= currrow[j-1] else }copy(prevrow, currrow) }return currrow[n]}func main()这两种方法都可用于计算 LCS 长度，具有更少的条目和额外的空间。
在此处插入说明。
在此处插入说明。
在此处插入说明。
为了计算两个序列的最长公共子序列（LCS）的长度，我们可以使用动态规划的方法。 在标准动态规划方法中，我们使用二维数组 dp 来存储子问题的解，其中 dp[i][j] 表示序列 x 的前 i 个元素和序列 y 的前 j 个元素的 LCS 长度。 该方法的空间复杂度为 o（m * n）。
为了降低空间复杂性，我们可以使用滚动数组技术，该技术仅保留计算当前和先前状态所需的信息。 通过这种方式，我们可以将空间复杂度降低到 o（min（m， n））。 以下是在 go 语言中实现此方法的方法**：
package mainimport ( "fmt"lcs 函数计算两个序列的最长公共子序列的长度func lcs（x， y string） int 创建一个大小为 min（m， n） +1 dp 的一维数组 ：= make（int， n+1） for i ：= 1; i <= m;i++ else } 返回最长的公共子序列的长度 return dp[n]} max 返回两个整数的最大值 func max（a， b int） int return b}func main（）.在仅使用 min（m， n） 条目的情况下，我们可以使用两个一维数组 prev 和 curr 来交替存储有关先前和当前状态的信息。 这种方法的时间复杂度仍为o（m * n），但空间复杂度降低到o（min（m， n））。 下面是实现此方法的 go 语言：
package mainimport ( "fmt"lcs 函数计算两个序列的最长公共子序列的长度func lcs（x， y string） int 创建两个一维数组，每个数组的大小为 n+1 prev ：= make（int， n+1） curr ：= make（int， n+1） for i ：= 1; i <= m;i++ else } swap prev and curr prev， curr = curr， prev } 返回最长的公共子序列的长度 return prev[n]} max 返回两个整数的最大值 func max（a， b int） int return b}func main（）.在此处插入说明。
在此处插入说明。
在此处插入说明。
要使用 2*min（m， n） 个条目和 o（1） 的额外空间计算 LCS 的长度，我们可以使用滚动数组的方法。 下面是使用 Go 语言实现的算法：
package mainimport ( "fmt")func lcslengthrolling(x, y string) int c := make(int, 2) for i := range c for i := 1; i <= m; i++ else }return c[m%2][n]}func max(a, b int) int return b}func main()package mainimport ( "fmt")func lcslengthmin(x, y string) int c := make(int, n+1) for i := 1; i <= m; i++ else prev = temp } return c[n]}func max(a, b int) int return b}func main()在此处插入说明。
在此处插入说明。
在此处插入说明。