LintCode 解题记录 字符串处理1.0 17.7.29

Before: 按照难度做的
————————-Easy———————————

LintCode Add Binary

二进制求和。给定两个用字符串表示的二进制序列，求其和序列，同样以字符串表示。
1.思路
按照加法的规则来，从两个字符串的末尾(相当于最低位)开始加，维护进位位，把每次得到的结果顺序加在结果字符串上，最后利用reverse函数将结果字符串颠倒即为正确答案。
2.注意
要注意判断最高位是否有进位
3.代码

    string addBinary(string& a, string& b) {
        // Write your code here
        string res;
        if (a.size() < b.size()) swap(a, b); //确保a是较长的那个字符串
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
        int i =  0;
        int c = 0, sum = 0;
        for (; i < b.size(); i++) {
            sum = (a[i]-'0') + (b[i]-'0') + c;
            c = sum / 2;
            sum %= 2;
            res += sum + '0';
        }
        while (i < a.size()) {
            sum = (a[i++]-'0') + c;
            c = sum / 2;
            sum %= 2;
            res += sum + '0';
        }
        if (c) res += c + '0'; //判断最终的进位位
        reverse(res.begin(), res.end());
        return res;
    }

LintCode Compare String

比较字符串A和B，判断是不是A包含B
思路
典型的hash应用。用hash数组存储字符串A中字符出现的次数，先遍历一遍A更新hash，然后再遍历B，每遍历到一次字符其相应的hash值就减1。如果发现其hash值小于0，就说明A不包含B，返回false。
代码

    bool compareStrings(string A, string B) {
        // write your code here
        unordered_map<char, int> hash;
        for (auto c: A) {
            hash[c]++;
        }
        for (auto c: B) {
            hash[c]--;
            if (hash[c] < 0) return false;
        }
        return true;
    }

LintCode Count and Say

对于一个字符串表示的数字序列”122123”,出现了一次1，即”11”，然后出现两次2，即”22”,接着一次1，一次2，一次3,即”111213”，得到下一个字符串是”1122111213”。再对新字符按照上面描述的规则”读”，即可得到又一新字符串，依次循环。
现在给定第一个字符串是”1”，问你第n个字符串是什么？
思路
按照上述读的规则进行。从第一个字符串开始计算，一直计算到第n个字符串即可。每次统计某一位出现字符串的次数，然后拼接形成新的字符串。
注意
C++字符串流stringstream在字符串转int,int转字符串的作用
代码

    string int2string(int cnt) {
        stringstream ss;
        ss << cnt;
        string temp;
        ss >> temp;
        return temp;
    }
    string GenerateString(string res) {
        string temp;
        char pre = res[0];
        int cnt = 1;
        for (int i = 1; i < res.size(); i++) {
            if (res[i] == pre) cnt++;
            else {
                temp += cnt + '0';
                temp += pre;
                pre = res[i];
                cnt = 1;
            }
        }
        temp += int2string(cnt);
        temp += pre;
        return temp;
    }
    string countAndSay(int n) {
        // Write your code here
        string res = "1";
        while (--n) {
            res = GenerateString(res);
        }
        return res;
    }

LintCode Length of Last Word

给定一个字符串包含大小写字母和空格，返回最后一个单词的长度
思路
从末尾往前遍历，先去掉末尾空格，然后遍历到下一个空格或者字符串头结束，返回计数值。
代码

        int res = 0;
        int p = s.size()-1;
        while (p >= 0 && s[p] == ' ') p--;
        for (; p >= 0; p--) {
            if (s[p] != ' ') {
                res++;
            }
            else {
                break;
            }
        }
        return res;
    }

LintCode Longest Word

给定一些单词，返回最长的单词的集合。要求一次遍历。
思路
用一个vector存储当前为止的最长单词集合。如果下一个单词的长度大于当前的长度，就把容器清空，把该单词加进去，如果相等则直接把该单词添加进去。最后返回该容器。
代码

    vector<string> longestWords(vector<string> &dictionary) {
        // write your code here
        vector<string> res;
        for (int i = 0; i < dictionary.size(); i++) {
            if (res.empty() || dictionary[i].size() > res[0].size()) {
                res.clear();
                res.push_back(dictionary[i]);
            } else if (dictionary[i].size() == res[0].size())
                res.push_back(dictionary[i]);
        }
        return res;
    }

LintCode Palindrome Number

