LintCode 解题记录 17.8.7 字符串处理3

LintCode Generate Parentheses

给定n对括号，写一个函数去产生所有符合要求的括号组合。
思路
递归+回溯。
如何判断一个序号组合序列是有效的呢？我最先想到的是堆栈。左括号就入栈，右括号就出栈(前提栈不为空)，如果空了就说明此时的组合不是合法的，就结束此次搜索。
还有一种简单的方法。针对从1~2n的序列，我们发现如下规则始终成立:左括号的个数大于等于右括号的个数。那么用两个指针leftNum和rightNum来表示左括号和右括号的余下的个数。如果leftNum > 0,那么此时添加一个左括号可以;如果 rightNum > leftNum && rightNum > 0，才可以添加一个右括号。如果leftNum=rightNum=0，说明搜索结束，此时产生的序列就是符合题意的。
代码

/**** version 1 ****/
    void dfs(vector<string> &res, string tmp, int cnt, stack<int> s, int n) {
        if (cnt == 2*n) {
            if (s.empty()) res.push_back(tmp);
            return;
        }
        for (int i = 0; i < 2; i++) {
            if (i == 0) {
                s.push(cnt);
                dfs(res, tmp + '(', cnt+1, s, n);
                s.pop();
            } else {
                if (s.empty()) break;
                s.pop();
                dfs(res, tmp + ')', cnt+1, s, n);
                s.push(cnt);
            }
        }
    }
    vector<string> generateParenthesis(int n) {
        // Write your code here
        vector<string> res;
        stack<int> s;
        string tmp = "";
        dfs(res, tmp, 0, s, n);
        return res;
    }

  /**** version 2 **** better version ****/
      vector<string> generateParenthesis(int n) {
        // Write your code here
        int leftNum, rightNum;
        leftNum = rightNum = n;
        vector<string> res;
        string tmp = "";
        generate(res, tmp, leftNum, rightNum);
        return res;
    }

    void generate(vector<string> &res, string tmp, int leftNum, int rightNum) {
        if (leftNum == 0 && rightNum == 0) {
            res.push_back(tmp);
            return;
        }
        if (leftNum > 0) {
            generate(res, tmp+'(', leftNum-1, rightNum);
        }
        if (rightNum > leftNum) {
            generate(res, tmp+')', leftNum, rightNum-1);
        }
    }

LintCode Integer to Roman

把一个数字转成罗马数字的写法。该数字大小不会超过3999。
思路
弄清楚罗马数字的写法，这题就很简单了。
代码

    string intToRoman(int n) {
        // Write your code here
        char c1[][5] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
        char c2[][5] = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
        char c3[][5] = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
        char c4[][5] = {"M", "MM", "MMM"};
        string res = "";
        int cnt = 0;
        while (n) {
            if (n >= 1000) {
                res += c4[n/1000-1];
                n %= 1000;
            } else if (n >= 100) {
                res += c3[n/100-1];
                n %= 100;
            } else if (n >= 10) {
                res += c2[n/10-1];
                n %= 10;
            } else if (n >= 1) {
                res += c1[n-1];
                break;
            }
        }
        return res;
    }

LintCode Letter Combinations of a Phone Number

给定一个数字序列(不包含01)，问你可以翻译成多少种字母组合。数字和字母的映射关系就是九宫格输入法。
思路
dfs
代码

    const vector<string> num2letter{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", 
        "tuv", "wxyz"};

    vector<string> letterCombinations(string& digits) {
        // Write your code here

        vector<string> res;
        string tmp = "";
        int n = digits.size();
        if (n) dfs(res, tmp, 0, digits, n);
        return res;
    }

    void dfs(vector<string> &res, string tmp, int idx, string digits, int n) {
        if (idx == n) {
            res.push_back(tmp);
            return;
        }
        int curr = digits[idx] - '0';
        for (int i = 0; i < num2letter[curr].size(); i++) {
            tmp += num2letter[curr][i];
            dfs(res, tmp, idx+1, digits, n);
            tmp.pop_back();
        }
    }

LintCode Longest Common Prefix

求k个字符串的最长公共前缀
思路
直接暴力搜索就可以。因为LCP一定是每一个字符串的子串。所以就可以选取某一字符串，逐个比较其字符和剩下所有字符串的字符是否相等，相等就跳到下一个字符，如果不相等或者发现一个长度更小的字符串，就返回当前结果。
其实我做的时候我最先想到了Merge K Sorted List这道题，于是也把这道题往这方面想了，当然也能做出来，算是又温习了一下这种问题的分治方法吧。
代码

    string longestCommonPrefix(vector<string> &strs) {
        // write your code here
        if (strs.size() == 0) return "";
        string res = "";
        res = findPrefix(strs, 0, strs.size()-1);
        return res;
    }

    string findPrefix(vector<string> &strs, int l, int r) {
        if (l == r) return strs[l];
        int mid = (l+r) >> 1;
        string pre1 = findPrefix(strs, l, mid);
        string pre2 = findPrefix(strs, mid+1, r);
        string res = findTwoPrefix(pre1, pre2);
        return res;
    }

    string findTwoPrefix(string str1, string str2) {
        string ret = "";
        for (int i = 0; i < min(str1.size(), str2.size()); i++) {
            if (str1[i] == str2[i]) ret += str1[i];
            else break;
        }
        return ret;
    }

