LintCode 解题记录17.8.8 字符串处理4

LintCode Restore IP Addresses

给定一个由数字组成的字符串，返回能复原的有效Ip地址。
注意:有效的Ip地址指每一位都在0~255之间。
思路
Dfs,每跳一次就是一个子网段,然后在后面加个’.’。那么根据题意可以知道每次最多可以跳三步，如果当前位为0则只能跳一步。组成的数还必须符合0~255的条件。
代码

    vector<string> restoreIpAddresses(string& s) {
        // Write your code here
        int n = s.size();
        vector<string> res;
        string tmp;
        dfs(res, tmp, s, n, 0, 0);
        return res;
    }
    //idx标示此时的下标，cnt表示跳的次数。
    void dfs(vector<string> &res, string tmp, string s, int n, int idx, int cnt) {
        if (idx == n || cnt == 4) {
            if (idx == n && cnt == 4) {
                tmp.pop_back();
                res.push_back(tmp);
            }
            return;
        }
        for (int i = 1; i <= 3 && idx+i <= n; i++) {
            if (Valid(s.substr(idx, i)))
                dfs(res, tmp+s.substr(idx, i)+'.', s, n, idx+i, cnt+1);
            if (s[idx] == '0') break;
        }
    }

    bool Valid(string s) {
        int sum = atoi(s.c_str());
        return sum >= 0 && sum <= 255;
    }

LintCode Roman to Integer

给定一个罗马字符序列，返回这个序列所代表的十进制整数
思路
观察罗马字符的写法规则就可以发现，如果小的符号在大的符号的左边就代表应当减去这个小的符号，否则全是加上该符号的值。
代码

    int romanToInt(string& s) {
        // Write your code here
        int res = 0;
        unordered_map<char, int> weight;
        weight['I'] = 1, weight['V'] = 5, weight['X'] = 10;
        weight['L'] = 50, weight['C'] = 100, weight['D'] = 500;
        weight['M'] = 1000;
        int cnt = 0;
        for (int i = 0; i < s.size(); i++) {
            if (i < s.size()-1 && weight[s[i]] < weight[s[i+1]]) {
                res -= weight[s[i]];
            } else
                res += weight[s[i]];
        }
        return res;
    }

LintCode Simplify Path

给定一个Unix的绝对路径，简化这个路径，比如/a/../b/ = /b这样
思路
这道题考察了一下Unix路径的基本知识，比如..代表的是上一层目录， cd ..就是回到上一层目录，cd .就是停留在当前目录。因此这道题可以把给的路径字符串按照’/’分割，依次处理中间的字符串，根据不同的情况来处理。
那么如何对字符串进行分割呢？C++里采用stringstream来实现。
代码

    string simplifyPath(string& path) {
        // Write your code here
        vector<string> v;
        string tmp, res;
        stringstream ss(path);
        //istream &getline(istream &is, string &str, char delim),从流is中读取字符串送给str，遇到delim字符结束读取
        while (getline(ss, tmp, '/')) { 
            if (tmp == "" || tmp == ".") continue;
            if (tmp == "..") {
                if (!v.empty()) v.pop_back();
            } else
                v.push_back(tmp);

        }
        for (int i = 0; i < v.size(); i++) {
            res += "/" + v[i];
        }
        return res.size() == 0 ? "/" : res;
    }

反思
刚开始我自己做的时候没有想到分割开来处理，而是顺序遍历一步一步处理，结果就是在/.，、/..，/…，这几个路径之间纠结了好一阵子。今日一看大神答案思路确实巧妙，更有大局观。

LintCode Sort Letters by Case

把给定的字符串排序，要求小写的在左边，大写的在右边，原本的字符顺序可以不用考虑。
思路
排序排成一部分在左边，一部分在右边是不是似曾相识？是的，就在快排里提到过，所以此题的解法跟一次快排的解法很像。从左边开始找到一个大写字母，从右边找到一个小写字母，交换，直至两个指针相遇。
代码

    void sortLetters(string &letters) {
        // write your code here
        if (letters.size() == 0) return;
        int low = 0, high = letters.size()-1;
        //下面的等号写不写并不影响结果
        while (low <= high) {
            while (low <= high && letters[low] >= 'a' && letters[low] <= 'z')
                low++;
            while (high >= low && letters[high] >= 'A' && letters[high] <= 'Z')
                high--;
            if (low <= high)
                swap(letters[low], letters[high]);
        }
    }

LintCode Word Break

给定一个字符串和一个字典，问你该字符串能不能拆成字典里的单词组合。
思路
我做题喜欢立马看下面的tag以寻求第一思路，感觉这种做法不是很好，不利于思路的发散。下次要尽量先自己思考用什么来解决比较好。
这道题是动态规划。维护dp[i]表示前i个字母是不是word break。接下来考虑递推式，就是如何从存储的历史信息中得到当前步的结果。很自然就可以想到，dp[i] = dp[i] || (dp[j] && s[j:i-1] in dict), 0 <= j < i-1。
代码

    bool wordBreak(string s, unordered_set<string> &dict) {
        // write your code here
        int n = s.size();
        vector<int> dp(n+1 ,0);
        int maxLen = 0;
        for (auto str : dict) {
            int len = str.size();
            maxLen = max(maxLen, len);
        }
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = i-1; j >= 0; j--) {
                if (i-j > maxLen) break;
                //dp[i] = dp[j] && (dict.find(s.substr(j, i-j)) != dict.end());
                //if (dp[i]) break;
                if (dp[j] && dict.find(s.substr(j, i-j)) != dict.end()) {
                    dp[i] = 1;
                    break;
                }
            }
        }
        return dp[n];
    }

发现我的代码里多了maxLen这几行代码。这是什么原因呢？因为在LeetCode中可以AC的代码但是在LintCode中以TLE告终。把测试数据下载下来看了一下，发现是给的字符串很长很长，但字典里的单词却很短很短。于是上网搜了一下，发现需要进一步的剪枝，即在s.substr(j, i-j)这一步，如果i-j大于字典里单词的最大长度，那么就没有必要进行判断了。即省略了substr这一步，从而在该测试数据集下速度快了很多，也AC了。