leetcode专题训练 97. Interleaving String

这道题是一道动态规划的题，首先要判断空的异常情况，之后判断s1和s2合并后字符串长度和s3不同的情况，然后就是动态规划了。动态规划公式：

dp[i][j] = (dp[i-1][j] and s1[i-1] == s3[i+j-1]) or (dp[i][j-1] and s2[j-1] == s3[i+j-1])

其中i和j分别代表着到s1的第i个数，到s2的第j个数，所以到取s1或s2种索引时，要相应的减1。dp[i][j]为True则说明到s1的前i个数，s2的前j个数，可以组合成s3的前(i+j)个数。按照这个公式写的代码如下。一定要注意初始化时，要初始化整个边界，不能落任何位置。
写法1：

class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
        if not s1:
            if s2 == s3:
                return True
            else:
                return False
        if not s2:
            if s1 == s3:
                return True
            else:
                return False
        
        l1 = len(s1)
        l2 = len(s2)

        # 如果长度不一致，那么直接返回False
        if l1+l2 != len(s3):
            return False

        # l1行, l2列
        dp = [[False for i in range(l2+1)] for j in range(l1+1)]
        # 初始化
        dp[0][0] = True
        for i in range(1, l1+1):
            dp[i][0] = dp[i-1][0] and s1[i-1] == s3[i-1]
        for j in range(1, l2+1):
            dp[0][j] = dp[0][j-1] and s2[j-1] == s3[j-1]
        for i in range(1, l1+1):
            for j in range(1, l2+1):
                dp[i][j] = (dp[i-1][j] and s1[i-1] == s3[i+j-1]) or (dp[i][j-1] and s2[j-1] == s3[i+j-1])
        
        return dp[l1][l2]

写法2：
后来看题解，发现由于当前的值只可能由左或上位置转移，那么就可以使用滚动数组解题，减少空间占用，代码如下：

class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
        if not s1:
            if s2 == s3:
                return True
            else:
                return False
        if not s2:
            if s1 == s3:
                return True
            else:
                return False
        
        l1 = len(s1)
        l2 = len(s2)

        # 如果长度不一致，那么直接返回False
        if l1+l2 != len(s3):
            return False

        # l1行, l2列
        dp = [False for i in range(l2+1)]
        # 初始化
        dp[0] = True
        for j in range(1, l2+1):
            dp[j] = dp[j-1] and s2[j-1] == s3[j-1]
        print([dp[j] for j in range(l2+1)])
        for i in range(1, l1+1):
            for j in range(l2+1):
                if j > 0:
                    dp[j] = (dp[j] and s1[i-1] == s3[i+j-1]) or (dp[j-1] and s2[j-1] == s3[i+j-1])
                else:
                    dp[j] = (dp[j] and s1[i-1] == s3[i+j-1])
        
        return dp[l2]

需要注意的是，滚动数组的方法没有设定一边的边界，所以与上面的方法相比，j的范围要从0开始，而不是从1开始。