Palindrome Partitioning II

首先想到的是，应该是一种DP算法，同时还有剪枝操作，但是我没怎么学过动态规划，所以最终的结果是超时了。

想法很简单，就是逐步分成一个个的小问题，小问题是，该字符段是回文，如果不是则划分更小的字符串进行操作。这个想法可能太局限于我遇到的第一个问题，Palindrome Partitioning ，在该问题中，我是这么解决的，所以自然而然的想到用这个方法。但是这个方法不好，结果是Time Limited

class Solution {
private:
	int min;
public:
    int minCut(string s) {
		min = s.size();
		vector<string> path;
		string temp = "";
		ispali(path,temp,s);
		return min-1;
    }
	void ispali(vector<string>path,string str,string s){
		if(path.size()>min){
			return;
		}
		if(str.length()>0){
			path.push_back(str);
		}
		int length = s.length();
		for(int i = 0;i<s.length();){
			if(i+length-1<s.length()){
				if(pali(s.substr(i,length))){
					if(i+length >= s.length()){
						path.push_back(s.substr(i,length));
						if(path.size()<min){
							min  =path.size();
						}
						break;
					}
					else{
						ispali(path,s.substr(i,length),s.substr(i+length,s.length()-i-length));
					}
				}
				length--;
				if(length<=0||path.size()>min){
					break;
				}
			}
		}
	}
	bool pali(string s){
		if(s.length()==1){
			return true;
		}
		for(int i=0;i<s.length()/2;i++){
			if(s[i]!=s[s.length()-1-i]){
				return false;
			}
		}
		return true;
	}
};

第二种方法，是最近看了算法导论，动态规划一章，尝试用这类方法写的一个，可能我定义的子问题以及中间迭代不好，最终也是超时，不过这是第一次自己尝试写动态规划问题的解法，所以也自己贴给自己看。

递归公式

f(i,j)=0,i=j;f(i,j)=min(f(i,k)+f(k+1,j)+1),j>i;

int minCut(string s) {
		int **min = new int*[s.length()];
		int i,j;
		for(i = 0;i<s.length();i++){
			min[i] = new int[s.length()];
		}
		for(i = 0;i<s.length();i++){
			for(j=0;j<s.length();j++){
				min[i][j]=abs(j-i);
			}
		}
		for(i = 2;i<=s.length();i++){
			for(j = 0;j<=s.length()-i;j++){
				if(s[j]==s[j+i-1]&&min[j+1][j+i-2]==0){
					min[j][j+i-1] = 0;
					break;
				}
				if(isparli(s.substr(j,i))){
					min[j][j+i-1] = 0;//从j到j+i-1的字符串是回文
					continue;
				}
				for(int k = 1;k<i;k++){
					if(min[j][j+i-1]>min[j][j+k-1]+min[j+k][j+i-1]+1){
						min[j][j+i-1]=min[j][j+k-1]+min[j+k][j+i-1]+1;
						printf("%d,%d\n",min[j][j+k-1],min[j+k][j+i-1]);
					}
				}
			}
		}
		int ret = min[0][s.length()-1];
		for(i = 0;i<s.length();i++){
			delete min[i];
		}
		delete min;
		return ret;
    }
	bool isparli(string s){
		for(int i = 0;i<s.length()/2;i++){
			if(s[i]!=s[s.length()-i-1]){
				return false;
			}
		}
		return true;
	}

下面这个方法是转自“”

其实和我第二个想的，一样，但是子问题不一样，他的这个是简化了的。很好，看来动态规划，我还需要好好练一下

int minCut(string s) {
		/*
		用一个数组p[i][j]表示，i,j是否是回文.
		f(i)表示，i到len所需要的mincut，返回f(0),子问题是，i+1到len之间的mincut数，是一个有用的信息，而我们所需要做的就是在
		添加上一个第i个字符，然后计算i到len之间的mincut数，将i和len之间所有的j遍历，查看i到j，和（f(j+1)）j+1到mincut的所有最小值。
		f(i) = min(f(i),f(j+1)+1),len>j>=i，且p(i,j)为回文,遍历i和len之间的所有j
		
		*/
		int len = s.length();
		int i,j;
		int *Min = new int[len+1];
		for(i = 0; i <= len; i++)   
            Min[i] = len-i;  //从后往前定义mincut
		bool ** P = new bool*[len];//表示i,j之间是否是回文
		
		for(i=0;i<len;i++){
			P[i] = new bool[len];
			for(j=0;j<len;j++){
				P[i][j] = false;
			}
		}
		for(i = len-1;i>=0;i--){
			for(j = i;j<len;j++){
				if(s[i]==s[j]&&(j-i<2||P[i+1][j-1])){
					P[i][j]=true;
					Min[i] = min(Min[i],Min[j+1]+1);
				}
			}
		}
		int ret = Min[0]-1;
		for(i=0;i<len;i++){
			delete P[i];
		}
		delete Min;
		delete P;
		return ret;
    }