leetCode 36-40

79-单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true

class Solution {
    boolean result = false;
    int m;
    int n;
    int length;
    public boolean exist(char[][] board, String word) {
        m = board.length;
        n = board[0].length;
        length = word.length();
        //记录位置是否走过
        boolean[][] used = new boolean[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(result){
                    return result;
                }else if(board[i][j] == word.charAt(0)){
                    //0是当前匹配的字符数
                    dfs(board,used,i,j,0,word);
                }else{
                    continue;
                }
            }
        }
        return result;
    }
    public void dfs(char[][] board, boolean[][] used, int x, int y,int temp,String word){
        if(temp==length){
            result = true;
            return;
        }else if(result) return;
        //是否在范围内
        else if(x>-1&&x<m&&y>-1&&y<n){
            if(!used[x][y]&&board[x][y]==word.charAt(temp)){
                used[x][y] = true;
                //四个方向遍历
                dfs(board,used,x-1,y,temp+1,word);
                dfs(board,used,x,y-1,temp+1,word);
                dfs(board,used,x+1,y,temp+1,word);
                dfs(board,used,x,y+1,temp+1,word);
                //重置状态
                used[x][y] = false;
            }
        }
        else return;
    }
}

84-柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

import java.util.*;
public class HelloWorld {
    public int largestRectangleArea(int[] heights) {
        //以第i根柱子为最矮柱子（也就是以第i跟柱子为高）所能延伸的最大面积
        //以i 为中心，
        //向左找第一个小于 heights[i] 的位置 left_i
        //向右找第一个小于 heights[i] 的位置 right_i
        //即最大面积为 heights[i] * (right_i - left_i -1)(即范围是从当前值开始，到最后一个大于它的数：如【0,2,5,6,2】，5就是从5开始，到最后一个大于它的数6，面积=5*（4-1-1）=10)
        int res = 0;
        //维护一个单调递增的栈，就可以找到 left_i 和 right_i
        Deque<Integer> stack = new LinkedList<>();
        //这里新数组的第一个和最后一个值等于0，处理只剩下一个数的时候
        int[] new_heights = new int[heights.length+2];
        //复制heights
        for(int i=1;i<heights.length+1;i++){
            new_heights[i] = heights[i-1];
        }
        for(int i=0;i<new_heights.length;i++){
            //以此以当前值为中心，维护单调栈
            //找栈顶元素比现在new_heights[i]大的值，i为右边界
			System.out.println("i是"+i);
            while(!stack.isEmpty()&&new_heights[stack.peek()]>new_heights[i]){
                int cur = stack.pop();
				System.out.println(cur+"出栈");
				System.out.println("栈顶="+stack.peek());
				System.out.println("new_heights[cur]="+new_heights[cur]);
                //stack.peek()对应的是，当前值的前一个，因为当前值已经出栈
                res = Math.max(res,(i-stack.peek()-1)*new_heights[cur]);
				System.out.println("res="+res);
            }
			System.out.println(i+"进栈");
            stack.push(i);
        }
        return res;
    }
	public static void main(String[] args){
		HelloWorld test = new HelloWorld();
		int[] nums = new int[]{3,5,6,1,2,3};
		test.largestRectangleArea(nums);
	}
}
````java

执行结果：
i是0
0进栈
i是1
1进栈
i是2
2进栈
i是3
3进栈
i是4
3出栈
栈顶=2
new_heights[cur]=6
res=6
2出栈
栈顶=1
new_heights[cur]=5
res=10
1出栈
栈顶=0
new_heights[cur]=3
res=10
4进栈
i是5
5进栈
i是6
6进栈
i是7
6出栈
栈顶=5
new_heights[cur]=3
res=10
5出栈
栈顶=4
new_heights[cur]=2
res=10
4出栈
栈顶=0
new_heights[cur]=1
res=10
7进栈

85-最大矩形

给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

class Solution {
    /**
    这一题的算法本质上和84题Largest Rectangle in Histogram一样，
    对每一行都求出每个元素对应的高度，这个高度就是对应的连续1的长度，
    然后对每一行都更新一次最大矩形面积。那么这个问题就变成了Largest Rectangle in Histogram。
    本质上是对矩阵中的每行，均依次执行84题算法。
     */
    public int maximalRectangle(char[][] matrix) {
        if(matrix.length==0) return 0;
        int res = 0;
        int m = matrix.length, n = matrix[0].length;
        //维护一个数组记录连续1个数
        int[] heigths = new int[n];
        //记录每一行每一个点的高度（也就是上方连续1的个数），同时对每一行求最大连续矩阵面积
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                //如果当前值为0，则高度即为0，因为是连续1个数
                if(matrix[i][j]=='0'){
                    heigths[j] = 0;
                }else{
                    heigths[j] = heigths[j]+1;
                }
            }
            res = Math.max(res, largestRectangleArea(heigths));
        }
        return res;
    }
     public int largestRectangleArea(int[] heights) {
        int res = 0;
        Deque<Integer> stack = new LinkedList<>();
        int[] new_heights = new int[heights.length + 2];
        for (int i = 1; i < heights.length + 1; i++) new_heights[i] = heights[i - 1];
        //System.out.println(Arrays.toString(new_heights));
        for (int i = 0; i < new_heights.length; i++) {
            //System.out.println(stack.toString());
            while (!stack.isEmpty() && new_heights[stack.peek()] > new_heights[i]) {
                int cur = stack.pop();
                res = Math.max(res, (i - stack.peek() - 1) * new_heights[cur]);
            }
            stack.push(i);
        }
        return res;  
    }
}

94- 二叉树中序遍历

//递归
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}
//迭代
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.pop();
            list.add(node.val);
            root = node.right;
        }
        return list;
    }
}

96-不同的二叉搜索树

link

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        
        for(int i = 2; i < n + 1; i++)
            for(int j = 1; j < i + 1; j++) 
                dp[i] += dp[j-1] * dp[i-j];
        
        return dp[n];
    }
}