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

Solution 1 (runtime: 93 ms):
#include <bits/stdc++.h>
using namespace std;

#define vi vector<int>
#define vpi vector<pair<int, int>>
#define vii vector<vector<int>>
#define pi pair<int, int>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rev(i, a, b) for (int i = a; i >= b; i--)
#define maxf(v) *max_element(v.begin(), v.end())
#define minf(v) *min_element(v.begin(), v.end())
#define revr(v) reverse(v.begin(), v.end())
#define inp(v) for (auto &i : v) cin >> i;
#define print(v) for (auto &i : v) cout << i << " ";
#define tvs(v) for (auto &i : v)
#define rsort(v) sort(v.rbegin(), v.rend())
#define pb push_back
#define pp pop_back
#define bb(v) v.back()
#define ff first
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define rr return
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define mx(x) *max_element(all(x))
#define mn(x) *min_element(all(x))
#define summ(x) accumulate(all(x), 0LL)
#define prt(x) cout << x << endl
#define lb lower_bound
#define up upper_bound
#define lld long double
#define int long long
#define ull unsigned int
#define ll int
const int mod = 998244353;
const ll inf = LLONG_MAX;
const ll ninf = LLONG_MIN;

#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << " "; _print(x); cerr << endl;
#else
#define debug(x)
#endif

void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(lld t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(ull t) { cerr << t; }

template <class T, class V> void _print(pair<T, V> p);
template <class T> void _print(vector<T> v);
template <class T> void _print(set<T> v);
template <class T, class V> void _print(map<T, V> v);
template <class T> void _print(multiset<T> v);
template <class T, class V> void _print(pair<T, V> p) {
    cerr << "{"; _print(p.ff); cerr << ","; _print(p.second); cerr << "}";
}
template <class T> void _print(vector<T> v) {
    cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";
}
template <class T> void _print(set<T> v) {
    cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";
}
template <class T> void _print(multiset<T> v) {
    cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";
}
template <class T, class V> void _print(map<T, V> v) {
    cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";
}
void fast() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
}

long long fpow(long long base, long long exp) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) result *= base;
        base *= base;
        exp /= 2;
    }
    return result;
}
#define double long double
#define ss second
// void solve(int nx) {
//     vector<vector<int>> v={{11,12,13,14},{21,22,23,24},{31,32,33,34},{41,42,43,44}};
//     vii ans=v;
//     for(int i=1;i<=2;i++){
//             for(int j=0;j<4;j++){
//                 for(int  k=0;k<4;k++){
//                     ans[k][4+1-j]=v[j][k];
//                 }

//             }
//              swap(ans,v);
//     }
//     debug(ans);



// }

// void solve(){
//     int n1,n2; cin>>n1>>n2;
//     string s,t; cin>>s>>t;
//     int i=0;
//     int j=0;
//     while(i<s.size() && j<t.size()){
//         if(s[i]=='b' && t[j]=='b') {i++; j++;}
//         else break;
//     }
//     if(i==s.size() && j!=t.size()) {no; rr;}
//     if(i!=s.size() && j==t.size()) {no; rr;}
//     if(s[i]!=t[j]) {no; rr;}
//     vpi v1,v2;
//     vpi v3,v4;
//     while(i<s.size()){
//         if(s[i]=='a'){
//             int start=i;
//             while(i<s.size() && s[i]=='a') {i++;}
//             v1.pb({start,i-1});
//         }
//         else {
//              int start=i;
//             while(i<s.size() && s[i]=='b') {i++;}
//             v3.pb({start,i-1});
//         }
//     }
//      while(j<t.size()){
//         if(t[j]=='a'){
//             int start=j;
//             while(j<t.size() && t[j]=='a') {j++;}
//             v2.pb({start,j-1});
//         }
//         else {
//           int start=j;
//             while(j<t.size() && t[j]=='b') {j++;}
//             v4.pb({start,j-1});  
//         }
//     }
//     if((v1.size()!=v2.size()) || (v3.size()!=v4.size())) {no; rr;}
//     rep(i,0,v1.size()){
//         int len1=v1[i].second-v1[i].first;
//         int len2=v2[i].second-v2[i].first;
//         if(len1!=len2) {no; rr;}
//     }
//     yes;


