Valid Parentheses

https://oj.leetcode.com/problems/valid-parentheses/

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

解题思路：

这道题比较典型的，栈匹配。左括号入栈，右括号出栈。最后检查栈是否为空。

public class Solution {

    public boolean isValid(String s) {

        Stack<Character> stack = new Stack<Character>();

        for(int i = 0; i < s.length(); i++){

            //遇到(或者[或者{，放到栈里

            if(s.charAt(i) == '(' || s.charAt(i) == '{' || s.charAt(i) == '['){

                stack.push(s.charAt(i));

                //遇到右侧括号弹出栈顶，如果栈为空，返回否，或者栈顶元素不是当前右括号的左括号

            }else if(s.charAt(i) == ')'){

                if(stack.empty()){

                    return false;

                }

                char temp = stack.pop();

                if(temp != '('){

                    return false;

                }

            }else if(s.charAt(i) == '}'){

                if(stack.empty()){

                    return false;

                }

                char temp = stack.pop();

                if(temp != '{'){

                    return false;

                }

            }else if(s.charAt(i) == ']'){

                if(stack.empty()){

                    return false;

                }

                char temp = stack.pop();

                if(temp != '['){

                    return false;

                }

            }

        }

        //结束时，栈里还有元素，返回否，比如s为'['

        if(!stack.empty()){

            return false;

        }

        return true;

    }

}

 还有一个动态规划的解法。定义一个数组，dp[]。dp[i]的意义为，s中以第i个字符结尾的子字符串的最大的valid长度。也就是从s.charAt(i)往前看的valid最长长度。下面考虑dp[i]和dp[i - 1]的关系。

研究到第i个char，如果删除它往前已经成对的字符，紧接着前面一个是他自己的左括号，当然前提是他自己必须是右括号。那么这时候，dp[i]就要在dp[i - 1]的基础上+2，也就是长度+2。比如([])。

这里还要考虑一个情况。如果i的左括号不在第一个元素，比如[{()]}，说明dp[i - 1]在x处被截断了，还要加上x往前的dp。

public class Solution {

    public boolean isValid(String s) {

        if(s.length() == 0){

            return true;

        }

        

        int[] dp = new int[s.length()];

        dp[0] = 0;

        

        for(int i = 1; i < s.length(); i++){

            //x就是从i向前，看看跳过前面已经匹配的字符串的前一个元素是不是自己的左括号

            int x = i - dp[i - 1] - 1;

            if(x >= 0){

                if(s.charAt(i) == ')' && s.charAt(x) == '('

                || s.charAt(i) == ']' && s.charAt(x) == '['

                || s.charAt(i) == '}' && s.charAt(x) == '{'){

                    //如果是的话，当前长度要+2

                    dp[i] = dp[i - 1] + 2;

                    //如果自己的左括号不是第一给元素

                    //说明dp[i - 1]在这个左括号的时候就被截断了，这里dp[i]还要加上这个左括号之前的长度

                    if(x > 0){

                        dp[i] = dp[i] + dp[x - 1];

                    }

                }

            }else{

                dp[i] = 0;

            }

        }

        return dp[s.length() - 1] == s.length();

    }

}

 这时一个dp，但是dp[i]的值并不单纯依赖于dp[i - 1]，而是更往前的一个dp[x - 1]。拓宽了dp的思路。