回文系列总结

回文系列题目，大致分为两种，一种是整数类型回文，一种是字符串类型回文。第二种较为常见。

1> 整数类型回文

题目

• Leetcode 9：判断一个整数是否是回文数。

方法1：整数转化为字符串，判断是否相等

    bool isPalindrome(int x) {
        string s = to_string(x);
        int i = 0, j = s.size() - 1;
        while(i < j)
        {
            if(s[i] != s[j])    return false;
            i++;    j--;
        }
        return true;
    }

方法2：反转一半整数，判断得到的一半整数与原数是否为相等或十倍关系

        if(x < 0 || (x % 10 == 0 && x != 0))  return false;
        int resverseNum = 0;
        while(x > resverseNum)
        {
            resverseNum = resverseNum * 10 + x % 10;
            x /= 10;
        }
        return resverseNum == x || x == resverseNum / 10;

2> 字符串类型回文之普通字符串

题目

• Leetcode 125 ：给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
• Leetcode 680 ：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

方法1：利用系统函数 reverse ，判断处理好的字符串。

   	//Code：125
    bool isPalindrome(string s) {
        string st;
        for(auto i : s) 
        {
            i = tolower(i);
            if(('a' <= i && i <= 'z') || ('0' <= i && i <= '9'))    st += i;
        }
        string t = st;
        reverse(st.begin(), st.end());
        return t == st;
    }

方法2：利用整数类型回文方法1，在循环中判断。

3> 字符串类型回文之回文子串

题目

• Leetcode 5 ： 给定一个字符串 s，找到 s 中最长的回文子串。
• Leetcode 132 ： 给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回符合要求的最少分割次数。
• Leetcode 647 ： 给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

方法1：中心扩展法
枚举所有的“中心”，包括以一个数为中心和以相邻的两个数为中心，线性扫描一遍字符串。

    //Code：647
    int countSubstrings(string s) {
        int n = 2 * s.size() - 1, ans = 0;
        for(int i = 0; i < n; i++)
        {
            int left = i / 2;
            int right = left + i % 2;
            while(left >= 0 && right < s.size() && s[left] == s[right])
            {
                left--;     right++;
                ans++;
            }
        }
        return ans;
    }

方法2：DP
f[ i ][ j ] 表示从 s[ i ] 到 s[ j ]是否为回文串
状态转移方程：

if(s[i] == s[j] && (j - i <= 2 || f[i+1][j-1]))		f[i][j] = true;

    //Code：647
    int countSubstrings(string s) {
        int n = s.size();
        vector<vector<bool>> f(n+1,vector<bool>(n));
        int ans = 0;
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<=n-1;j++)
            { 
                if(s[i] == s[j] && (j - i <= 2 || f[i+1][j-1]))
                {
                    f[i][j] = true;     ans++;
                }
            }
        }
        return ans;
    }

其中132题综合以上两种思想，运用DP，在指定范围内从后向前枚举分割点，并不断判断分割后的子串是否为回文串。

    //Code：132
    int minCut(string s) {
        int n = s.size();
        vector<int> f(n);
        vector<vector<bool>> dp(n+1,vector<bool>(n));
        //用空间换时间，用函数TLE
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if(s[i] == s[j] && (j - i <= 2 || dp[i+1][j-1]))     dp[i][j] = true;
            }
        }

        for(int i=0;i<n;i++)    f[i] = i;

        for(int i=0;i<n;i++)
        {
            if(dp[0][i])  
            {
                f[i] = 0;   continue;
            }
            for(int j=1;j<=i;j++)
            {
                if(dp[j][i])      f[i] = min(f[i], f[j-1] + 1);
            }
        }
        return f[n-1];
    }

4> 字符串类型回文之出现次数的奇偶性

题目

• Leetcode 409：给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。
• Leetcode 面试题01.04：给定一个字符串，编写一个函数判定其是否为某个回文串的排列之一。排列是指字母的重新排列。
• Leetcode 1400：给你一个字符串 s 和一个整数 k 。请你判断是否能用 s 字符串中 所有字符 构造 k 个非空 回文串 。

方法1：哈希表统计每种字符出现的次数，根据回文串的特点，以及哈希表中存储的值的奇偶性进行判断。

    //Code：409
    int longestPalindrome(string s) {
        unordered_map<char, int> hash;
        for(auto i : s)     hash[i]++;
        int ans = 0, flag = 0;
        for(auto h : hash)
        {
            ans += (h.second / 2) * 2;
            if(h.second & 1)   flag = 1;
        }
        return ans + flag;
    }

5> 字符串类型回文之回文子序列

题目

• Leetcode 516：给定一个字符串s，找到其中最长的回文子序列，并返回该序列的长度。
• Leetcode 1332：给你一个字符串 s，它仅由字母 ‘a’ 和 ‘b’ 组成。每一次删除操作都可以从 s 中删除一个回文子序列。返回删除给定字符串中所有字符（字符串为空）的最小删除次数。

方法1：DP
f[ i ][ j ]：s[i~j]之间的最长回文子序列长度
状态转移方程：

        if(s[i] == s[j])	f[i][j] = f[i+1][j-1];   
        else	f[i][j] = max(f[i][j-1], f[i+1][j]);   

    //Code：516
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        if(!n)  return 0;
        vector<vector<int>>f(n+1,vector<int>(n));
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if(i == j)  
                {
                    f[i][j] = 1;    continue;
                }
                if(s[i] == s[j])    f[i][j] = f[i+1][j-1] + 2;
                else    f[i][j] = max(f[i][j-1],f[i+1][j]);
            }
        }
        return f[0][n-1];
    }

状态压缩，一维数组

    int longestPalindromeSubseq(string s) {
        int n = s.size();
        if(!n)  return 0;
        vector<int> f(n,1);
        for(int i=n-1;i>=0;i--)
        {
           int pre = 0;
           for(int j=i+1;j<n;j++)
           {
               int tp = f[j];
               if(s[i] == s[j])     f[j] = pre + 2;
               else     f[j] = max(f[j], f[j-1]);
               pre = tp;  //tp存上一轮的 j-1
           } 
        }
        return f[n-1];
    }

6> 字符串类型回文之改动字符串

题目

• Leetcode 680 ：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
• Leetcode 1328 ：给你一个回文字符串，请你将其中 一个 字符用任意小写英文字母替换，使得结果字符串的字典序最小，且不是回文串。
• Leetcode 1332：给你一个字符串 s，它仅由字母 ‘a’ 和 ‘b’ 组成。每一次删除操作都可以从 s 中删除一个回文子序列。返回删除给定字符串中所有字符（字符串为空）的最小删除次数。

方法1：按照题目要求找到改动的位置，之后根据具体情况解答。

        //Code：1328
        int n = palindrome.size();
        if(n == 1)      return "";
        for(int i=0;i<n;i++)
        {
            if(palindrome[i] != 'a')
            {
                if(n & 1 && i == n / 2)     continue;
                palindrome[i] = 'a';
                return palindrome;
            }
        }
        palindrome[n-1] = 'b';
        return palindrome;
    }