// }

// void solve(){
//    int n; cin>>n; vi v(n);
//    for(auto &i:v) cin>>i;
//    vi ans(n,-1);
//     multiset<int> ms(all(v));
//     int i=0;
//    // vpi ans;
//     while(i<n){
//         multiset<int> ms1;
//         ms1.insert(v[i]);
//         ms.erase(ms.find(v[i]));
//         int start=i;
//         debug(start);
//         int j=i+1;
//         while(j<n) {int x=*ms.begin(); debug(x); if(x>=*ms1.rbegin()) break; ms.erase(ms.find(v[j])); ms1.insert(v[j]); j++;}
//         debug(ms1);
//         ans[start]=*ms1.rbegin();
//         i=j;
//     }
//     debug(ans);
//     rep(i,0,n){
//         if(ans[i]==-1) ans[i]=ans[i-1];
//     }
//     print(ans); cout<<endl;

// }

// void solve(){
//     int n,m; cin>>n>>m;
//     int h; cin>>h;
//     set<int> horse;
//     rep(i,0,h){
//         int x; cin>>x;
//         s.insert(x);
//     }
//     vii adj(n+1,vi());
//     map<pair<int,int>,int> mp;
//     rep(i,0,m){
//         int x,y,w; cin>>x>>y>>w;
//         adj[x].pb(y);
//         adj[y].pb(x);
//         mp[{min(x,y),max(x,y)}]=w;
//     }

//         vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
//         dist[0][0] = 0;

//         priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, greater<>> pq;
//         pq.push({dist[0],0, {0, 0}});


//         vector<pair<int, int>> directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

//         while (!pq.empty()) {
//             int d = pq.top().first;
//             int hashorse=pq.top().first.second;

//             int x = pq.top().second.first;
//             int y=pq.top().second.second;
//           //  int y = pq.top().second.second;
//             pq.pop();

//             if (d > dist[x][hashorse]) continue;
//             if(hashorse){
//                 int dist=

//             }
//             else{

//             }

           
            
//         }

//         return dist[n-1][m-1];
// }

// void solve1(){
//     int n,q; cin>>n>>q;
//     vi v(n);
//     map<int,int> cnt;
//     vi prev(n);
//     vi next(n);
//     rep(i,0,n){
//         v[i]=i;
//         cnt[i]++;
//         prev[i]=i;
//         next[i]=i;
//     }
//     while(q--){
//         int type; cin>>type;
//         if(type==2) {int c; cin>>c; cout<<cnt[c-1]<<endl; continue;}
//         int x,c; cin>>x>>c;
//         x--; c--;
//         if()
//     }



// }


const int MAXN = 5005; 
int dp[MAXN][MAXN];

int f(int i, int j, const string &a, const string &b, const string &c) {
    if (i == a.size() && j == b.size()) return 0; 

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

    int res = INT_MAX;

    if (i < a.size() && c[i + j] == a[i]) {
        res = min(res, f(i + 1, j, a, b, c));
    } else if (i < a.size()) {
        res = min(res, 1 + f(i + 1, j, a, b, c)); 
    }

    if (j < b.size() && c[i + j] == b[j]) {
        res = min(res, f(i, j + 1, a, b, c));
    } else if (j < b.size()) {
        res = min(res, 1 + f(i, j + 1, a, b, c)); 
    }

    return dp[i][j] = res; 
}