判断一个正数是不是回文数
思路
先把该数转换为字符串，然后从两边注意比较即可
代码

    bool palindromeNumber(int num) {
        // Write your code here
        string res;
        while (num) {
            res += num % 10 + '0';
            num /= 10;
        }
        bool flag = true;
        for (int i = 0; i < res.size()/2; i++) {
            if (res[i] != res[res.size()-1-i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }

LintCode Reverse Words in a String

给定一个输入字符串，按照单词反转单词
思路
两次反转，先整体翻转，然后再单独把单词翻转，即能达到要求
注意
字符串有前导0与末尾0，但是翻转之后应该去掉。每个单词之间有可能有多个空格，翻转之后要求只有一个
代码

        reverse(s.begin(), s.end());
        string res,temp;
        int p = 0, first = 0;
        while (p < s.size() && s[p] == ' ') p++; //jump the leading zeroes.

        while (p < s.size()) {
            if (s[p] != ' ') {
                temp += s[p++];
                first = true;
            } else if (first) { //遇到第一个空格
                reverse(temp.begin(), temp.end());
                res += temp + s[p++];
                temp = "";
                first = false;
            } else
                p++;
        }
        reverse(temp.begin(), temp.end());
        res += temp;
        return res;
    }

后来想到了可以用stringstream从一个带空格的单词序列读取每一个单词，放在vec里，然后倒序遍历再拼接起来就好了。

    string reverseWords(string s) {
        // write your code here
        string res;
        //if (s == "") return res;
        stringstream ss(s);
        vector<string> vec;
        string temp;
        while (ss >> temp) {
            vec.push_back(temp);
        }
        //vector的倒序迭代器rbegin(),rend()
        for (auto ite = vec.rbegin(); ite != vec.rend(); ite++) {
            if (ite != vec.rbegin()) res += " ";
            res += *ite;
        }
        return res;
    }

LintCode Rotate String

从左向右循环移动字符串n次，要求O(1)空间
思路
本来还在找移动了n次的规律，后来发现只需要每次移动一位，循环n次就可以了
代码

    void rotateString(string &str,int offset){
        //wirte your code here
        if (str.size() == 0) return;
        offset %= str.size();
        for (int i = 0; i < offset; i++) {
            char temp = str[str.size()-1];
            for (int j = str.size()-2; j >= 0; j--) {
                str[j+1] = str[j];
            }
            str[0] = temp;
        }

    }

LintCode Space Replacement

将一个字符串中所有空格替换成”%20”，返回修改后的字符串的长度。
要求O(1)空间复杂度
思路
遍历，当遍历到一个空格后将空格后的有效字符均向右移动两位，然后添加”%20”,由于题目说明了空间是足够的，所以不用慌。
代码

    int replaceBlank(char string[], int length) {
        // Write your code here
        int cnt = 0, i = 0;
        while (cnt < length) {
            if (string[i] != ' ') {
                cnt++;
                i++;
            } else {
                for (int j = length-cnt-1; j > 0; j--) {
                    string[i+2+j] = string[i+j];
                }
                string[i] = '%';
                string[i+1] = '2';
                string[i+2] = '0';
                i += 3;
                cnt++;
            }
        }
        return i;
    }

九章做法是先求得新的长度，然后从原字符串的末尾开始遍历，同时修改新申请的长度空间。
代码

   int replaceBlank(char string[], int length) {
        // Write your code here
        if(string == NULL && length <= 0)
            return 0;

        /*originalLength 为字符串string的实际长度*/
        int originalLength = 0;
        int numberOfBlank = 0;
        int i = 0;
        while(string[i] != '\0')
        {
            ++ originalLength;

            if(string[i] == ' ')
                ++ numberOfBlank;

            ++ i;
        }

        /*newLength 为把空格替换成'%20'之后的长度*/
        int newLength = originalLength + numberOfBlank * 2;

        int indexOfOriginal = originalLength;
        int indexOfNew = newLength;
        while(indexOfOriginal >= 0 && indexOfNew > indexOfOriginal)
        {
            if(string[indexOfOriginal] == ' ')
            {
                string[indexOfNew --] = '0';
                string[indexOfNew --] = '2';
                string[indexOfNew --] = '%';
            }
            else
            {
                string[indexOfNew --] = string[indexOfOriginal];
            }

            -- indexOfOriginal;
        }
        return newLength;
    }

LintCode String Permutation

给定两个字符串，判断其中一个是不是另一个的排列组合
思路
将两个字符串排序，若排序后相等就说明符合题意，否则就不符合。复杂度O(nlogn)
或者用hash统计字符出现次数，复杂度O(n)
代码

    bool Permutation(string A, string B) {
        // write your code here
        sort(A.begin(), A.end());
        sort(B.begin(), B.end());
        return A == B;
    }

LintCode Two Strings Are Anagrams

Anagrams: They can be same after change the order of characters.
Challenge: O(n)时间复杂度,O(1)空间复杂度
思路
之前提到的是O(n)的时间复杂度，O(n)空间复杂度的方法，这里只不过将开辟的数组换成一个大小固定为26的数组，然后做同样的事情。

    bool anagram(string s, string t) {
        // write your code here
        vector<int> hash(26, 0);
        for (auto c: s) {
            c = tolower(c);
            hash[c-'a']++;
        }
        for (auto c: t) {
            c = tolower(c);
            hash[c-'a']--;
            if (hash[c-'a'] < 0) return false;
        }
        return true;
    }

LintCode Valid Palindrome

给定一个字符串，判断其是不是一个有效的回文串，只考虑英文数字字母(alphanumeric characters)且忽略大小写。
Challenge: O(n) time without extra memory.
思路:
用两个指针从两端向中间遍历，只有在都是字母或数字的时候才判断其是否满足相等，相等则继续判断，不相等则不满足回文串要求。
代码

    bool isPalindrome(string& s) {
        // Write your code here
        int l = 0, r = s.size()-1;
        while (l < r) {
            if (!isalpha(s[l]) && !isdigit(s[l])) l++;
            else if (!isalpha(s[r]) && !isdigit(s[r])) r--;
            else if (tolower(s[r]) == tolower(s[l])) {
                l++;
                r--;
            } else
                return false;
        }
        return true;
    }

LintCode strStr

对于一个给定的source string和一个target string，返回target string在source string中的起始下标，若source string不包含target，则返回-1。
思路：
这就是字符串查找的KMP算法，可以以O(n)的方式解决此问题。KMP算法我并不熟，所以这道题暂时是以O(n2)做的，有时间学习了KMP算法在来更新这道题。
代码

    int strStr(const char *source, const char *target) {
        // write your code here
        if (source == NULL || target == NULL) return -1;
        if (target[0] == '\0') return 0;
        for (int i = 0; source[i] != '\0'; i++) {
            if (source[i] == target[0]) {
                bool find = true;
                for (int j = 1; target[j] != '\0'; j++) {
                    if (source[i+j] == '\0' || source[i+j] != target[j]) {
                        find = false;
                        break;
                    }
                }
                if (find) return i;
            }
        }
        return -1;
    }

LintCode Big Interger Multiplication

给定另个非负大整数(用字符串表示)，求他们的乘积，结果也以字符串表示。
思路
按照正常乘法的思路，用一个vector存储所有的因子，最后把这些因子加起来就是想要的答案。
另外可以用一个result数组存储相乘得到的每一位,这种方法代码上更清晰一点。

    string multiply(string& num1, string& num2) {
        // Write your code here
        if (num1 == "0" || num2 == "0") return "0";
        int len1 = num1.size(), len2 = num2.size();
        vector<char> result(len1+len2, '0');
        int c;
        for (int i = len1-1; i >= 0; i--) {
            c = 0;
            for (int j = len2-1; j >= 0; j--) {
                int temp = (result[i+j+1]-'0')+(num1[i]-'0')*(num2[j]-'0')+c;
                c = temp/10;
                result[i+j+1] = temp%10 + '0';
            }
            result[i] += c;
        }
        string res = "";
        int cnt = 0;
        for (; cnt < len1+len2; cnt++) {
            if (result[cnt] != '0') break;
        }
        for (; cnt < len1+len2; cnt++) {
            res += result[cnt];
        }
        return res;
    }

LintCode Decode Ways

给定一种编码方式，比如’A’ to ‘1’, ‘B’ to ‘2’,…,’Z’ to ‘26’，现在给你一数字序列，问你有多少种译码方式。
思路
从前往后遍历，假设当前位置i，既可以选择i+1位的单字符编码，也可以选择i+1、i+2位组成的双字符编码。当然存在组成的字符编码无法译码的情况，比如单字符为’0’就无法译码，或者双字符组成的数大于26或者’0x’这样的形式。这道题很像上楼梯问题:一共n个楼梯，一次可以选择走一步，也可以选择走两步，问一共有多少种上楼方式。
总结一下递推公式:
dp[i] = dp[i-1](if s[i] != ‘0’) + dp[i+2] (if 10*(s[i-1]-‘0’) + s[i]-‘0’ < 26 && s[i-1] != ‘0’)
初始条件 如果s != null && s[0] != ‘0’,那么s[0] = 1; s[1]的判断同理。
代码

    int numDecodings(string& s) {
        // Write your code here
        if (s.size() == 0 || s[0] == '0') return 0;
        if (s.size() == 1) return 1;
        vector<int> res(s.size(), 0);
        res[0] = 1;
        int sum = 10*(s[0]-'0')+(s[1]-'0');
        if (sum >= 1 && sum <= 26) res[1]++;
        if (s[1] != '0') res[1]++;
        for (int i = 2; i < s.size(); i++) {
            int sum = 10*(s[i-1]-'0')+(s[i]-'0');
            if (s[i] != '0')
                res[i] += res[i-1];
            if (sum >= 1 && sum <= 26 && s[i-1] != '0') {
                res[i] += res[i-2];
            }
        }
        return res[s.size()-1];

    }