#include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstdlib>

 #include <cstring>

 #include <vector>

 #define min(a, b) ((a) < (b) ? (a) : (b))

 #define max(a, b) ((a) > (b) ? (a) : (b))

 inline void swap(int &a, int  &b)

 {

     long long tmp = a;a = b;b = tmp;

 }

 inline void read(int& x)

 {

     x = ;char ch = getchar(), c = ch;

     while(ch < '' || ch > '')c = ch, ch = getchar();

     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();

 }

 const int INF = 0x3f3f3f3f;

 const int MAXN = ;

 const int MAXNUM = ;

 int dp[( << MAXN) + ][MAXN + ][], die[MAXN][][MAXN][], n, ma, sum, len[MAXN], cnt[MAXN], tot, b[MAXN];

 char s[MAXN][MAXNUM];

 inline void init()

 {

     memset(dp, , sizeof(dp));

     memset(die, , sizeof(die));

     tot = ;

     sum = ;

     memset(b, , sizeof(b));

     memset(len, , sizeof(len));

     memset(cnt, , sizeof(cnt));

     //check j是否包含在i中

     for(register int i = ;i <= n;++i)

     {

         scanf("%s", s[i] + );

         len[i] = strlen(s[i] + );

     }

     for(register int i = ;i <= n;++ i)

         for(register int j = ;j <= n;++ j)

         {

             if(i == j || b[i] || b[j] || len[j] > len[i])continue;

             //正着配

             for(register int a = ;a <= len[i] - len[j] + ;++ a)

             {

                 int tmp1 = a;

                 while(s[i][tmp1] == s[j][tmp1 - a + ] && tmp1 - a +  <= len[j]) ++ tmp1;

                 if(tmp1 - a +  > len[j]) b[j] = ;

             }

             //倒着配

             for(register int a = len[i];a >= len[j];-- a)

             {

                 int tmp1 = a, p = ;

                 while(s[i][tmp1] == s[j][p] && p <= len[j]) -- tmp1, ++ p;

                 if(p > len[j]) b[j] = ;

             }

         }

     for(register int i = ;i <= n;++ i)

         if(!b[i])

             cnt[++ tot] = i, sum += len[i];

     //j跟在i后面重叠部分大小

     for(register int p = ;p <= tot;++ p)

         for(register int q = ;q <= tot;++ q)

         {

             int i = cnt[p], j = cnt[q];

             if(i == j)continue;

             //0 0

             for(register int a = ;a <= len[i];++ a)

             {

                 int b = , tmp = a;

                 while(s[i][tmp] == s[j][b] && tmp <= len[i] && b <= len[j])++ tmp, ++ b;

                 if(tmp > len[i])

                 {

                     die[p][][q][] = len[i] - a + ;

                     break;

                 }

             }

             //0 1

             for(register int a = ;a <= len[i];++ a)

             {

                 int b = len[j], tmp = a;

                 while(s[i][tmp] == s[j][b] && tmp <= len[i] && b >= )++ tmp, -- b;

                 if(tmp > len[i])

                 {

                     die[p][][q][] = len[i] - a + ;

                     break;

                 }

             }

             //1 0

             for(register int a = len[i];a >= ;-- a)

             {

                 int b = , tmp = a;

                 while(s[i][tmp] == s[j][b] && tmp >=  && b <= len[j])-- tmp, ++ b;

                 if(tmp < )

                 {

                     die[p][][q][] = a;

                     break;

                 }

             }

             //1 1

             for(register int a = len[i];a >= ;-- a)

             {

                 int b = len[j], tmp = a;

                 while(s[i][tmp] == s[j][b] && tmp >=  && b >= )-- tmp, -- b;

                 if(tmp < )

                 {

                     die[p][][q][] = a;

                     break;

                 }

             }

         }

         ma =  << tot;

 }

 int main()

 {

     while(scanf("%d", &n) != EOF && n)

     {

         init();

         int flag = ;

         if(tot == )

         {

             int x = cnt[tot];

             for(register int i = ;i <= len[x];++ i)

             {

                 for(register int j = ;j <= len[x];++ j)

                 {

                     if(j + i -  > len[x]) break;

                     int p1 = , p2 = j, rank = ;

                     while(s[x][p1] == s[x][p2] && rank < len[x])

                     {

                         ++ p1, ++ p2, ++ rank;

                         if(p1 > len[x]) p1 = ;

                         if(p2 > j + i - ) p2 = ;

                     }

                     if(rank >= len[x])

                     {

                         printf("%d\n", max(, i));

                         flag = ;

                         break;

                     }

                 }

                 if(flag) break;

             }

             if(flag) continue;

         }

         //dp[S][i][0/1]表示以1号字符串为头，已经选了S，最后一个是i的正/反状态的最大折叠数

         //dp[S | k][k][p] = max(dp[S | k][k][p], dp[S][i][p'] + die[i][p'][k][p])

          for(register int S = ;S < ma;++ S)

             for(register int i = ;i <= tot;++ i)/*分别用dp[S][i][0]和dp[S][i][1]去更新*/

             {

                 if(!(S & ))continue;

                 if(!(S & ( << (i - )))) continue;

                 for(register int k = ;k <= tot;++ k)

                 {

                     if(S & ( << (k - ))) continue;

                     if(S == )

                     {

                         dp[S | ( << (k - ))][k][] = max(dp[S | ( << (k - ))][k][], dp[S][i][] + die[i][][k][]);

                         dp[S | ( << (k - ))][k][] = max(dp[S | ( << (k - ))][k][], dp[S][i][] + die[i][][k][]);

                     }

                     else

                     {

                         dp[S | ( << (k - ))][k][] = max(dp[S | ( << (k - ))][k][], max(dp[S][i][] + die[i][][k][], dp[S][i][] + die[i][][k][]));

                         dp[S | ( << (k - ))][k][] = max(dp[S | ( << (k - ))][k][], max(dp[S][i][] + die[i][][k][], dp[S][i][] + die[i][][k][]));

                     }

                 }

             }

         int ans = ;

         for(register int i = ;i <= tot;++i)

             ans = max(ans, max(dp[ma - ][i][] + die[i][][][], dp[ma - ][i][] + die[i][][][]));

         printf("%d\n", max(, sum - ans));

     }

     return ;

 }