Codility：方括号确定给定的括号字符串是否正确嵌套

Question

编码问题描述：

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

S为空；S的形式为“（U）”或“ [U]”或“ {U}”，其中U是正确嵌套的字符串；S的形式为“ VW”，其中V和W是正确嵌套的字符串。例如，字符串“ {[（）（）]}”已正确嵌套，而“（[]（）]”则未正确嵌套。

编写一个函数：

类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;

    }
}

Answer 1

这个问题的简短而干净的 Python 解决方案。100% 美味

def solution(S):

    matches, stack = dict(['()', '[]', '{}']), []

    for i in S:
        if i in matches.values():
            if stack and matches[stack[-1]] == i:
                stack.pop()
            else:
                return 0
        else:
            stack.append(i)

    return int(not stack)

Answer 2

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

例如，对于像(((.

一个简单的解决方法是在循环结束后检查堆栈确实为空来替换此条件。

Answer 3

简单的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;
    }