补充 hot 100 medium 题解

Author: kanglongba

src/com/alibaba/edison/AlgorithmDataStructure.java

@@ -10,6 +10,7 @@
  * offer/add添加元素；peek返回队列的头部元素，但是不出队；poll/remove返回并删除队列的头部元素。
  * [优先队列（PriorityQueue）常用方法及简单案例](https://blog.csdn.net/m0_37602827/article/details/100172976)
  * 6.PriorityBlockingQueue，线程安全版PriorityQueue，多线程环境，会阻塞其余线程
+ * 3.Queue(队列)->Deque(双端队列)->ArrayDeque，内部是数组
  *
  *
  * 位运算

src/com/alibaba/edison/LeetCode56.java

@@ -0,0 +1,56 @@
+package com.alibaba.edison;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.PriorityQueue;
+
+/**
+ * 合并区间，medium
+ * 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的
+ * 区间数组，该数组需恰好覆盖输入中的所有区间。
+ * <p>
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/7 11:17 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode56 {
+
+    /**
+     * 这种类型的题，没有套路。就是分析规律，然后用代码实现。
+     *
+     * @param intervals
+     * @return
+     */
+    public int[][] merge(int[][] intervals) {
+        //分析规律：先排序，再遍历
+        PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                return o1[0] - o2[0]; //升序
+            }
+        });
+        int length = intervals.length;
+        for (int i = 0; i < length; i++) {
+            queue.add(intervals[i]);
+        }
+        List<int[]> result = new ArrayList<>();
+        int[] temp = queue.poll();
+        while (!queue.isEmpty()) {
+            int[] next = queue.poll();
+            if (temp[1] >= next[1]) { //前一个区间完全包围后一个区间
+                temp = new int[]{temp[0], temp[1]}; //扩大范围，向后继续探索
+            } else if (temp[1] >= next[0]) { //建一个区间与后一个区间存在交集
+                temp = new int[]{temp[0], next[1]}; //扩大范围，向后继续探索
+            } else { //前一个区间与后一个区间，没有交集
+                result.add(temp); //前一个区间探索完毕，添加到结果列表
+                temp = next; //把下一个区间设置为探索区间，继续下一个循环
+            }
+        }
+        result.add(temp); //集合已经遍历完成，把最有一个区间添加到结果列表
+        int[][] array = new int[result.size()][]; //把list转化为数组
+        return result.toArray(array);
+    }
+}

src/com/alibaba/edison/LeetCode62.java

@@ -0,0 +1,47 @@
+package com.alibaba.edison;
+
+/**
+ * 不同路径，medium
+ * 一个机器人位于一个 m x n网格的左上角 （起始点在下图中标记为 “Start” ）。
+ * 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
+ * 问总共有多少条不同的路径？
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/8 1:36 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode62 {
+
+    /**
+     * 经典的动态规划
+     * <p>
+     * 由于机器人只能向右走和向下走，所以要想到达(m,n)，必须先到达(m,n-1)或(m-1,n)
+     * dp[i][j]，表示到达(i,j)的总路径
+     * 状态转移方程：dp[i][j] = dp[i][j-1] + dp[i-1][j]
+     * 边界条件：在左边和上边，只有一种走法
+     *
+     * @param m
+     * @param n
+     * @return
+     */
+    public int uniquePaths(int m, int n) {
+        if (m == 1 || n == 1) {
+            return 1;
+        }
+        int[][] dp = new int[m][n];
+        dp[0][0] = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == 0) {
+                    dp[i][j] = 1;
+                } else if (j == 0) {
+                    dp[i][j] = 1;
+                } else {
+                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}

src/com/alibaba/edison/LeetCode64.java

