算法-回文分割问题

回文分割问题

动归四角度：

1.状态定义F（i）：字符串s的前i个字符的最小分割次数；

2.状态间的转移方程定义：F（i）=min（F（i），F（j）+1），0 <= j < i,且F（j）为已知状态，当[j+1,i]为回文串时，执行此状态转移方程

3.状态的初始化：F（i） = i-1，注意F（0）为-1；

例如，当字符串为"aa"，因为[1,2]为回文串，F（2）= min（F（2），F（0）+1）=min（1，0）= 0，得到正确答案

4.返回结果 ：F（s.length())；

import java.util.*;
public class Solution {
    //判断是否为回文串
    public boolean func(String s,int start,int end) {
        while(start<end) {
            if(s.charAt(start)!=s.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
    public int minCut (String s) {
        int len = s.length();//字符串的长度
        if(len == 0) return 0;//当长度为0时直接返回0
        int[] count = new int[len + 1];//用于记录状态
        //状态初始化
        for(int i = 0;i <= len;i ++) {
            count[i] = i-1;
        }
        for(int i = 1;i <= len;i++) {
            for(int j = 0;j <= i-1;j++) {
                if(func(s,j,i-1)) {
                    count[i] = Math.min(count[i],count[j]+1);//状态转移方程
                }
            }
        }
        return count[len];//返回结果
    }
}

状态四角度：

1.状态定义F（i，j）：字符区间[i,j]是否为回文串

2.状态间的转移方程定义F（i，j）：

如果i == j，表示单字符，F（i，j） = true；

如果j == i+1，表明俩字符是紧挨着的，如果在总字符串s中对应的字符相同，F（i，j）= true，反之F（i，j） = false；

其他的情况中，F（i，j） = (s.charAt(i) == s.charAt(j)) && F（i+1，j-1）；
该转移方程的意思为字符首尾字符相同，且去掉字符区间的首位字符后的字符区间的状态F（i+1，j-1）仍然为回文串才证明[i,j]字符串区间为回文串即F（i，j）= true

3.状态的初始化：F（i，j） = false

4.返回结果状态二维布尔类型数组

注：由于在状态转移的过程中，求F（i，j）会只用到之前已经计算过的状态F（i+1，j-1），这就意味着i需要从后向前遍历，使用的是已经更新过结果的值

解法2：

class Solution {
    public int minCut(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int[] minCut = new int[s.length() + 1];
        //初始化
        for (int i = 0; i <= s.length(); i++) {
            minCut[i] = i - 1;
        }
        //boolean[][] pali = new boolean[s.length()][s.length()];
        //回文
        boolean[][] pali  = assignPali(s);
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 0; j < i; j++) {
                if (pali[j][i - 1]) {
                    minCut[i] = Math.min(minCut[j] + 1, minCut[i]);
                }
            }
        }
        return minCut[s.length()];
    }
    
    
    /***回文判断
    public void assignPali(boolean[][] pali, String s) {
        int length = s.length();
        for (int i = 0; i < length; i++) {
            pali[i][i] = true;
        }
        for (int i = 0; i < length - 1; i++) {
            pali[i][i + 1] = (s.charAt(i) == s.charAt(i + 1));
        }
        for (int i = 2; i < length; i++) {
            for (int j = 0; j + i < length; j++) {
                pali[j][i + j] = pali[j + 1][i + j - 1] && s.charAt(j) == s.charAt(i + j);
            }
        }
    }***/


       //判断是否为回文串
    public boolean[][] assignPali(String s) {
        int len = s.length();//字符串的长度
        boolean[][] ret = new boolean[len][len];
        //记录状态的二维数组，默认值为false
        //由于i<=j<len,所以ret数组实际只更新了一半
        for(int i = len;i >= 0;i--) {
            for(int j = i;j<len;j++) {
                if(i == j) {
                    ret[i][j] = true; //单字符比为回文串
                }else if(j == i+1) {
                    if(s.charAt(i) == s.charAt(j)) {
                        ret[i][j] = true; //相邻字符相同为回文串
                    }else{
                        ret[i][j] = false;//相邻字符不同就不是回文串
                    }
                }else{
                    ret[i][j] = (s.charAt(i) == s.charAt(j)) && ret[i+1][j-1];
                    //其余转移情况
                }
            }
        }
        return ret;//返回结果
    }
}