【力扣】字符串编码解码

【力扣】字符串编码解码

Leetcode 0471 编码最短长度的字符串

题目描述：

给定一个 非空 字符串，将其编码为具有最短长度的字符串。编码规则是：k[encoded_string]，其中在方括号 encoded_string 中的内容重复 k 次。

注：

（1）k 为正整数且编码后的字符串不能为空或有额外的空格。

（2）你可以假定输入的字符串只包含小写的英文字母。字符串长度不超过 160。

（3）如果编码的过程不能使字符串缩短，则不要对其进行编码。如果有多种编码方式，返回任意一种即可。

示例：

示例1：
输入： "aaa"
输出： "aaa"
解释： 无法将其编码为更短的字符串，因此不进行编码。

示例2：
输入： "aaaaa"
输出： "5[a]"
解释： "5[a]" 比 "aaaaa" 短 1 个字符。

示例3：
输入： "aaaaaaaaaa"
输出： "10[a]"
解释： "a9[a]" 或 "9[a]a" 都是合法的编码，和 "10[a]" 一样长度都为 5。

示例4：
输入： "aabcaabcd"
输出： "2[aabc]d"
解释： "aabc" 出现两次，因此一种答案可以是 "2[aabc]d"。

示例5：
输入： "abbbabbbcabbbabbbc"
输出： "2[2[abbb]c]"
解释： "abbbabbbc" 出现两次，但是 "abbbabbbc" 可以编码为 "2[abbb]c"，因此一种答案可以是 "2[2[abbb]c]"。

分析

• 本题的考点：区间dp。

• 注意：2022.10.12秋招华为软开第一题 报文压缩 就是这题。

• 分析如下：

代码

• C++

class Solution {
public:
    string encode(string s) {
        int n = s.size();
        vector<vector<string>> f(n, vector<string>(n, ""));
        // 区间dp
        for (int len = 1; len <= n; len++) { // 遍历区间长度
            for (int i = 0; i + len - 1 < n; i++) { // 遍历区间左端点
                int j = i + len - 1; // 区间右端点

                string t = s.substr(i, len);
                f[i][j] = t;
                int p = (t + t).find(t, 1); // 力扣459
                if (p < t.size()) {
                    // 说明s[i, j]由一个子串循环得到，该子串(循环节)为s[i, i + p - 1]
                    string str = to_string(t.size() / p) + "(" + f[i][i + p - 1] + ")";
                    if (str.size() < f[i][j].size()) f[i][j] = str;
                    continue;
                }

                for (int k = i; k < j; k++) {
                    string l = f[i][k], r = f[k + 1][j];
                    if (l.size() + r.size() < f[i][j].size()) {
                        f[i][j] = l + r;
                    }
                }
            }
        }

        return f[0][n - 1];
    }
};

时空复杂度分析

• 时间复杂度：$O(n^3)$，n为字符串长度。

• 空间复杂度：$O(n^2)$。

Leetcode 0394 字符串解码

题目描述：Leetcode 0394 字符串解码

分析

• 本题的考点：递归回溯。

• 直接递归求解即可。

代码

• C++

class Solution {
public:
    string decodeString(string s) {

        int u = 0;
        return dfs(s, u);
    }

    // &u：目的是为了让在递归的过程中使用同一个u
    string dfs(string &s, int &u) {
        string res;
        while (u < s.size() && s[u] != ']') {  // 这里s[u] != ']'是为了过滤掉最后一个右括号
            if ((s[u] >= 'a' && s[u] <= 'z') || (s[u] >= 'A' && s[u] <= 'Z')) res += s[u++];
            else if (s[u] >= '0' && s[u] <= '9') {
                int k = u;
                while (s[k] >= '0' && s[k] <= '9') k++;
                int x = stoi(s.substr(u, k - u));
                u = k + 1;  // 过滤掉左括号
                string y = dfs(s, u);
                u++;  // 过滤掉右括号
                while (x--) res += y;
            }
        }
        return res;
    }
};

• Java

class Solution {
    
    // 类变量，每次都要初始化为0，否则多次测试无法通过，如果不加static可以不用每次都初始化为0
    static int u = 0;

    public String decodeString(String s) {
        u = 0;
        return dfs(s.toCharArray());
    }

    private String dfs(char[] s) {

        StringBuilder res = new StringBuilder();
        while (u < s.length && s[u] != ']') {  // 这里s[u] != ']'是为了过滤掉最后一个右括号
            if ((s[u] >= 'a' && s[u] <= 'z') || (s[u] >= 'A' && s[u] <= 'Z')) res.append(s[u++]);
            else if (s[u] >= '0' && s[u] <= '9') {
                int k = u;
                while (s[k] >= '0' && s[k] <= '9') k++;
                int x = Integer.parseInt(new String(s, u, k - u));
                u = k + 1;  // 过滤掉左括号
                String y = dfs(s);
                u++;  // 过滤掉右括号
                while (x-- != 0) res.append(y);
            }
        }
        return res.toString();
    }
}

时空复杂度分析

• 时间复杂度：$O(n)$，n为字符串长度。

• 空间复杂度：和递归深度有关。