【leetcode】5.最长回文子串【cpp】

题目：[leetcode]5. 最长回文子串
方法一：暴力求解，但是只能过47个测试用例，再往后会超时。

#include <algorithm>
#include <string>
#include <iostream>
using namespace std;
class Solution {
public:
    bool IsPalindromeStr(string s) {
            string tmp = s;
            reverse(s.begin(), s.end());        
            if(tmp == s) { 
            // 判断是否回文字符串，只需要反转一下字符串进行比较即可。是回文，会相等。    
                    return true;        
            } else {      
                  return false;
            }    
    }    
    string longestPalindrome(string s) {
            int len = s.length();        
            string res;        
            int i, j;        
            int max = 0;        
            for (i = 0; i < len; i++) {      
                  for (j = 1; j <= len - i; j++) {         
                         if (IsPalindromeStr(s.substr(i, j))) {             
                                if (j > max) {                  
                                      max = j > max ? j : max;                        
                                      res = s.substr(i, j);                  
                                 }               
                         }            
                 }       
            }       
            return res;   
    }
 };

方法二：两边扩展算法

class Solution {
public:
    string longestPalindrome(string s) {    
        if (s.length() == 0) {       
             return s;   
        }        
        int max = 1; // 保存回文串的最大长度，初始化为1        
        int start = 0; // 回文串的起始位置        
        int end = 0; // 回文串的结束位置        
        int len = s.length(); // 字符串的长度        
        for(int i = 0; i < len; i++) {            
            // 处理奇数情况，以i为中心，如果两边的字符相等，           
            // 说明扩展后的子串也是回文数，记录长度，与最大长度max比较，             
            // 如果大于max的长度，更新max和回文串的起始结束位置。            
            int l = i - 1;            
            int r = i + 1;            
            while (l >= 0 && r < len && s[l] == s[r]) {                
            	int currentLen = r - l + 1;                
            	if (currentLen > max) {                
            	    max = currentLen;                    
            	    start = l;                    
            	    end = r;                
            	}                
            	l--;                
            	r++;            
            }
            // 处理偶数情况，如果是相邻字符的相等，再向外扩展，更新max和起始结束位置            
            l = i;            
            r = i + 1;            
            while (l >= 0 && r < len && s[l] == s[r]) {                
            	int currentLen = r - l + 1;                
            	if (currentLen > max) {                    
            	    max = currentLen;                    
            	    start = l;                    
            	    end = r;               
            	}                
            	l--;                
            	r++;            
           }        
       }        
       return s.substr(start, max);    
   }
};

来源：CSDN

作者：tingsong_diary

链接：https://blog.csdn.net/qq_37871657/article/details/103652253