数据结构解题

Stack

　　1. MinStack

　　　　

　　2 Longest Valid Parentheses

　　求最长的合理的()

• 利用stack做(的积累和匹配
• 利用gobal变量和local变量做更新
• 注意 ()(()的时候，也就是说 当）与stack里的（做了匹配之后 需要判断stack是否为空， 不为空的话，往后继续累积，往前的话就断掉了！　　
• 　()(()()()() 在黄色空间里，做了匹配，可以往后扩展，但是向前的地方就要看下一个char是否能把stack清空，上面的例子不行 下面这个例子可以  ()(())

　　

public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        if (s == null) {
            return 0;
        }

        Stack<Integer> stack = new Stack<Integer>();
        int maxLen = 0;
        int accumulatedLen = 0;

        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '(') {
                stack.push(i);
            } else {
                if (stack.isEmpty()) {
                    accumulatedLen = 0;
                } else {
                    int matchedPos = stack.pop();
                    int matchedLen = i - matchedPos + 1;

                    if (stack.isEmpty()) {
                        accumulatedLen += matchedLen;
                        matchedLen = accumulatedLen;
                    } else {
                        matchedLen = i - stack.peek();
                    }

                    maxLen = Math.max(maxLen, matchedLen);
                }
            }
            maxLen = Math.max(maxLen,accumulatedLen);
         }
    return maxLen;
    }
}

　　3. maximal-rectangle

　　首先用坐标型动态规划拿到一个高度的数组。

　　其次利用stack， 递增时不断的push， 当遇到一个比stack的值小的时候，相当于木桶原理的短板的时候，求这个时候的面积。

　　当一直往后走，到达末位的时候，都没有比当前stack低的值的时候，那么就是从当前pos到最后这么长作为宽度。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if (matrix == null || matrix.length == 0) {
            return 0;
        }
        
        //准备一个表示高度的matrix
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] height = new int[m][n];
        
        //坐标类动态规划得到高度矩阵
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0) {
                    height[i][j] = ((matrix[i][j] == '1')? 1: 0);
                } else {
                    height[i][j] = ((matrix[i][j] == '1') ? height[i - 1][j] + 1 : 0);
                }       
            }
        }
      
      
       
        
        int result = 0;
        for (int i = 0; i < m; i++) {
            Stack<Integer> myStack = new Stack<Integer>();
            for (int j = 0; j < n; j++) {
                //当有一个值比当前的stack最外面点低的时候，拿到这段区间的面积
                while (!myStack.empty() && height[i][j] < height[i][myStack.peek()]) {
                    int pos = myStack.peek();
                    myStack.pop();
                    int temp = height[i][pos]* (myStack.empty()? j: j - myStack.peek() - 1);
                    result = Math.max(result, temp);
                    
                }
                myStack.push(j);
            }
            
            //当走到最后都没有值比stack里面的点低
            while (!myStack.empty()) {
                int pos = myStack.peek();
                myStack.pop();
                //需要检测是否为空！
                int temp = height[i][pos]* (myStack.empty()? n: n - myStack.peek() - 1);
                    result = Math.max(result, temp);
            }
        }
        return result; 
        
    }
}