LeetCode-394：Decode String（字符串解碼）

Given an encoded string, return its decoded string.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.

You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.

Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won’t be input like 3a or 2[4].

Examples:

 s = "3[a]2[bc]", return "aaabcbc".
 s = "3[a2[c]]", return "accaccacc".
 s = "2[abc]3[cd]ef", return "abcabccdcdcdef".

思路

本題要求很簡單，就是按要求給字符串解碼，編碼規則爲k[encoded_string]，k爲一個數字，表示encoded_string出現的次數，解碼規則即爲將 k[encoded_string] 轉化爲 k 個encoded_string 的拼接，題目所給的字符沒有空格，並且編碼串中不會存在數字。
這裏可以使用棧這種數據結構來處理，步驟如下：

1. 遍歷字符串中的所有元素；
2. 當遍歷字符非數字和右括號“]”時，全部進行入棧操作；
3. 當遍歷的字符是數字時，需要繼續遍歷，直到找到所有連續的數字字符，並將其拼接爲一個數字字符串，然後入棧；
4. 當遍歷到“]”字符時，開始出棧操作，直到遇到“[”字符後終止，此時除“[”字符外的其他所有出棧字符按序拼接後可得到encoded_string 的逆序串，並且此時棧頂的元素一定是編碼串出現的次數 k ;
5. 得到encoded_string 和 k 後，將其進行解碼，並將解碼串入棧；
6. 進行如上步驟遍歷完全部元素後，此時將棧中元素依次出棧，即可得到目標解碼串的逆序串，此時只需將逆序串反序輸出即可。

Java實現

class Solution {
    public String decodeString(String s) {
        Stack<String> res = new Stack<>();
        // 存儲數字k
        StringBuffer k = new StringBuffer();
        // 數字k拼接完成標誌
        boolean flag = false;

        for (char c : s.toCharArray()) {
            // 如果是數字字符，則開始構建編碼次數k
            if (c >= '0' && c <= '9') {
                flag = true;
                k.append(c);
                continue;
            }
            // 將拼好的數字k入棧，並置空k
            if (flag) {
                res.push(k.toString());
                k = new StringBuffer();
                flag = false;
            }

            // 如果是右括號，開始出棧構建編碼串，直到出棧元素是左括號
            if (c == ']') {
                StringBuffer encodedStr = new StringBuffer();
                String str = "";
                while (true) {
                    // 出棧一個元素
                    str = res.pop();
                    // 如果元素是左括號則直接跳出循環，否則構建編碼串
                    if ("[".equals(str)) {
                        break;
                    } else {
                        encodedStr.append(str);
                    }
                }
                // 跳出循環後，棧頂元素即爲編碼次數，需要把字符串解碼後入棧
                StringBuffer decodeStr = new StringBuffer();
                String num = res.pop();
                for (int i = 0; i < Integer.parseInt(num); i++) {
                    decodeStr.append(encodedStr);
                }
                // 解碼串入棧
                res.push(decodeStr.toString());
            } else {
                // 其他元素直接入棧
                res.push(String.valueOf(c));
            }
        }

        // 所有循環走完開始拼接結果
        StringBuffer resStr = new StringBuffer();
        while (!res.empty()) {
            resStr.append(res.pop());
        }

        return resStr.reverse().toString();
    }
}

Python實現

class Solution(object):
    def decodeString(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 使用列表作爲棧
        res = []
        # 存儲數字k
        k = ""
        # 存儲k拼接完成標誌
        flag = False

        for c in s:
            # 如果是數字字符，則開始構建編碼次數k
            if c >= '0' and c <= '9':
                k += c
                flag = True
                continue
            # 如果k拼接好，則入棧，然後初始化flag
            if flag:
                res.append(k)
                k = ""
                flag = False
            
            # 如果是右括號，開始出棧構建編碼串，直到出棧元素是左括號
            if c == ']':
                encodedStr = ""
                sr = ""
                while True:
                    # 出棧一個元素
                    sr = res.pop()
                    # 如果元素是左括號則直接跳出循環，否則構建編碼串
                    if sr == '[':
                        break
                    else:
                        encodedStr += sr
                
                # 跳出循環後，棧頂元素即爲編碼次數，需要把字符串解碼後入棧
                decodeStr = ""
                num = int(res.pop())
                for i in range(num):
                    decodeStr += encodedStr

                # 解碼串入棧
                res.append(decodeStr)
            else:
                # 其他元素直接入棧
                res.append(c)

        # 所有循環走完後開始拼接結果串
        resStr = ""
        while len(res) > 0:
            resStr += res.pop()
        
        return resStr[::-1]

Scala實現

import scala.collection.mutable.Stack

object Solution {
    def decodeString(s: String): String = {
        // 定義棧
        val res = new Stack[String]
        // 存儲數字k
        var k = new StringBuffer()
        // 定義數字k拼接成功標誌
        var flag = false

        for (c <- s.toCharArray) {
            // 如果是數字字符，則開始構建編碼次數k
            if (c >= '0' && c <= '9') {
                k.append(c)
                flag = true
            } else {
                // 將拼好的數字k入棧，並置空k
                res.push(k.toString)
                k = new StringBuffer()
                flag = false
                // 如果是右括號，開始出棧構建編碼串，直到出棧元素是左括號
                if (c == ']') {
                    val encodedStr = new StringBuffer()
                    var str = res.pop()
                    while (!"[".equals(str)) {
                        // 出棧一個元素，如果元素是左括號則直接跳出循環，否則構建編碼串
                        encodedStr.append(str)
                        str = res.pop()
                    }
                    // 跳出循環後，棧頂元素即爲編碼次數，需要把字符串解碼後入棧
                    val decodeStr = new StringBuffer()
                    val num = res.pop()
                    for (i <- 0 until num.toInt) {
                        decodeStr.append(encodedStr)
                    }
                    // 解碼串入棧
                    res.push(decodeStr.toString)
                } else {
                    // 其他元素直接入棧
                    res.push(c.toString)
                }
            }
        }

        // 所有循環走完開始拼接結果
        val resStr = new StringBuffer()
        while (!res.isEmpty) {
            resStr.append(res.pop())
        }
        return resStr.reverse().toString
    }
}