leetcode 5—— Longest Palindromic Substring

         这道题是求字符串中的最长回文字符串。

      回文字符串就是从前面读与从后往前读是一样的。

      一看到题目，我就开始想，既然这样，那我就从前往后扫描字符串，既然回文，那肯定头尾一样，我找到一头一尾，根据头尾的位置，然后判断剩余的部分，从头往后，从尾往前，再一个个判断。

      因此，代码如下：

      

string longestPalindrome(string s)
{
	bool signal = false;
	int len = s.length();
	int result = 0;
	int pos1 = 0;
	int pos2 = 0;
	if (len == 1)
		return s;
	for (int i = 0; i < len; i++)
	{
		int curValue = int(s[i]);
		for (int j = i + 1; j < len; j++)///往后扫描
		{
			int nextValue = int(s[j]);
			if (nextValue - curValue == 0)
			{
				//cout << "enter" << endl;
				int mediumNum = j - i - 1;
				
				int checkTime = 0;
				if (mediumNum == 0)
				{
					signal = true;
					checkTime = 0;
				}
					
				else
				{
					checkTime = mediumNum == 1 ? 1 : mediumNum / 2;
				}
				//针对这两个位置，判断两个位置中间的地方
				int forePos = i;
				int backpos = j;
				
				for (int k = 0; k < checkTime; k++)
				{
					if (s[++forePos] == s[--backpos])
						signal = true;
					else
					{
						signal = false;
						break;
					}
				}
				if (signal == true)
				{
					int beforeValue = result;
					result = max(j - i + 1, result);
					if (result > beforeValue)
					{
						pos1 = i;
						pos2 = j;
					}
					
				}
			}
			else continue;			 
		}
	}
	cout << "pos1 = " << pos1 << endl;
	cout << "result = " << result << endl;
	if (result > 0)
	{
		string resultString(s, pos1, result);
		return resultString;
	}
	else return string(s,0,1);
	
}

         这个方法后面提交的时候，再测试超长字符串的时候显示超时了！-_-

         

       有什么办法可以降级时间复杂度？？？一脸懵逼....

       最后看了disscuss，别人是真厉害阿，短短十几行，还跑得飞快。同样的超长字符串，别人代码瞬间就出来了，我的就要等十几秒-_-！！！

       既然自己想不出好方法，就学习别人的啦。

       下面是大神的代码：

        

string method3(string s) 
{
	//总的来说，这种方法就是在某个位置，前后扩散找
	if (s.empty()) return "";
	if (s.size() == 1) return s;
	int min_start = 0, max_len = 1;
	for (int i = 0; i < s.size();) 
	{
		//如果剩下的没判断的字符串的长度还没有已经找到的回文字符串长，那剩下的里面肯定不会出现更好的结果了，所以直接break
		if (s.size() - i <= max_len / 2) break;
		int j = i;
		int k = i;
		while (k < s.size() - 1 && s[k + 1] == s[k]) 
			++k;  
		i = k + 1;
		while (k < s.size() - 1 && j > 0 && s[k + 1] == s[j - 1]) 
		{ 
			//扩散
			++k; 
			--j; 
		} 
		//计算回文字符串的长度
		int new_len = k - j + 1;
		if (new_len > max_len) 
		{ 
			min_start = j; 
			max_len = new_len; 
		}
	}
	return s.substr(min_start, max_len);
}

      这样一看好像这个方法原理也不复杂阿，，，阿，真实智商堪忧，为啥我想不到-_-。