第一题中题目核心点就是拼接，每次拼接有两种方式，如果是爆搜的话，那么时间复杂度会很高，但是我们注意到一个性质，就是我们第一次拼接完之后，第二次再拼接的话，其实是不是只需要知道头和尾的字符就行，不需要字符串是怎么样的，那么知道头和尾了，那么是不是我们现在就差前面一次拼接时的状态的字符串长度，那么只要前面的状态有了头和尾和当前字符串最小长度，那是不是我们就可以从上一个状态转移过来了，不太懂的话，可以先按爆搜思考，再用记忆化搜索，最后再用动态规划来考虑，我是直接爆搜后发现这个性质，然后就知道用记忆化搜索或者动态规划这里采用动态规划，定义f[i][j][k]，代表前i次操作头为j尾为k的最小长度，那么转移的时候，我们就可以根据当前的words[i]来判断是否可以转移了，那么第i次操作之后，拼接之后主要分为两种情况

第一种情况：
1.1:words[i]的尾部和stri-1的头部相同，那么这种情况拼接之后的头部是words[i]的头部，stri-1的尾部,这个stri-1的尾部我们是不知道具体是哪个的，但是不会超过26个字符的，所以直接遍历尾部

f[i][top][k] = min(f[i][top][k],f[i - 1][tail][k] + len - 1);

1.2:words[i]的尾部和stri-1的头部不相同

f[i][top][k] = min(f[i][top][k],f[i - 1][j][k] + len);

第二种情况同理

words[i]的头部和stri-1的尾部相同,那么拼接之后就是stri-1的头部和words[i]的尾部，拼接的地方是words[i]的头部

2.1

f[i][j][tail] = min(f[i][j][tail],f[i - 1][j][top] + len - 1);

2.2

f[i][j][tail] = min(f[i][j][tail],f[i - 1][j][k] + len);

class Solution {
public:
    int f[1100][26][26];
    int minimizeConcatenatedLength(vector<string>& words) 
    {
        memset(f,0x3f3f3f3f,sizeof(f));
        string str0 = words[0];
        int n = words.size();
        string stri_1 = str0;
        f[0][stri_1[0] - 'a'][stri_1[stri_1.size() - 1] - 'a'] 
        = stri_1.size();
        for(int i = 1;i < n;i++)
        {
           int top = words[i][0] - 'a';
           int tail = words[i][words[i].size() - 1] - 'a';
           int len = words[i].size();
           for(int j = 0;j < 26;j++)
           {
              for(int k = 0;k < 26;k++)
              {
                 if(tail == j)//如果当前单词的尾等于上一层字符串的头的话
                 {
                     f[i][top][k] = 
                     min(f[i][top][k],f[i - 1][j][k] + len - 1);
                 }
                 else f[i][top][k] = min(f[i][top][k],f[i - 1][j][k]+ len);

                 if(top == k)
                 {
                     f[i][j][tail] = 
                     min(f[i][j][tail],f[i - 1][j][k] + len - 1);
                 }
                 else f[i][j][tail] = min(f[i][j][tail],f[i - 1][j][k]+len);
              }
           }
        }
        int ans = 0x3f3f3f3f;
        for (int j = 0; j < 26; j++) 
           for (int k = 0; k < 26; k++) 
            ans = min(ans, f[n - 1][j][k]);
  
        return ans;
    }
};