LeetCode Palindrome Partitioning I&&Palindrome Partitioning II

问题一就是一个搜索，问你有多少种分割单词的分法，分出来的每个部分都是回文，首先要用数据isdc[i][j]来记录i位置到j位置的串是不是回文，其他没啥好说的，记得递归下一层回来的时候记得把下一层的状态回复到当前层即可。直接贴代码：

int isdc[1001][1001];
vector< vector<string> > ans;
int n;
string tmp;
vector<string>cl;
class Solution {
public:
    void dfs(string s,int st)
    {
        int i,j;
        if(st>n-1)
        {
            ans.push_back(cl);
            return ;
        }
        for(i=st;i<n;i++)
        {
            if(isdc[st][i]==1)
            {
                tmp="";
                for(j=st;j<=i;j++)
                    tmp+=s[j];
                cl.push_back(tmp);
                dfs(s,i+1);
                cl.pop_back();
            }
        }
        return ;
    }
    vector<vector<string> > partition(string s) {
        int i,j,l;
        n=s.size();
        if(n==0)
            return ans;
        cl.clear();
        ans.clear();
		for(i=0;i<n;i++)
		{		
			for(j=i;j<n;j++)
			{
				if(i==j)
					isdc[i][j]=1;
				else if(i+1==j)
				{
					if(s[i]==s[j])
						isdc[i][j]=1;
					else
						isdc[i][j]=0;
				}
				else
					isdc[i][j]=0;
			}
		}
		
		for(i=1;i<n-1;i++)
			for(l=1;i-l>=0&&i+l<=n-1;l++)
			{
				if(isdc[i-l+1][i+l-1]==1)
				{
					if(s[i-l]==s[i+l])
						isdc[i-l][i+l]=1;
				}
				else
					isdc[i-l][i+l]=0;
			}
		for(i=0;i<n-1;i++)
		{
			for(l=1;i-l>=0&&i+l<=n-1;l++)
			{
				if(isdc[i-l+1][i+l]==1)
				{
					if(s[i-l]==s[i+1+l])
						isdc[i-l][i+l+1]=1;
				}
				else
					isdc[i-l][i+l+1]=0;
			}
		}
        dfs(s,0);
        return ans;
    }
};

一看到问题2马上有一个类似矩阵连乘dp的思想，dp[i][j]表示第i个字符到第j个字符可以分的最少回文串数，那么有dp[i][j]=min(dp[i][k],dp[k+1][j])，k=[i,j-1]，如果i到j不是回文；dp[i][j]=1，如果i到j是回文。计算这样的dp数组需要的时间复杂度是O(n^3),交上去超时。

后来想其实这个问题和矩阵连乘还是有一些不同的，如果方程是dp[i][j]=min(dp[i][k],dp[k+1][j])，那么会发现对于回文这个问题，其实很多状态是一样的，例如abc三段分别是回文，而且他是整个字符的最优解，那么对于矩阵连乘思想而言，abc可以由状态(ab)c和a(bc)得到,对于回文来说，(ab)c和a(bc)是同一个解，其实只需要用(ab)c就可以得到这个最优解了，从a(bc)的枚举是没有必要的。而对于矩阵连乘而言(ab)c和a(bc)并不是同一种解，或者这样说，abc如果是最优的话，那么对于回文问题来说，ab一定是最优的，而对于矩阵连乘问题来说，ab不一定是最优的，可能是bc最优转移过来，所以有了另一种dp想法。

dp[i]表示从第0个到第i个字符能分出的最少回文串数，那么有dp[i]=min(dp[j])+1,j=[0...i-1]。1表示一个回文串，其实能发现，dp[i]肯定可以由一个dp[j]和一个回文串转移过来，只要找到这个最小的dp[j]，那么dp[i]的结果就出来，

代码如下：

int dp[5001];
int isdc[5001][5001];
class Solution {
public:
    int minCut(string s) {
    	int i,j,k,l;
    	int n=s.size();
		for(i=0;i<n;i++)
		{		
			for(j=i;j<n;j++)
			{
				if(i==j)
					isdc[i][j]=1;
				else if(i+1==j)
				{
					if(s[i]==s[j])
						isdc[i][j]=1;
					else 
						isdc[i][j]=0;
				}
				else
					isdc[i][j]=0;
			}
			dp[i]=i+1;
		}
		
		for(i=1;i<n-1;i++)
			for(l=1;i-l>=0&&i+l<=n-1;l++)
			{
				if(isdc[i-l+1][i+l-1]==1)
				{
					if(s[i-l]==s[i+l])
						isdc[i-l][i+l]=1;
				}
				else 
					isdc[i-l][i+l]=0;
			}
		for(i=0;i<n-1;i++)
		{
			for(l=1;i-l>=0&&i+l<=n-1;l++)
			{
				if(isdc[i-l+1][i+l]==1)
				{
					if(s[i-l]==s[i+1+l])
						isdc[i-l][i+l+1]=1;
				}
				else  
					isdc[i-l][i+l+1]=0;
			}
		}
       	for(i=1;i<n;i++)
       	{
	       	if(isdc[0][i]==1)
	       	{
	       		dp[i]=1;
	       		continue;
	       	}
	    	for(j=i;j>=0;j--)
       		{	
			   if(isdc[j+1][i]==1)
       			{
		    		if(dp[i]>dp[j]+1)
						dp[i]=dp[j]+1;   	
	       		}
       		}
       	}
       	return dp[n-1]-1;
    }
};