leetcode005（暴力解法+动态规划法）

//最慢：找到每个字符为起始的所有回文串，并保存最长的（算法上难以实现？假设取第一个字符，那么必须判断到1/2长度之后，才能确定有无回文串）
//效率太低

//能否考虑按照特定字符作为起始，来找回文串
//假设第一个字符为a，从字符串末尾找另一个a，并判断夹在中间的是不是回文串；
//若不是，继续向前找下一个a，再次判断；
//若是，则该回文串是以a作为首位的最长串
//
//
//如何判断一个字符串是不是回文串
//最慢：对撞指针逐个字符判断
//其他方法？？

//判断是不是回文串之前，可以先算一下字符串长度和当前记录的最大长度，若是小于，则直接跳过

//时间复杂度太高，考虑剪枝方法

//优化1：截取的字符串与目前最长回文串比较，长度小于，则直接跳过
//优化2:
class Solution {
public:
	string longestPalindrome(string s) {
		int i, j;
		int len = s.length();
		char start, end;
		string temp, result, record;
		for (i = 0; i<len; i++)
		{
			start = s[i];
            for (j = (len - 1); j>=i; j--)
			{
				end = s[j];
				if (start == end)
				{
					temp = s.substr(i, j - i + 1);
                    
                    if(j-i+1<=result.length()) break;  //优化1
                    
					if (huiwen(temp) == true)
					{
						if (j - i + 1>result.length()) result = temp;
					}
				}
			}
		}
        return result;
	}
    bool huiwen(string S){
        int i,j;
        int len=S.length();
        for(i=0;i<(len/2);i++)
        {
            if(S[i]!=S[len-1-i]) return false;
        }
        return true;
    }
};

//动态规划法，二维数组元素dp[i][j]代表从i到j是否是回文串（true、false）
//dp[i][i]=true，因为单独的字符一定是回文串
//dp[i][j]如何判断，根据动态规划的思想，需要由其子问题的解来得到
//当是双字符的字符串时，只要满足s[i]==s[j]即可，双字符串的判断条件是j-i=1
//当是三个或以上的字符串时，只需要满足1）s[i]==s[j]  2）dp[i+1][j-1]=true即可
//两种情况的判断可以用||和&&合并

class Solution {
public:
    string longestPalindrome(string s) {
        int i,j,k,len=s.length(),max=0;
        //创建二维向量dp[len][len]
        vector<vector<bool>> dp(len); 
        for (i = 0; i < dp.size(); i++)    
            dp[i].resize(len);  
        //标志位用于记录回文串首位
        int  left=0,right=0;
        //
        for (i = 0; i < len; i++) dp[i][i] = true;
        for(k=1;k<len;k++)
        {
            for(i=0;i<len-k;i++)
            {
                if((s[i]==s[i+k])&&((k==1)||dp[i+1][i+k-1]))  
                {
                    dp[i][i+k]=true;
                    if(k+1>max) 
                    {
                        max=k+1;
                        right=i+k;
                        left=i;
                    }
                }
            }
        }
        cout<<left<<" "<<right<<endl;
        return s.substr(left,right-left+1);      
    }
};