@@ -0,0 +1,45 @@
+package com.alibaba.edison;
+
+/**
+ * 最小路径和，medium
+ * 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
+ * 说明：每次只能向下或者向右移动一步。
+ * <p>
+ * 与LeetCode62，同样的思路
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/8 2:32 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode64 {
+
+    /**
+     * 凭直觉是动态规划
+     * <p>
+     * dp[i][j] 表示 到达(i,j)的路径和
+     * 状态转移方程：dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j] ，只能向下和向右移动
+     *
+     * @param grid
+     * @return
+     */
+    public int minPathSum(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] dp = new int[m][n];
+        for (int i = 0; i < m; i++) { //因为只能向下和向右移动，所以可以使用循环，因为循环也是按照从做到右，从上到下的顺序。使前面的计算结果正好可以给后面复用
+            for (int j = 0; j < n; j++) {
+                if (i == 0 && j == 0) { // 初始值
+                    dp[0][0] = grid[0][0];
+                } else if (i == 0) { //上边
+                    dp[i][j] = dp[i][j - 1] + grid[i][j];
+                } else if (j == 0) { //左边
+                    dp[i][j] = dp[i - 1][j] + grid[i][j];
+                } else {
+                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}

src/com/alibaba/edison/LeetCode75.java

@@ -0,0 +1,50 @@
+package com.alibaba.edison;
+
+/**
+ * 颜色分类，medium
+ * 给定一个包含红色、白色和蓝色、共n 个元素的数组nums，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
+ * 我们使用整数 0、1 和 2 分别表示红色、白色和蓝色。
+ * 必须在不使用库的sort函数的情况下解决这个问题。
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/8 3:06 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode75 {
+
+    /**
+     * 1.直接单个元素暴力冒泡
+     * 2.没有套路，只能分析规律，然后实现。双指针+团体冒泡。
+     *
+     * @param nums
+     */
+    public void sortColors(int[] nums) {
+        //团体冒泡，使目标团体一直紧贴着next元素，一步一步把目标团体冒上去。
+        for (int i = 2; i > 0; i--) { //一共三种元素，当把 2 和 1 排好了，0 自然也就排好了，所以只需要两次循环
+            int left = -1, right = -1; //双指针
+            for (int j = 0; j < nums.length; j++) { //开始团体冒泡
+                if (nums[j] == i) { //next是目标元素
+                    if (left == -1) { //以前未发现目标团体，则直接更新双指针
+                        left = j;
+                        right = j;
+                    } else { //以前发现了目标团体，直接扩充移动右边界指针，扩充团体
+                        right = j;
+                    }
+                } else if (nums[j] < i) { //next比目标元素小，所以应该把它移动团体的左边
+                    if (left == -1) { //左边还没有目标团体
+                        continue;
+                    } else { //左边已有目标团体，直接交换左指针和next
+                        int temp = nums[j];
+                        nums[j] = nums[left];
+                        nums[left] = temp;
+                        left++; //更新边界指针
+                        right++; //更新边界指针
+                    }
+                } else { //因为我们是先排大元素，再排小元素，所以如果遇到比目标团体大的next，说明已经后面已经都是排好序的元素，那么就直接结束本次冒泡
+                    break;
+                }
+            }
+        }
+    }
+}

src/com/alibaba/edison/LeetCode78.java

@@ -0,0 +1,49 @@
+package com.alibaba.edison;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 子集，medium
+ * 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
+ * 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/8 3:59 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode78 {
+
+    /**
+     * 又是探索所有的解，自然就会想到回溯法
+     *
+     * @param nums
+     * @return
+     */
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        result.add(new ArrayList<>()); //空集也是子集
+        List<Integer> combine = new ArrayList<>();
+        recursion(result, combine, nums, 0);
+        return result;
+    }
+
+    /**
+     * 递归探索
+     * @param result
+     * @param combine
+     * @param nums
+     * @param index 从第几个元素开始探索
+     */
+    public void recursion(List<List<Integer>> result, List<Integer> combine, int[] nums, int index) {
+        for (int i = index; i < nums.length; i++) {
+            combine.add(nums[i]);
+            List<Integer> temp = new ArrayList<>();
+            temp.addAll(combine);
+            result.add(temp); //每探索一步，都是一个子集
+            recursion(result, combine, nums, i + 1); //因为不能包含重复的元素，所以用过的元素就不能再用了，要从 i + 1 开始探索
+            combine.remove(combine.size() - 1); //回溯，探索另一条岔路
+        }
+    }
+}

