在LeetCode中等难度题目中，「交错字符串」是一道经典的动态规划应用题。它的核心是判断一个字符串是否能由另外两个字符串"交错"组成，看似简单却容易陷入思维误区，今天我们就来一步步拆解这道题，从题目理解到代码实现，把每一个细节讲透。
一、题目核心理解
先明确题目要求：给定三个字符串s1、s2、s3，验证s3是否是由s1和s2交错组成的。这里的「交错」有严格定义，我们用通俗的话翻译一下：
-
将s1分割成若干个非空子串（比如s1 = a + b + c），s2分割成若干个非空子串（比如s2 = x + y）；
-
分割后两个字符串的子串数量相差不超过1（|n - m| ≤ 1）；
-
把这两组子串交替拼接，要么是「s1子串在前、s2子串在后」（a+x + b+y + c），要么是「s2子串在前、s1子串在后」（x+a + y+b），最终拼接结果等于s3。
举个例子：s1 = "aabcc"，s2 = "dbbca"，s3 = "aadbbcbcac"，就是一个合法的交错组合------s1分割为"aa"+"bc"+"c"，s2分割为"dbbc"+"a"，交替拼接后得到"aa"+"dbbc"+"bc"+"a"+"c"，正好等于s3。
而如果s3的长度不等于s1+s2的长度，那直接可以判定为false，这是最基础的边界条件。
二、解题思路：为什么用动态规划？
拿到这道题，首先会想到暴力解法------枚举s1和s2的所有分割方式，再判断拼接后是否等于s3。但这种方法的时间复杂度极高，因为分割方式的数量是指数级的，对于稍长的字符串完全不适用。
这时候就需要动态规划（DP）来优化。动态规划的核心是「状态定义+状态转移」，我们可以通过定义一个DP数组，记录"用s1的前i个字符和s2的前j个字符，能否组成s3的前i+j个字符"，这样就能把大问题拆解成小问题，逐步递推求解。
三、动态规划细节拆解
1. 状态定义
定义dp[i][j]：表示s1的前i个字符（s1[0..i-1]）和s2的前j个字符（s2[0..j-1]），能否交错组成s3的前i+j个字符（s3[0..i+j-1]）。
这里要注意下标细节：i和j从0开始，当i=0时，意味着不使用s1的任何字符，只使用s2的前j个字符；当j=0时，意味着不使用s2的任何字符，只使用s1的前i个字符。
2. 初始化
初始化的核心是处理"只使用s1"或"只使用s2"的情况：
-
dp[0][0] = true：s1的前0个字符（空字符串）和s2的前0个字符（空字符串），能组成s3的前0个字符（空字符串），这是基础条件。
-
当i>0、j=0时：dp[i][0] = dp[i-1][0] && s1[i-1] === s3[i-1]。也就是说，只有前i-1个字符能组成s3的前i-1个字符，且s1的第i个字符（s1[i-1]）等于s3的第i个字符（s3[i-1]），才能满足条件。
-
当j>0、i=0时：类似上面，dp[0][j] = dp[0][j-1] && s2[j-1] === s3[j-1]。
3. 状态转移方程
对于任意i>0、j>0的情况，dp[i][j]的取值有两种可能，只要满足其中一种，就为true：
-
最后一个字符来自s1：此时需要满足「s1的前i-1个字符和s2的前j个字符能组成s3的前i+j-1个字符」（即dp[i-1][j]为true），并且s1的第i个字符（s1[i-1]）等于s3的第i+j个字符（s3[i+j-1]）。
-
最后一个字符来自s2：此时需要满足「s1的前i个字符和s2的前j-1个字符能组成s3的前i+j-1个字符」（即dp[i][j-1]为true），并且s2的第j个字符（s2[j-1]）等于s3的第i+j个字符（s3[i+j-1]）。
因此，状态转移方程可以写成：
dp[i][j] = (dp[i-1][j] && s1[i-1] === s3[i+j-1]) || (dp[i][j-1] && s2[j-1] === s3[i+j-1])
4. 最终结果
dp[s1.length][s2.length] 就是我们要的答案------表示s1的全部字符和s2的全部字符，能否交错组成s3的全部字符。
四、完整代码及逐行解读
下面是完整的TypeScript代码，结合上面的思路，逐行解读每一步的作用：
typescript
function isInterleave(s1: string, s2: string, s3: string): boolean {
// 1. 边界条件：s3长度不等于s1+s2长度，直接返回false
const l1: number = s1.length;
const l2: number = s2.length;
const l3: number = s3.length;
if (l1 + l2 != l3) {
return false;
}
// 2. 初始化DP数组：dp[i][j]表示s1前i个、s2前j个能否组成s3前i+j个
const dp: boolean[][] = Array.from({ length: l1 + 1 }, () => new Array(l2 + 1).fill(false))
dp[0][0] = true; // 空字符组成空字符，基础条件
// 3. 填充DP数组：双重循环遍历所有i和j的组合
for (let i = 0; i <= l1; i++) {
for (let j = 0; j <= l2; j++) {
const p = i + j - 1; // s3当前对应的下标（前i+j个字符的最后一个下标）
// 情况1：最后一个字符来自s1（i>0才有可能）
if (i > 0) {
dp[i][j] = (dp[i - 1][j] && s1[i - 1] === s3[p]) || dp[i][j];
}
// 情况2：最后一个字符来自s2（j>0才有可能）
if (j > 0) {
dp[i][j] = (dp[i][j - 1] && s2[j - 1] === s3[p]) || dp[i][j];
}
}
}
// 4. 返回最终结果：s1全部和s2全部能否组成s3全部
return dp[l1][l2];
};五、关键注意点&优化方向
1. 下标细节（最容易踩坑）
一定要注意：s1的第i个字符对应的下标是i-1，s2的第j个字符对应的下标是j-1，s3的前i+j个字符的最后一个下标是i+j-1（即变量p）。很多人会在这里混淆下标，导致代码出错。
2. 空间优化
上面的代码使用了二维DP数组，空间复杂度是O(l1*l2)。但观察状态转移方程可以发现，dp[i][j]只依赖于dp[i-1][j]（上一行）和dp[i][j-1]（同一行前一列），因此可以优化为一维DP数组，将空间复杂度降低到O(min(l1, l2))。
优化思路：用一个一维数组dp[j]，每次遍历i时，更新dp[j]的值，具体可以自行尝试（提示：遍历i时，dp[j]的更新需要注意顺序，避免覆盖未使用的值）。
3. 特殊测试用例
提交代码前，建议测试以下几个特殊用例，避免边界漏洞：
-
s1、s2均为空：s3也为空 → 返回true；s3非空 → 返回false。
-
其中一个字符串为空：比如s1为空，判断s2是否等于s3；反之亦然。
-
字符重复场景：比如s1="aabcc"，s2="dbbca"，s3="aadbbbaccc" → 返回false（最后一个c的来源不匹配）。
六、总结
「交错字符串」的核心是用动态规划将"分割拼接"的复杂问题，转化为"逐步判断字符匹配"的子问题。关键在于正确定义DP状态，理清状态转移的两种情况，同时注意下标细节。
这道题的DP思路具有通用性，类似"两个字符串拼接成第三个字符串"的问题，都可以尝试用类似的状态定义来解决。掌握了这道题，也能加深对动态规划"递推思想"的理解。