Leetcode | Palindrome

Valid Palindrome

Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

For example,
"A man, a plan, a canal: Panama" is a palindrome.
"race a car" is not a palindrome.

Note:
Have you consider that the string might be empty? This is a good question to ask during an interview.

For the purpose of this problem, we define empty string as valid palindrome.

处理好大小写转换、非法字符忽略就可以。

class Solution {
public:
    
    bool isPalindrome(string s) {
        if (s.empty()) return true;
        int l = 0, r = s.length() - 1;
        char c1, c2;
        while (r > l) {
            while (true) {
                if (l >= r) break;
                if (s[l] >= 'a' && s[l] <= 'z') break;
                if (s[l] >= 'A' && s[l] <= 'Z') { s[l] += 32; break; }
                if (s[l] >= '0' && s[l] <= '9') break;
                l++;
            }
            
            while (true) {
                if (l >= r) break;
                if (s[r] >= 'a' && s[r] <= 'z') break;
                if (s[r] >= 'A' && s[r] <= 'Z') { s[r] += 32; break; }
                if (s[r] >= '0' && s[r] <= '9') break;
                r--;
            }
            
            if (s[l] != s[r]) return false;
            l++; r--;
        }
        
        return true;
    }
};

这样写好一点。

class Solution {
public:
    bool isDigit(char c) {
        return (c >= '0' && c <= '9');
    }
    
    bool isUppercase(char c) {
        return (c >= 'A' && c <= 'Z');
    }
    
    bool isLowercase(char c) {
        return (c >= 'a' && c <= 'z');
    }
    
    bool isValid(char c) {
        return (isLowercase(c) || isDigit(c) || isUppercase(c));
    }
    
    bool isPalindrome(string s) {
        if (s.empty()) return true;
        int n = s.length();
        for (int i = 0, j = n - 1; i < j; ) {
            for (; i < j && !isValid(s[i]); i++);
            for (; i < j && !isValid(s[j]); j--);
            if (isUppercase(s[i])) s[i] += 32;
            if (isUppercase(s[j])) s[j] += 32;
            if (s[i] != s[j]) return false;
            i++, j--;        
        }
        return true;
    }
};

 

Palindrome Partitioning

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = "aab",
Return

[
["aa","b"],
["a","a","b"]
]

回溯法就可以了。

class Solution {
public:
    
    bool isPalindrome(string &s) {
        int n = s.length();
        if (n <= 1) return true;
        int l = 0, r = n - 1;
        while (r > l) {
            if (s[l] != s[r]) return false;
            r--; l++;
        }
        return true;
    }
    
    vector<vector<string>> partition(string s) {
        vector<vector<string>> rets;
        
        vector<string> ret;
        bt(s, 0, ret, rets);
        
        return rets;
    }
    
    void bt(string &s, int index, vector<string> &ret, vector<vector<string>> &rets) {
        if (index >= s.length()) {
            rets.push_back(ret);
            return;
        }
        
        for (int i = index; i < s.length(); ++i) {
            string tmp(s.substr(index, i - index + 1));
            if (isPalindrome(tmp)) {
                ret.push_back(tmp);
                bt(s, i + 1, ret, rets);
                ret.pop_back();
            }
        }
    }
};

Palindrome Partitioning II

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

For example, given s = "aab",
Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.

这里主要有两层需要dp的。

1. 令p[i][j]为i到j之间需要的最小cut个数。我们要求的是p[0][n - 1]。第一个dp很简单，p[i][n - 1] = min{p[j+1][n-1]} + 1， 其中i<=j<n，s(i, j)是回文。

2. 判断回文其实也是一个dp的过程，不过每次都用循环。如果s(i, j)是回文，则p[i][j]=0。p[i][j] = 0 当且仅当str[i]== str[j] && p[i + 1][j - 1]=0。没有这一部分dp就会TLE了。这一步骤用递归就可以，注意的是，比较后要设置p[i][j]，无论是否等于0.

class Solution {
public:
    bool isPalindrome(string &s, int l, int r, vector<vector<int> > &p) {
        if (l > r) return true;
        if (p[l][r] == 0) return true;
        if (p[l][r] != -1) return false;
        if (s[l] != s[r]) return false;
        
        bool isPalin = isPalindrome(s, l + 1, r - 1, p);
        if (isPalin) {
            p[l][r] = 0;
        } else {
            p[l][r] = r - l;
        }
        return isPalin;
    }
    
    int minCut(string s) {
        int n = s.length();
        if (n <= 1) return 0;
        vector<vector<int> > p(n, vector<int>(n, -1));
        for (int i = 0; i < n; ++i) {
            p[i][i] = 0;
        }
        for (int i = n - 2; i >= 0; --i) {
            p[i][n - 1] = n - i - 1;
            for (int j = i; j < n; ++j) {
                if (s[j] == s[i] && isPalindrome(s, i + 1, j - 1, p)) {
                    p[i][j] = 0;
                    
                    if (j < n - 1 && p[j + 1][n - 1] + 1 < p[i][n - 1]) {
                        p[i][n - 1] = p[j + 1][n - 1] + 1;
                    }
                }
            }
        }
        
        return p[0][n - 1];
    }
};

 第三次写，用了两个数组。不过思路也算简单了。

class Solution {
public:
    int minCut(string s) {
        if (s.empty()) return 0;
        int n = s.length();
        vector<vector<bool> > dp(n, vector<bool>(n, false));
        vector<int> min(n, 0);
        for (int i = 1; i < n; ++i) {
            dp[i][i] = true;
            min[i] = min[i - 1] + 1;
            for (int j = i - 1; j >= 0; --j) {
                if ((j > i - 2 || dp[j + 1][i - 1]) && s[i] == s[j]) {
                    dp[j][i] = true;
                    if (j == 0) min[i] = 0;
                    else if (min[j - 1] + 1 < min[i]) min[i] = min[j - 1] + 1;
                }
            }
        }
        return min[n - 1];
    }
};

空间上比起用vector<vector<int> >还是省了。因为用bool的话，最终用了O(n^2+n)，用int虽然看起来只用了一个变量，但是却是O(4n^2)。