Problem: 2050E - Three Strings
Language: python

Solution 1 (runtime: 234 ms):
from functools import *
from itertools import *
from collections import *
from math import *
from bisect import *
from heapq import *

def factors(n):
    i = 1
    res = []
    while i <= sqrt(n):
        if (n % i == 0):
            if (n / i == i):
                res.append(i)
            else:
                res.append(i)
                res.append(n//i)
        i = i + 1
    return res

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i:
            i += 1
        else:
            n //= i
            factors.append(i)
    if n > 1:
        factors.append(n)
    return factors

def largest_prime_factor(n):
    i = 2
    while i * i <= n:
        if n % i:
            i += 1
        else:
            n //= i
    return n

def sieve(n):
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1

    return prime

MOD=10**9+7
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]
 
    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]
 
    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]
 
    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]
 
class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)
 
    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

for _ in range(int(input())):
    a = list(input())
    b = list(input())
    c = list(input())

    mask = 0

    dp = [[inf]*(len(b)+1) for _ in range(len(a)+1)]

    for ai in range(len(a), -1, -1):
        for bi in range(len(b), -1, -1):
            i = ai+bi
            if i>=len(c):
                dp[ai][bi] = 0
                continue
            
            ago = inf
            bgo = inf

            if ai<len(a):
                ago = int(a[ai]!=c[i]) + dp[ai+1][bi]
            if bi<len(b):
                bgo = int(b[bi]!=c[i]) + dp[ai][bi+1]
            dp[ai][bi] = min(ago, bgo)
    print(dp[0][0])
 

Solution 2 (runtime: 1467 ms):

def solve(a,b,c):
	dp = [[0] * (len(b) + 1) for _ in (range(len(a)+1))]

	d = 0
	for i in reversed(range(0,len(a))):
		if a[i] != c[i+len(b)]:
			d += 1
		dp[i][len(b)] = d
	d = 0
	for j in reversed(range(0,len(b))):
		if b[j] != c[len(a)+j]:
			d += 1
		dp[len(a)][j] = d

	for k in reversed(range(0,len(a)+len(b)-1)):
		x0 = max(0,k-(len(b)-1))
		x1 = min(k,(len(a)-1))
		for i in range(x0,x1+1):
			j = k-i
			res = None
			if i == len(a):
				res = sum(map(lambda x: x[0]!=x[1], zip(iter(b[j:]),iter(c[i+j:]))))
			elif j == len(b):
				res = sum(map(lambda x: x[0]!=x[1], zip(iter(a[i:]),iter(c[i+j:]))))
			else:
				res = min(
					dp[i+1][j] + (0 if a[i] == c[i+j] else 1),
					dp[i][j+1] + (0 if b[j] == c[i+j] else 1)
				)

			dp[i][j] = res

	return dp[0][0]

def test():
	print(solve("a","b","cb"))
	print(solve("ab","cd","acbd"))
	print(solve("ab","ba","aabb"))
	print(solve("xxx","yyy","xyxyxy"))
	print(solve("a","bcd","decf"))
	print(solve("codes","horse","codeforces"))
	print(solve("egg","annie","egaegaeg"))
	exit()

for _ in range(int(input())):
	print(solve(input(),input(),input()))