【LeetCode】394. 字符串解码（Java）

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

解法一

class Solution {
    public String decodeString(String s) {
        Deque<Integer> numStack = new ArrayDeque<>();       //数字栈
        Deque<String> strStack = new ArrayDeque<>();       //字符串栈
        StringBuilder res = new StringBuilder();
        int num = 0;    //重复次数
        //遍历每个字符
        for (char c : s.toCharArray()) {
            if (c >= '0' && c <= '9') {
                //把数字字符转成整型，因为可能不止是个位，而是十位百位，所以需要乘10
                num = num * 10 + (c - '0');
            } else if (c == '[') {
                //把数字num压入数字栈中
                numStack.push(num);
                num = 0;
                //把拼接的字符串也压入字符串栈中
                strStack.push(res.toString());
                res = new StringBuilder();
            } else if (c == ']') {
                StringBuilder temp = new StringBuilder();
                //取出数字栈的数字，进行循环复制
                int count = numStack.pop();
                //拼接
                for (int i = 0; i < count; i++) {
                    temp.append(res);
                }
                res = new StringBuilder(strStack.pop() + temp);
            } else {
                //剩下的就是在括号[]里的数据
                res.append(c);
            }
        }
        return res.toString();
    }
}

做了一个小时了，还是有bug，最后按照Krahets大神的思路才终于运行成功，解法二也是按照Krahets大神的思路做的。

解法二

class Solution {
    public String decodeString(String s) {
        //递归    
        return dfs(s, 0)[0];
    }

    //传参和返回值都是字符串和下标
    //递归，把整个字符串看成 2[...] 或 ab3[...] 这种类型的
    private String[] dfs(String s, int i) {
        StringBuilder res = new StringBuilder();
        int num = 0;    //重复次数
        while (i < s.length()) {
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                num = num * 10 + (s.charAt(i) - '0');
            } else if (s.charAt(i) == '[') {
                //遇到'['，把后面的部分递归过去，其余的不管
                //然后拿到返回的字符串和递归操作后的下标
                //这里考虑的是当前方法，让下一个方法解决中间字符串，和拿到返回值后重复复制拼接的问题
                String[] tmp = dfs(s, i + 1);
                //修改下标
                i = Integer.parseInt(tmp[1]);
                //拼接字符串
                while (num > 0) {
                    res.append(tmp[0]);
                    num--;
                }
            } else if (s.charAt(i) == ']') {
                //遇到']'就返回拼接的字符串和当前的下标
                //这里考虑的是已经是下个方法，即上面发起递归后的下一个方法了
                return new String[]{res.toString(), String.valueOf(i)};
            } else {
                res.append(s.charAt(i));
            }
            i++;
        }
        return new String[]{res.toString(), String.valueOf(i)};
    }
}

代码里写的递归的思路可能有点乱，不过递归也就只能自己找感觉。