Codility : Brackets 确定给定的括号字符串是否正确嵌套

Question

来自 codility 的问题描述：

如果满足以下任何条件，则认为由 N 个字符组成的字符串 S 正确嵌套：

S为空； S 的形式为“(U)”或“[U]”或“{U}”，其中 U 是正确嵌套的字符串； S 的形式为“VW”，其中 V 和 W 是正确嵌套的字符串。例如，字符串“{[()()]}”是正确嵌套的，但“([)()]”不是。

写一个函数：

class Solution { public int solution(String S); }

即，给定一个由 N 个字符组成的字符串 S，如果 S 正确嵌套则返回 1，否则返回 0。

例如，给定 S =“{[()()]}”，函数应返回 1，给定 S =“([)()]”，函数应返回 0，如上所述。

假使，假设：

N为[0..200,000]范围内的整数；字符串 S 仅由以下字符组成：“(”、“{”、“[”、“]”、“}”和/或“)”。复杂：

预期的最坏情况时间复杂度为 O(N)；预期的最坏情况空间复杂度为 O(N)（不计算输入参数所需的存储空间）。

我得到 87% 我似乎无法弄清楚问题所在。

这是我的代码：

    // you can also use imports, for example:
// import java.util.*;
import java.util.Stack;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
   public int solution(String s) {

        if (s.length() % 2 != 0) {
            return 0;
        }

        Character openingBrace = new Character('{');
        Character openingBracket = new Character('[');
        Character openingParen = new Character('(');
        Stack<Character> openingStack = new Stack<Character>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == openingBrace || c == openingBracket || c == openingParen) {
                openingStack.push(c);
            } else  {
                if (i == s.length()-1 && openingStack.size() != 1) {
                    return 0;
                }
                if (openingStack.isEmpty()) {
                    return 0;
                }
                Character openingCharacter = openingStack.pop();
                switch (c) {
                case '}':
                    if (!openingCharacter.equals(openingBrace)) {
                        return 0;
                    }
                    break;
                case ']':
                    if (!openingCharacter.equals(openingBracket)) {
                        return 0;
                    }
                    break;
                case ')':
                    if (!openingCharacter.equals(openingParen)) {
                        return 0;
                    }
                    break;

                default:
                    break;
                }
            }
        }

        return 1;

    }
}

原文由 klind 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

右括号块中的第一个条件检查堆栈的大小是否为 != 1。我认为这是为了检查您是否没有任何剩余的左括号，这是个好主意。但是，如果您的最后一个字符不是右括号/paren/..，您将错过整个检查。

例如，对于像 ((( 这样的输入，这将失败。

一个简单的修复方法是在循环结束 后 检查堆栈是否确实为空，从而替换此条件。

原文由 Leeor 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

简单的 Java 解决方案，100/100

 public int solution(String S) {
        Deque<Character> stack = new ArrayDeque<Character>();

        for(int i = 0; i < S.length(); i++) {
            char c = S.charAt(i);

            switch (c) {
                case ')':
                    if (stack.isEmpty() || stack.pop() != '(')
                        return 0;
                    break;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[')
                        return 0;
                    break;
                case '}':
                    if(stack.isEmpty() || stack.pop() != '{')
                        return 0;
                    break;
                default:
                    stack.push(c);
                    break;
            }
        }

        return stack.isEmpty() ? 1 : 0;
    }

原文由 Elaina 发布，翻译遵循 CC BY-SA 4.0 许可协议