void solve2() {
    string a, b, c;
    cin >> a >> b >> c;
    int n=a.size(); int m=b.size();
   

   

    vector<vector<int>> dp(n+5,vector<int>(m+5,10000000));
 dp[0][0]=0;
    for(int i=0;i<=n;i++){
        for(int j=0;j<=m;j++){
            
            if(i<n && i+j<c.size()){
                int tt=a[i]!=c[i+j];
                dp[i+1][j]=min(dp[i+1][j],tt+dp[i][j]);

            }
             if(j<m && i+j<c.size()){
                int tt=b[j]!=c[i+j];
                dp[i][j+1]=min(dp[i][j+1],tt+dp[i][j]);

            }
        }
    }
    cout<<dp[n][m]<<endl;

    
}
int32_t main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    #ifndef ONLINE_JUDGE
        freopen("input1.txt", "r", stdin);
        freopen("input2.txt", "w", stdout);
        freopen("error1.txt", "w", stderr);
    #endif

    int test = 1;
    cin >> test;
    rep(i, 1, test + 1) solve2();

    return 0;
}


Solution 2 (runtime: 62 ms):
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>

const int M=1e9+7;
// const int N=2e5+10;
// ll dppower[N];
// ll segtree[2*N];

// ll findroot(ll n){
// 	ll low=1;
// 	ll high=n;
// 	while(high-low>1){
// 		ll mid=low+(high-low)/2;
// 		if(mid*mid==n) return mid;
// 		if(mid*mid>n) high=mid;
// 		else low=mid;
// 	}
// 	return low;
// }

// ll powerll(ll x,ll y){
// 	ll temp;
// 	if(dppower[y]!=0) return dppower[y];
//     if (y == 0)
//         return 1LL;
//     temp = powerll(x, y / 2);
//     if (y % 2 == 0)
//         return dppower[y]=(temp * temp)%M;
//     else
//         return dppower[y]=((x%M) * ((temp * temp)%M))%M;
// }

// void buildsegtree(vector<int>& vec)  
// {
// 	int n=vec.size();
//     // insert leaf nodes in tree 
//     for (int i=0; i<n; i++)     
//         segtree[n+i] = vec[i]; 
      
//     // build the tree by calculating parents 
//     for (int i = n - 1; i > 0; --i)      
//         segtree[i] = segtree[i<<1] + segtree[i<<1 | 1];     
// }

// // function to update a tree node 
// void updateTreeNode(int p, int value, int n)  
// {  
//     // set value at position p 
//     segtree[p+n] = value; 
//     p = p+n; 
      
//     // move upward and update parents 
//     for (int i=p; i > 1; i >>= 1) 
//         segtree[i>>1] = segtree[i] + segtree[i^1]; 
// } 

// // function to get sum on interval [l, r) 
// int querysegtree(int l, int r, int n)  
// {  
//     int res = 0; 
      
//     // loop to find the sum in the range 
//     for (l += n, r += n; l < r; l >>= 1, r >>= 1) 
//     { 
//         if (l&1)  
//             res += segtree[l++]; 
      
//         if (r&1)  
//             res += segtree[--r]; 
//     } 
      
//     return res; 
// }

//---------------------------------------------------------------------
// void dpsolve(string& a, string& b, string& c){

// }
void solve(){
	string a,b,c; cin>>a>>b>>c;
	int na=a.size(),nb=b.size();
	int dp[na+1][nb+1];
	fill(&dp[0][0],&dp[0][0]+(na+1)*(nb+1),M);
	dp[0][0]=0;
	for(int i=0;i<na;i++){
		dp[i+1][0]=dp[i][0]+(a[i]==c[i]?0:1);
	}
	for(int i=0;i<nb;i++){
		dp[0][i+1]=dp[0][i]+(b[i]==c[i]?0:1);
	}
	for(int i=1;i<=na;i++){
		for(int j=1;j<=nb;j++){
			dp[i][j]=min(dp[i-1][j]+(a[i-1]==c[i+j-1]?0:1),
						 dp[i][j-1]+(b[j-1]==c[i+j-1]?0:1));
		}
	}
	cout<<dp[na][nb]<<endl;
}

int main(){
	int t; cin>>t;
	while(t--){
		solve();
	}
	return 0;
}