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了。