给三个字符串，判断C字符串是否由A B字符串顺序组成，

---

很容易想到的是，A的长度加上B的长度为C的长度

其实进一步想，这 提供了一个思路：

设f(i,j)为bool数组 ，表示 A的 1~i 部分 和B的 1~j 部分是否能组成 C的1~i+j部分

这也是符合上面的定理的

---

分析一下A的第 i 项 、B的第 j 项 、C的第 i+j 项 的关系

其实这决定了 什么情况用什么公式（情况很多）

因为如果 结果为Yes,那么 C的第 i+j 项 一定等于A的第 i 项 或 B的第 j 项

因为：

A的第 i 项是A的1~i部分的末尾，

B的第 j 项是B的1~j 部分的末尾，

C的1~ i + j 项是由A的1~i部分 和 B的1~j 部分 组成的，

C的1~ i + j 项的末尾必为 A的1~i部分的末尾 或 B的1~j 部分的末尾

也就是C的第 i+j 项 一定等于A的第 i 项 或 B的第 j 项

---

但事实是，C的第 i+j 项要么是A的第 i 项 要么是B的第 j 项

也可能，A的第 i 项 =B的第 j 项=C的第 i+j 项，我们要枚举两个情况，有一个为Yes即可

不过我们只是想知道A的 1~i 部分 和B的 1~j 部分是否能组成 C的1~i+j部分

所以我们看 f(i-1,j) （以a结尾）和f(i,j-1) （以b结尾） 即可

---

好了，根据上述，我们推出

当 C(i+j) = a(i) 且 C（i+j) = b(j )

\[f(i,j) = f(i - 1, j) || f(i, j - 1);
\]

解析：三个相等时，二者皆有可能，有一个为Yes即可，所以是用或

当 C(i+j) = a(i) 且 C（i+j) ≠ b(j)

\[f(i,j) = f(i - 1, j) ;
\]

解析：只有a和C相等时，只可能是以a结尾

当 C(i+j) ≠ a(i) 且 C（i+j) = b(j)

\[f(i,j) = f(i, j-1) ;
\]

解析：只有b和C相等时，只可能是以b结尾

当 C(i+j) ≠ a(i) 且 C（i+j) ≠ b(j)

\[f(i,j) = false;
\]

解析：皆不相等，无解

---

代码与理论的不同之处：

1. 由于字符串是从0位开始的，所以调用 a,b,c 时记得位数减1
2. 由于是记忆化，我的 f 略有不同——0表示未计算，1表示有解，2表示无解
3. 上面问题的延伸——f 数组 mod 2 可转成bool

---

主函数：

int main() {
    cin >> n;//多组数据
    for (int i = 1; i <= n; i++) {
        memset(f, 0, sizeof(f));//每次都要初始化
        cin >> a >> b >> c;
        lena = a.size();
        lenb = b.size();
        lenc = c.size();//求位数
        if (lena + lenb == lenc && dg(lena, lenb)) {//判断
            cout << "Data set " << i << ":yes" << endl;
        } else {
            cout << "Data set " << i << ":no" << endl;
        }
    }
}

简单，不详细讲解

---

递归函数：

整体浏览

bool dg(int x, int y) //求f(x,y)
{
    if (f[x][y])
        return f[x][y] % 2;
    if (!x) {
        bool flag = true;
        for (int i = 0; i < y; i++) {
            if (c[i] != b[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    if (!y) {
        bool flag = true;
        for (int i = 0; i < x; i++) {
            if (c[i] != a[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    if (c[x + y - 1] == a[x - 1] && c[x + y - 1] == b[y - 1]) {
        f[x][y] = dg(x - 1, y) || dg(x, y - 1);
    } else {
        if (c[x + y - 1] == a[x - 1]) {
            f[x][y] = dg(x - 1, y);
        } else {
            if (c[x + y - 1] == b[y - 1]) {
                f[x][y] = dg(x, y - 1);
            } else {
                return false;
            }
        }
    }
    if (f[x][y] == 0)
        f[x][y] = 2;
    return f[x][y] % 2;
}

---

记忆化：

    if (f[x][y])
        return f[x][y] % 2;

简单，不讲

---

边界：

如果一个数为0了，只需比较另外一个数和c直接位对位比较

    if (!x) {//如果a匹配完了
        bool flag = true;
        for (int i = 0; i < y; i++) {
            if (c[i] != b[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    if (!y) {//如果b匹配完了
        bool flag = true;
        for (int i = 0; i < x; i++) {
            if (c[i] != a[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }

---

公式：

使用大量if，不解释

    if (c[x + y - 1] == a[x - 1] && c[x + y - 1] == b[y - 1]) {//三者相等
        f[x][y] = dg(x - 1, y) || dg(x, y - 1);
    } else {
        if (c[x + y - 1] == a[x - 1]) {//只与a匹配
            f[x][y] = dg(x - 1, y);
        } else {
            if (c[x + y - 1] == b[y - 1]) {//只与b匹配
                f[x][y] = dg(x, y - 1);
            } else {
                return false;//无解
            }
        }
    }

此时 f 可能为0，我们将其转成2，返回即可

---

#include <bits/stdc++.h>
using namespace std;
int n, lena, lenb, lenc;
string a, b, c;
int f[205][205];
bool dg(int x, int y)
{
    if (f[x][y])
        return f[x][y] % 2;
    if (!x) {
        bool flag = true;
        for (int i = 0; i < y; i++) {
            if (c[i] != b[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    if (!y) {
        bool flag = true;
        for (int i = 0; i < x; i++) {
            if (c[i] != a[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    if (c[x + y - 1] == a[x - 1] && c[x + y - 1] == b[y - 1]) {
        f[x][y] = dg(x - 1, y) || dg(x, y - 1);
    } else {
        if (c[x + y - 1] == a[x - 1]) {
            f[x][y] = dg(x - 1, y);
        } else {
            if (c[x + y - 1] == b[y - 1]) {
                f[x][y] = dg(x, y - 1);
            } else {
                return false;
            }
        }
    }
    if (f[x][y] == 0)
        f[x][y] = 2;
    return f[x][y] % 2;
}
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        memset(f, 0, sizeof(f));
        cin >> a >> b >> c;
        lena = a.size();
        lenb = b.size();
        lenc = c.size();
        if (lena + lenb == lenc && dg(lena, lenb)) {
            cout << "Data set " << i << ":yes" << endl;
        } else {
            cout << "Data set " << i << ":no" << endl;
        }
    }
}