Leetcode 97. 交错字符串

1、问题分析

题目链接：https://leetcode-cn.com/problems/interleaving-string/submissions/
  可以使用动态规划解决，使用dp数组保存之前的计算结果。代码我已经进行了详细的注释，理解应该没有问题，读者可以作为参考，如果看不懂(可以多看几遍)，欢迎留言哦！我看到会解答一下。
状态转移方程：
$$dp\left[i\right]\left[j\right]=\left(dp\left[i-1\right]\left[j\right]==2\&\&s1\left[i-1\right]==s3\left[i+j-1\right]\right)||\left(dp\left[i\right]\left[j-1\right]==2\&\&s1\left[j-1\right]==s3\left[i+j-1\right]\right)?2:1$$

2、问题解决

  笔者以C++方式解决。

#include "iostream"

using namespace std;

#include "algorithm"
#include "vector"
#include "queue"
#include "set"
#include "map"
#include "cstring"
#include "stack"

class Solution {
private:
    // 定义二维 dp 数组 保存某种选取方式是否可取
    // 例如： dp[2][3] 代表 从 s1 中选取前两个字符，从 s2 中选取 3 个字符，这样能否构成 s3 的前5个字符
    // 如果可以则 dp[2][3] == 2 否则 dp[2][3] == 1
    // 这里状态转移方程是：
    // dp[i][j] = (dp[i - 1][j] == 2 && s1[i - 1] == s3[i + j - 1]) || (dp[i][j - 1] == 2 && s1[j - 1] == s3[i + j - 1]) ? 2 : 1
    // 就是判断 s3[i] 中最后一个字符是选择 s1中的字符， 还是选择 s2中的字符 ,有一个可以拼接成功，说明可以成功
    // 这里选取的字符，
    // 1、首先前面的路径一定是可以拼接的，否则你再怎么拼接后面的字符，整体肯定是不可以的，
    ///2、然后选取的字符一定要和s3中即将组成的字符一样，否则肯定不能拼接成功
    // 上面的状态转移方程我没有设置边界条件，具体的边界条件可以参考源代码
    vector<vector<int>> dp;
public:
    bool isInterleave(string s1, string s2, string s3) {
        // 长度不等，肯定不可以拼接成功
        if (s1.length() + s2.length() != s3.length()) {
            return false;
        }
        // 初始化 dp 数组 这里注意长度是 length() + 1，因为我们保存的选取字符的个数，选取范围为[0,length()]
        // 两个都是闭区间，这里注意一下
        dp.resize(s1.length() + 1);
        for (int i = 0; i < s1.length() + 1; ++i) {
            dp[i].resize(s2.size() + 1);
        }

        // 初始化边界，0个s1+0个s2，肯定可以拼接成 0 个s3
        dp[0][0] = 2;

        // 返回处理结果
        return deal(s1, s2, s3);
    }

    bool deal(const string &s1, const string &s2, const string &s3) {
        // 使用递推方式求解，习惯了使用递归，咋使用还有点不习惯
        for (int i = 0; i < s1.length() + 1; ++i) {
            for (int j = 0; j < s2.length() + 1; ++j) {
                // 边界条件
                if (i == 0 && j == 0) {
                    continue;
                }
                // 边界，防止越界，没有 i-1 ，如果发生越界，那就只有一种情况
                if (i < 1) {
                    // 这里写的比较复杂，读者可以自行拆分，这里要注意各个运算符的优先级，如果不清楚就直接上括号
                    dp[i][j] = (((dp[i][j - 1] == 2) && (i + j - 1 < 0 ? true : s2[j - 1] == s3[i + j - 1]))) ? 2 : 1;
                } else if (j < 1) {
                    // 同上
                    dp[i][j] = (((dp[i - 1][j] == 2) && (i + j - 1 < 0 ? true : s1[i - 1] == s3[i + j - 1]))) ? 2 : 1;
                } else {
                    // 这里没有越界，那就要考虑两种情况
                    dp[i][j] = (((dp[i - 1][j] == 2) && (i + j - 1 < 0 ? true : s1[i - 1] == s3[i + j - 1])) ||
                                ((dp[i][j - 1] == 2) && (i + j - 1 < 0 ? true : s2[j - 1] == s3[i + j - 1]))) ? 2 : 1;

                }

            }
        }

        // 返回选取 s1.length() + s2.length() 个字符，是否可以拼接成功
        return dp[s1.length()][s2.length()] == 2;

    }
};

int main() {
    string s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac";
//    string s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc";
    Solution *pSolution = new Solution;
    bool b = pSolution->isInterleave(s1, s2, s3);
    cout << b << endl;
    system("pause");
    return 0;
}

运行结果

有点菜，有时间再优化一下。

3、总结

  书上的代码直接运行绝大部分是对的，但是总有一些软件的更新使得作者无能为力。之前的API是对的，但是之后就废弃了或修改了是常有的事。所以我们需要跟踪源代码。这只是一个小小的问题，如果没有前辈的无私奉献，很难想象我们自己一天能学到多少内容。感谢各位前辈的辛勤付出，让我们少走了很多的弯路！

点个赞再走呗！欢迎留言哦！