src/com/alibaba/edison/LeetCode79.java

@@ -0,0 +1,78 @@
+package com.alibaba.edison;
+
+/**
+ * 单词搜索，medium
+ * 给定一个m x n 二维字符网格 board 和一个字符串单词word 。如果word 存在于网格中，返回 true ；否则，返回 false 。
+ * 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
+ * <p>
+ * <p>
+ * author: qonyqian
+ * created on: 2022/2/8 5:11 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode79 {
+
+    /**
+     * 这题好难呀，乍一看，完全没有思路
+     * <p>
+     * 不过这种探索类型的题目，没想法时，用回溯法准没错
+     *
+     * @param board
+     * @param word
+     * @return
+     */
+    public boolean exist(char[][] board, String word) {
+        int m = board.length;
+        int n = board[0].length;
+        boolean[][] visited = new boolean[m][n];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) { //以每个点为起点，依次探索
+                recursion(visited, m, n, i, j, board, word, 0); //递归探索
+                if (find) { //如果找到了，提前返回。
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    boolean find = false;
+
+    /**
+     * 递归探索单次
+     *
+     * @param visited
+     * @param m       矩阵的行
+     * @param n       矩阵的列
+     * @param x       将要探索元素的坐标
+     * @param y       将要探索元素的坐标
+     * @param board
+     * @param word
+     * @param index   探索 word 的第几个字符
+     */
+    public void recursion(boolean[][] visited, int m, int n, int x, int y, char[][] board, String word, int index) {
+        if (find) { //如果已经找到了，提前返回
+            return;
+        }
+        if (index == word.length()) { //word 已经探索完，成功找到
+            find = true;
+            return;
+        }
+        if (x < 0 || x > m - 1 || y < 0 || y > n - 1) { //元素坐标非法
+            return;
+        }
+        if (visited[x][y]) { //这个点已经探索过了，不能重复探索
+            return;
+        }
+        if (board[x][y] != word.charAt(index)) { //元素与 word 的字符不等
+            return;
+        }
+        visited[x][y] = true; //更新元素已经探索过
+        recursion(visited, m, n, x - 1, y, board, word, index + 1); //继续探索它的上
+        recursion(visited, m, n, x, y + 1, board, word, index + 1); //右
+        recursion(visited, m, n, x + 1, y, board, word, index + 1); //下
+        recursion(visited, m, n, x, y - 1, board, word, index + 1); //左
+        visited[x][y] = false; //回溯，恢复元素为未探索状态
+    }
+}

src/com/alibaba/edison/LeetCode96.java

@@ -0,0 +1,42 @@
+package com.alibaba.edison;
+
+/**
+ * 不同的二叉搜索树，medium
+ * 给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
+ *
+ * 二叉查找树（英语：Binary Search Tree），也称为二叉搜索树、二叉查找树、有序二叉树（ordered binary tree）或排序二叉
+ * 树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：
+ * 1.若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
+ * 2.若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
+ * 3.任意节点的左、右子树也分别为二叉查找树；
+ *
+ * 未能独立解答
+ *
+ * author: qonyqian
+ * created on: 2022/2/8 7:39 下午
+ * version：1.0
+ * description:
+ */
+public class LeetCode96 {
+
+    /**
+     * 二叉搜索树的中序遍历是升序的
+     *
+     * 感觉又是回溯法，探索所有可能。【卧槽，竟然是动态规划】
+     *
+     * @param n
+     * @return
+     */
+    public int numTrees(int n) {
+        int[] G = new int[n + 1];
+        G[0] = 1;
+        G[1] = 1;
+
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j <= i; ++j) {
+                G[i] += G[j - 1] * G[i - j];
+            }
+        }
+        return G[n];
+    }
+}