LeetCode练习题20、84

20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:
输入: “()”
输出: true

示例 2:
输入: “()[]{}”
输出: true

示例 3:
输入: “(]”
输出: false

示例 4:
输入: “([)]”
输出: false

示例 5:
输入: “{[]}”
输出: true

有效的括号

栈：左括号压栈；右括号与栈顶元素比较，匹配出栈

bool isValid(char * s){
    int len = strlen(s);
    char *stack = (char*)malloc(sizeof(char)*(len+1));   //构造栈
    int top = 0;
    int i;
    if(s == NULL)   return true;      //数组为空
    if(len % 2 == 1)    return false;     //数组为奇数
    for(i = 0; i < len; ++i) {
        if(s[i] == '(' || s[i] == '{' || s[i] == '[') {
            stack[top++] = s[i];
        }     //左括号入栈
        else {
            top--;
            if(top == -1)    return false;
            if(s[i] == ')' && stack[top] != '(')    return false;
            if(s[i] == ']' && stack[top] != '[')    return false;
            if(s[i] == '}' && stack[top] != '{')    return false;
        }     //出栈
    }
    return (!top);    //栈顶为空时，为真
}

84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。
图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：直接暴力

int largestRectangleArea(int* heights, int heightsSize){
    int maxarea = 0;
    int minheight = 0;
    int area = 0;
    int i, j;
    for(i = 0; i < heightsSize; i++) {
        minheight = heights[i];
        for(j = i; j < heightsSize; j++){
            if(heights[j] < minheight) {
                minheight = heights[j];
            }
            area = minheight * (j-i+1);
            if(area > maxarea) {
                maxarea = area;
            }
        }
    }
    return maxarea;
}

方法二：暴力以基准点向外遍历

int largestRectangleArea(int* heights, int heightsSize){
    int area = 0;
    int max = 0;
    if(heightsSize == 0)    { return 0;}
    for(int i = 0; i < heightsSize; i++) {
        int left = i;
        int right = i;
        while((left >= 0) && (heights[left] >= heights[i])) {
            left--;
        }       //向左遍历找到比基准点小的
        while((right < heightsSize) && (heights[right] >= heights[i])) {
            right++;
        }      //向右遍历找到比基准点小的
        area = heights[i] * (right-left-1);
        if(area > max) {
            max = area;
        }
    }
    return max;
}

好不容易自己写出来个 却超时了😑

方法三：维护栈

int largestRectangleArea(int* heights, int heightsSize){
    if(heightsSize == 0) {return 0;}
    if(heightsSize == 1) {return heights[0];}
    int stack[heightsSize + 1];   //创建栈
    stack[0] = -1;   //栈顶为-1
    int Index = 0;
    int MAXAREA = 0;
    int area = 0;
    for(int i = 0; i < heightsSize; i++) {
        while(Index != 0 && heights[stack[Index]] > heights[i]) {
            area = heights[stack[Index]] * (i - stack[Index-1]-1);
            if(area > MAXAREA) {MAXAREA = area;}
            Index--;
        }     //入栈元素大于栈内元素时入栈，使栈内形成递增序列
        stack[++Index] = i;
    }
    while(Index > 0) {
        area = heights[stack[Index]] * (heightsSize - stack[Index-1]-1);   //到达栈顶时，面积的计算
        if(area > MAXAREA) {MAXAREA = area;}
        Index--;
    }    
    return MAXAREA;
}