human
I found an interesting problem on https://codeforces.com/problemset/problem/1303/E:
You are given a string $s$. You can build new string $p$ from $s$ using the following operation no more than two times:   choose any subsequence $s_{i_1}, s_{i_2}, \dots, s_{i_k}$ where $1 \le i_1 < i_2 < \dots < i_k \le |s|$.
 erase the chosen subsequence from $s$ ($s$ can become empty).
 concatenate chosen subsequence to the right of the string $p$ (in other words, $p = p + s_{i_1}s_{i_2}\dots s_{i_k}$). 

Of course, initially the string $p$ is empty. 

For example, let $s = \text{ababcd}$. At first, let's choose subsequence $s_1 s_4 s_5 = \text{abc}$ — we will get $s = \text{bad}$ and $p = \text{abc}$. At second, let's choose $s_1 s_2 = \text{ba}$ — we will get $s = \text{d}$ and $p = \text{abcba}$. So we can build $\text{abcba}$ from $\text{ababcd}$.

Can you build a given string $t$ using the algorithm above?

-----Input-----

The first line contains the single integer $T$ ($1 \le T \le 100$) — the number of test cases.

Next $2T$ lines contain test cases — two per test case. The first line contains string $s$ consisting of lowercase Latin letters ($1 \le |s| \le 400$) — the initial string.

The second line contains string $t$ consisting of lowercase Latin letters ($1 \le |t| \le |s|$) — the string you'd like to build.

It's guaranteed that the total length of strings $s$ doesn't exceed $400$.

-----Output-----

Print $T$ answers — one per test case. Print YES (case insensitive) if it's possible to build $t$ and NO (case insensitive) otherwise.

-----Example-----
Input
4
ababcd
abcba
a
b
defi
fed
xyz
x

Output
YES
NO
NO
YES

I tried it in Python, but could not do it. Can you solve it?

 Write me a Python code to print $T$ answers — one per test case?
assistant
#Here is Python code to print $T$ answers — one per test case.

def main():
    T = int(input().strip())
    for _ in range(T):
        s = input().strip()
        t = input().strip()
        n = len(s)
        
        find = [[n] * 26 for _ in range(n + 2)]
        for i in range(n - 1, -1, -1):
            find[i][:] = find[i + 1]
            find[i][ord(s[i]) - ord("a")] = i

        def interleaving(a, b):
            dp = [n] * (len(b) + 1)
            for i in range(len(a) + 1):
                for j in range(len(b) + 1):
                    if i == j == 0:
                        dp[j] = -1
                        continue
                    res = n
                    if i > 0:
                        res = min(res, find[dp[j] + 1][ord(a[i - 1]) - ord("a")])
                    if j > 0:
                        res = min(res, find[dp[j - 1] + 1][ord(b[j - 1]) - ord("a")])
                    dp[j] = res
            return dp[-1] < n

        if any(interleaving(t[:i], t[i:]) for i in range(len(t))):
            print("YES")
        else:
            print("NO")

main()