Problem:
Score : 500 points

Problem Statement

Snuke has a string s.
From this string, Anuke, Bnuke, and Cnuke obtained strings a, b, and c, respectively, as follows:

Choose a non-empty (contiguous) substring of s (possibly s itself). Then, replace some characters (possibly all or none) in it with ?s.

For example, if s is mississippi, we can choose the substring ssissip and replace its 1-st and 3-rd characters with ? to obtain ?s?ssip.

You are given the strings a, b, and c.
Find the minimum possible length of s.

Constraints

1 \leq |a|, |b|, |c| \leq 2000

a, b, and c consists of lowercase English letters and ?s.

Input

Input is given from Standard Input in the following format:

a
b
c

Output

Print the minimum possible length of s.

Sample Input 1

a?c
der
cod

Sample Output 1

7

For example, s could be atcoder.

Sample Input 2

atcoder
atcoder
???????

Sample Output 2

7

a, b, and c may not be distinct.

Solution in Python (3.4.3) (judge verdict: Time Limit Exceeded)

def solve():
    Sss = [input().rstrip() for _ in range(3)]

    Sss.sort(key=len, reverse=True)
    As, Bs, Cs = Sss
    lenA, lenB, lenC = len(As), len(Bs), len(Cs)

    def check(Ss, Ts):
        for S, T in zip(Ss, Ts):
            if not (S == T or S == '?' or T == '?'):
                return 0
        return 1

    def getISOKs(Ss, Ts):
        lenS, lenT = len(Ss), len(Ts)
        isOKs = [0] * (lenS+lenT+1)
        for iT in range(-lenT, 0):
            isOKs[iT] = check(Ss[:lenT+iT], Ts[-iT:])
        for iT in range(0, lenS-lenT+1):
            isOKs[iT] = check(Ss[iT:lenT+iT], Ts)
        for iT in range(lenS-lenT+1, lenS+1):
            isOKs[iT] = check(Ss[iT:], Ts[:lenS-iT])
        return isOKs

    isOKABs = getISOKs(As, Bs)
    isOKACs = getISOKs(As, Cs)
    isOKBCs = getISOKs(Bs, Cs)
    isOKBCs = isOKBCs[:lenB+1] + [1]*(lenA+lenB+lenC) + isOKBCs[lenB+1:]

    ans = lenA + lenB + lenC
    for iB in range(-lenB, lenA+1):
        if not isOKABs[iB]: continue
        for iC in range(-lenC, lenA+1):
            if isOKACs[iC] and isOKBCs[iC-iB]:
                L = max(lenA, iB+lenB, iC+lenC) - min(0, iB, iC)
                ans = min(ans, L)
    for iB in range(-lenB, lenA+1):
        if not isOKABs[iB]: continue
        for iC in range(-lenB-lenC, -lenC+1):
            if isOKBCs[iC-iB]:
                L = max(lenA, iB+lenB, iC+lenC) - min(0, iB, iC)
                ans = min(ans, L)
        for iC in range(lenA, lenA+lenB+1):
            if isOKBCs[iC-iB]:
                L = max(lenA, iB+lenB, iC+lenC) - min(0, iB, iC)
                ans = min(ans, L)
    for iC in range(-lenC, lenA+1):
        if not isOKACs[iC]: continue
        for iB in range(-lenB-lenC, -lenB+1):
            if isOKBCs[iC-iB]:
                L = max(lenA, iB+lenB, iC+lenC) - min(0, iB, iC)
                ans = min(ans, L)
        for iB in range(lenA, lenA+lenB+1):
            if isOKBCs[iC-iB]:
                L = max(lenA, iB+lenB, iC+lenC) - min(0, iB, iC)
                ans = min(ans, L)

    print(ans)


solve()