LintCode Longest Common Substring

求两个字符串的最长公共子串。同理最长公共子序列。
正如题中提到了substring differs with subsequences.
思路
动态规划来解决。我们考虑状态dp[i][j]来表示字符串1的前i个字符和字符串2的前j个字符的最长公共子串(包含第i个字符和第j个字符)。其实这道题的思路有点像最大子序列和。接下来考虑str1[i-1]和str2[j-1]，如果str1[i-1]==str2[j-1],那么dp[i][j] = dp[i-1][j-1]+1,如果不相等那么dp[i][j] = 0。然后我们只要在这个过称中寻找到dp[i][j]的最大值即可。
代码

int longestCommonSubstring(string &A, string &B) {
    // write your code here
    int m = A.size(), n = B.size();
    vector<vector<int> > local(m + 1, vector<int>(n + 1, 0));
    int maxx = 0;
    for (int i = 1; i < m + 1; i++) {
        for (int j = 1; j < n + 1; j++) {
            local[i][j] = A[i - 1] == B[j - 1] ? local[i - 1][j - 1] + 1 : 0;
            maxx = max(maxx, local[i][j]);
        }
    }
    return maxx;
}

同理，我们也来研究一下最大子序列的问题。这道题仍然是动态规划，我们用dp[i][j]来表示字符串1的前i位和字符串2的前j位的最大子序列长度。同样考虑str1[i-1]是否和str2[j-1]相等。如果相等，那么分别加上这一位一定形成了更长的子序列，所以此时dp[i][j] = dp[i-1][j-1]+1。如果不想等，那么思考从哪几个子状态中可以一步跳转到该状态呢？于是我们得到如下递推 dp[i][j] = max(dp[i-1][j], dp[i][j-1]);

LintCode Longest Palindromic Substring

求给定字符串的最长回文子串
思路
O(n2)的方法
从回文串的中心向两边遍历来寻找最长回文串，注意回文串有偶数长度的也有奇数长度的。所以对于每一位都要考虑这个因素。
代码

    string longestPalindrome(string s) {
        // write your code here
        if (s.size() == 0) return "";
        int l = 0, r = 0;
        int startIdx = 0, len = 0;
        for (int i = 0; i < s.size(); i++) {
            if (i < s.size()-1 && s[i] == s[i+1]) { //偶数长度
                l = i;
                r = i+1;
                SearchPalindrome(s, l, r, startIdx, len);
            }
            l = r = i; //奇数长度
            SearchPalindrome(s, l, r, startIdx, len);
        }
        return s.substr(startIdx, len);
    }
    void SearchPalindrome(string s, int left, int right, int &startIdx, int &len) {
        int step = 1;
        bool tag = true;
        while (left-step >= 0 && right+step < s.size()) {
            if (s[left-step] == s[right+step]) {
                step++;
            } else {
                tag = false;
                if (right-left+2*step-1 > len) {
                    len = right-left+2*step-1;
                    startIdx = left-step+1;
                }
                break;
            }
        }
        if (tag) {
                if (right-left+2*step-1 > len) {
                    len = right-left+2*step-1;
                    startIdx = left-step+1;
                }
        }
    }

思路2
此题也可以用动态规划的方法来解决。维护变量dp[i][j]表示字符串从i到j之间是否为回文串。那么如果i == j，意思就是单个字符，肯定是回文串。如果i和j之间相差为1，意思就是两个字符，就判断这两个字符是否相等来决定是否为回文串。如果i和j之间相差为2，那么dp[i][j] = dp[i+1][j-1] && s[i] == s[j]。
代码就不写了，提及此思路的原因就是想多跟动态规划套套近乎:D

思路3
O(n)的解法，是马拉车算法Manachers’ Algorithm。
算法介绍参考博客 :http://www.cnblogs.com/grandyang/p/4475985.html
代码

    string longestPalindrome(string s) {
        string t ="$#";
        for (int i = 0; i < s.size(); ++i) {
            t += s[i];
            t += '#';
        }
        int p[t.size()] = {0}, id = 0, mx = 0, resId = 0, resMx = 0;
        for (int i = 0; i < t.size(); ++i) {
            p[i] = mx > i ? min(p[2 * id - i], mx - i) : 1;
            while (t[i + p[i]] == t[i - p[i]]) ++p[i];
            if (mx < i + p[i]) {
                mx = i + p[i];
                id = i;
            }
            if (resMx < p[i]) {
                resMx = p[i];
                resId = i;
            }
        }
        return s.substr((resId - resMx) / 2, resMx - 1);
    }
};