Problem: 2050E - Three Strings
Language: c++17 

Solution 1 (runtime: 609 ms):
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define MOD 1000000007

int dp[1005][1005]; // Memoization table

// Helper function to calculate minimum mismatches
int fun(const string &a, const string &b, const string &c, int i, int j) {
    int k = i + j; // Current index in c
    if (k == c.length()) return 0; // Base case: All characters in c processed

    if (dp[i][j] != -1) return dp[i][j]; // Return memoized result

    int res = INT_MAX;

    // If current character in c matches a[i]
    if (i < a.length() && c[k] == a[i]) {
        res = min(res, fun(a, b, c, i + 1, j));
    }
    // If current character in c matches b[j]
    if (j < b.length() && c[k] == b[j]) {
        res = min(res, fun(a, b, c, i, j + 1));
    }
    // If mismatch, replace the character in c
    if (i < a.length()) {
        res = min(res, fun(a, b, c, i + 1, j) + 1);
    }
    if (j < b.length()) {
        res = min(res, fun(a, b, c, i, j + 1) + 1);
    }

    return dp[i][j] = res; // Memoize and return result
}

main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin >> t;
    while (t--) {
        string a, b, c;
        cin >> a >> b >> c;

        // Initialize memoization table
        memset(dp, -1, sizeof(dp));

        // Find and print the result
        cout << fun(a, b, c, 0, 0) << endl;
    }
    return 0;
}


Solution 2 (runtime: 108 ms):
/*⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                        ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞        ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞         ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞           ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞                             ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞                    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞              ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞              ⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞                   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                            ⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞                       ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                                    ⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞                             ⁞⁞⁞⁞⁞⁞⁞                                   ⁞    ⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                                                                     ⁞⁞   ⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                         ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                                  ⁞⁞    ⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞                   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                   ⁞⁞         ⁞⁞⁞⁞   ⁞⁞⁞⁞⁞

⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞                ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                ⁞⁞⁞⁞⁞        ⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞             ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞            ⁞⁞⁞⁞⁞⁞⁞⁞        ⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞          ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞         ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞       ⁞⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞        ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞       ⁞⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞

⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                ⁞⁞⁞⁞⁞⁞⁞⁞  ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞        ⁞⁞⁞⁞⁞⁞⁞              ⁞⁞⁞⁞⁞⁞ ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞            ⁞⁞                ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                         ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞    ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞                   ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞     ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞               ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞      ⁞⁞⁞⁞⁞⁞⁞           ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞        ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                   ⁞⁞⁞⁞⁞⁞⁞          ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞                        ⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞

⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞⁞*/

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long long int lli;

#define endline cout << "\n";

#define endl "\n";

#define KAMUI                         \

    ios_base::sync_with_stdio(false); \

    cin.tie(NULL);



const int mod = 1e9 + 7;

/*****************************************************************/



int helper(int i, int j, string &a, string &b, string &c, vector<vector<int>> &dp)

{

    int n = a.size();

    int m = b.size();

    int ans = 1e6;

    if (i + j >= n + m)

        return 0;

    if (dp[i][j] != -1)

        return dp[i][j];

    if (i < n && c[i + j] == a[i])

    {

        ans = min(ans, helper(i + 1, j, a, b, c, dp));

    }

    if (j < m && c[i + j] == b[j])

    {

        ans = min(ans, helper(i, j + 1, a, b, c, dp));

    }

    // Consider replacing characters if no match

    if (i < n)

        ans = min(ans, 1 + helper(i + 1, j, a, b, c, dp));

    if (j < m)

        ans = min(ans, 1 + helper(i, j + 1, a, b, c, dp));



    return dp[i][j] = ans;

}

int main()

{

    KAMUI



    int t;

    cin >> t;

    while (t--)

    {

        string a, b, c;

        cin >> a >> b >> c;

        int n = a.size();

        int m = b.size();

        vector<vector<int>> dp(n + 1, vector<int>(m + 1, -1));

        cout << helper(0, 0, a, b, c, dp);

        cout << endl;

    }

    return 0;

}