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 Java8 (OpenJDK 1.8.0) (judge verdict: Runtime Error)

//
import java.math.*;
import java.util.*;
import java.io.*;
  
public class Main { 
  
    static BufferedReader in;
    static PrintWriter out = new PrintWriter(System.out);
    static String file = "../in";
    static int test = 10; // 0 for local testing, 1 for std input
    static int inf = 1_000_000, mod = 1_000_000_007;

    void swap(int[]ary, int i, int j)
    {
        int t = ary[i];
        ary[i] = ary[j];
        ary[j] = t;
    }
    
    String[] split() throws Exception
    {
        return in.readLine().split(" ");
    }

    int readInt() throws Exception
    {
        return Integer.valueOf(in.readLine());
    }

    long[] toLongArray() throws Exception
    {
        String[] sp = split();
        int n = sp.length;
        long[] ary = new long[n];
        for(int i = 0; i < n; i++) ary[i] = Long.valueOf(sp[i]);
        return ary;
    }

    int[] toIntArray() throws Exception
    {
        String[] sp = split();
        int n = sp.length;
        int[] ary = new int[n];
        for(int i = 0; i < n; i++) ary[i] = Integer.valueOf(sp[i]);
        return ary;
    }

    String reverse(String str)
    {
        return new StringBuilder(str).reverse().toString();
    }


    long pow(long a, int pow)
    {
        long res = 1;
        while(pow > 0)
        {
            if(pow % 2 != 0) {
                res *= a;
                res %= mod;
            }
            a = a * a;
            a %= mod;
            pow /= 2;
        }

        return res;
    }

    public static void main(String[] args) throws Exception
    {
        int _k = Integer.valueOf("1");
        if(test > 0) in = new BufferedReader(new InputStreamReader(System.in));
        else in = new BufferedReader(new FileReader(file));
        if(test < 0) {String[] str = in.readLine().split(" ");}
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
        // System.out.println((-100 + 0) / 2);

        new Main().e();
        out.flush();
    }

    void e() throws Exception
    {
        String a = in.readLine(),
                b = in.readLine(),
                c = in.readLine();
        // try combs and overlaps
        int len = a.length() * 3;
        len = Math.min(len, combine(a, b, c));
        len = Math.min(len, combine(a, c, b));
        len = Math.min(len, combine(b, a, c));
        len = Math.min(len, combine(b, c, a));
        len = Math.min(len, combine(c, a, b));
        len = Math.min(len, combine(c, b, a));
        out.println(len);
    }

    int overlap(String s1, String s2)
    {
        int n = s1.length();
        for(int i = 0; i < n; i++)
        {
            boolean match = true;
            for(int j = 0; j + i < n; j++)
            {
                if(s1.charAt(j + i) != s2.charAt(j))
                {
                    if(s1.charAt(j + i) == '?' || s2.charAt(j) == '?') continue;
                    match = false;
                    break;
                }
            }
            if(match) return n - i;
        }
        return 0;
    }

    int combine(String s1, String s2, String s3)
    {
        int o1 = overlap(s1, s2),
            o2 = overlap(s2, s3),
            n = s1.length();
        return n * 3 - o1 - o2;
    }

    void d() throws Exception
    {
        int n = readInt();
        Queue<String> q = new LinkedList<>();
        q.offer("");
        char[] cs = {'a','b','c','d','e','f','g','h','i','j'};
        for(int i = 0; i < n; i++)
        {
            Queue<String> q2 = new LinkedList<>();
            while(!q.isEmpty())
            {
                String cur = q.poll();
                for(char c = 'a'; c <= cs[i]; c++)
                {
                    if(c > 'a' && cur.indexOf(c - 1) < 0) continue;
                    q2.offer(cur + String.valueOf(c));
                }
            }
            q = q2;
        }
        for(String str : q) out.println(str);
    }

    void c() throws Exception
    {
        long[] ary = toLongArray();
        long a = ary[0], b = ary[1], c = ary[2];

        long left = a * b;
        long right = (c - a - b);
        if(right < 0)
        {
            out.println("No");
            return;
        }

        right = right * right;
        for(int i = 0; i < 4; i++) right -= left;
        
        if(right > 0) out.println("Yes");
        else out.println("No");
    }
    
    void b() throws Exception
    {
        long[] ary = toLongArray();
        long h = ary[0], w = ary[1];
        if(h == 1 || w == 1)
        {
            out.println("1");
            return;
        }
        long ans = 0;
        // 0 2 4 6 ..
        //  1 3 5 7..
        ans += (h / 2) * w;
        if(h % 2 != 0) ans += (w + 1) / 2;
        out.println(ans);
    }

    void a() throws Exception
    {
        int[] ary = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
        int k = readInt();
        out.println(ary[k - 1]);
    }

}