每日一练之回文串分割

回文串分割

OJ地址：回文串分割

[动态规划]

• 状态：
  子状态：到第 1，2，3，……，n个字符需要的最小分割数
  F(i)：到第 i 个字符需要的最小分割数
• 状态递推：
  F(i) = min(F(i), F(j) + 1) (当 i < j && [j+1, i]是回文串)
  上式表示如果从 j+1 到 i 判断为回文串，且已经知道从第 1 个字符到第 j 个字符的最小切割数，那么只需要再切一次，就可以保证 1–>j, j+1 --> i 都是回文串
• 初始化：
  F(i) = i - 1;
  上式表示到第 i 个字符需要的最大分割数
  比如单个字符只要切 0 次，2个字符最大需要切 1 次，3个字符最大需要切 2 次，……
• 返回结果：
  F(n)

 //判断是否为回文串
    bool isPlalindrome(string str)
    {
        for(int i = 0; i < str.length()/2; i++)
        {
            if(str[i] != str[str.length()-i-1])
                return false;
        }
        return true;
    }
    int minCut(string s) {
        // write code here
        if(s.length() <= 1)
            return 0;
        int n = s.length() + 1;
        vector<int> dp(n, 0);
        for(int i = 1; i < n; i++)
        {
            //dp[i] = i - 1;  //初始化方法一：初始化为第i个字符需要的最大分割数
            dp[i] = dp[i - 1] + 1; //初始化方法二：初始化为前 i-1 个字符数需要的切割数+1
            for(int j = 0; j < i; j++)
            {
                if(isPlalindrome(s.substr(j, i-j)))
                {
                    if(j == 0) //表示前i个字符组成的字符串整体是回文串，那么直接返回0
                    {
                        dp[i] = 0;
                        break;
                    }
                    else
                        dp[i] = min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[n-1];
    }

[时间复杂度]：O(n^3)

优化

判断回文串的方法可以继续优化，使总体时间复杂度将为O(n^2)
判断回文串，这是一个“是不是”的问题，所以也可以用动态规划来实现
判断回文串：动态规划

• 状态：
  子状态：从第一个字符到第二个字符是不是回文串，第1-3，第2-5，…
  F(i,j): 字符区间 [i,j] 是否为回文串
• 状态递推：
  F(i,j): true->{s[i]==s[j] && F(i+1,j-1)} OR false
  上式表示如果字符区间首尾字符相同且在去掉区间首尾字符后字符区间仍为回文串，则原字符区间为回文串
  从递推公式中可以看到第i处需要用到第 i+1 处的信息，所以i应该从字符串末尾遍历
• 初始化：
  F(i,j) = false
• 返回结果：
  矩阵F(n,n), 只更新一半值（i <= j），n^2 / 2

vector<vector<bool> > getMat(string str)
    {
        int n = str.length();
        vector<vector<bool> > mat(n, vector<bool>(n, false));
        for(int i = n - 1; i >= 0; i--)
        {
            for(int j = i; j < n; j++)
            {
                if(j == i) //单字符为回文串
                    mat[i][j] = true;
                else if(j == (i + 1)) //相邻字符如果相同，则为回文串
                    mat[i][j] = (str[i] == str[j]);
                else
                    mat[i][j] = (str[i] == str[j]) && mat[i + 1][j - 1];
            }
        }
        return mat;
    }
  int minCut(string s) {
        // write code here
        if(s.length() <= 1)
            return 0;
        int n = s.length();  
        vector<vector<bool> > mat = getMat(s);
        vector<int> dp(n+1, 0);
        for(int i = 0; i<= n; i++)
            dp[i] = i - 1;
        for(int i = 2; i <= n; i++)
        {
            for(int j = 0; j < i; j++)
            {
                if(mat[j][i - 1])
                    dp[i] = min(dp[i], dp[j] + 1);
            }
        }
        return dp[n];
    }