Rabbit-Sir的博客

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;public class OneHundred { public boolean isSameTree(TreeNode p, TreeNode q) { if (p == null && q == null) return true; if (p == null || q == null)

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;import java.util.HashMap;public class ThreeHundredsAndThirtySeven { public int rob(TreeNode root) { HashMap<TreeNode, Integer> hashMap = new HashMap<>(); retur

package LeetCode.OneToFiveHundred;public class FourHundredsAndFourteen { public String addStrings(String num1, String num2) { // 用 StringBuffer 方便操作 StringBuffer sb = new StringBuffer(""); // 用双指针，根据加法法则，我们从后往前加，从 carry 来保存进位

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;import java.util.ArrayList;import java.util.List;public class OneHundredAndFourteen { private List<TreeNode> ans = new ArrayList<>(); public void flatten(TreeNode root) {

package LeetCode.面试题;public class FindMagicIndex { public int findMagicIndex(int[] nums) { return helper(nums,0,nums.length - 1); } private int helper(int[] nums, int left, int right){ // 前提条件 if (left > right) retu

今天的没啥说的 public int maxDepth(TreeNode root) { if (root == null) return 0; else { // 直接进行递归，找到左右中最大的返回 int left = maxDepth(root.left); int right = maxDepth(root.right); return Ma

package LeetCode.OneToFiveHundred;import java.util.Arrays;public class FourHundredsAndForty { // dp public int splitArray(int[] nums, int m) { int len = nums.length; // 存储每次最小值 int[][] dp = new int[len + 1][m + 1];

package LeetCode.OneThousandMore;public class OneThousandAndTwentyFive { public boolean divisorGame(int n) { // 用dp boolean[] dp = new boolean[n + 1]; // 因为先手 0 和 1 必输，没有选择 dp[0] = dp[1] = false; // 进行遍历，寻找可以赢的

package LeetCode.OneToFiveHundred;public class SixtyFour { // 记忆答案 private int[][] ans; public int minPathSum(int[][] grid) { int m = grid.length, n = grid[0].length; ans = new int[m][n]; // 进行搜索 return dfs(gri

package LeetCode.剑指offer;public class MinArray { public int minArray(int[] numbers) { int start = 0, end = numbers.length - 1; while (start < end){ // 防止除法运算出错 int mid = (end - start) / 2 + start;

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;import java.util.LinkedList;import java.util.List;public class NinetyFive { public List<TreeNode> generateTrees(int n) { if (n == 0) return new LinkedList<TreeNode>()

package LeetCode.OneToFiveHundred;public class OneHundredAndSixtySeven { public int[] twoSum(int[] numbers, int target) { int len = numbers.length; if (len == 0) return new int[]{-1, -1}; for (int i = 0; i < len; i++){

package LeetCode.OneToFiveHundred;import java.util.Arrays;public class ThirtyFive { public int searchInsert(int[] nums, int target) { int len = nums.length; if (len == 0) return 0; // 可以进行查找，如果有的话，直接就返回能节省时间 int temp

public int numTrees(int n) { // 每个节点都可能做跟，所以有 n 种可能 // 当每个节点做跟的时候，左边共有 1 - i 个节点，右边共有 n - i 个节点 int[] dp = new int[n + 1]; // 边界处理，我们已知当 n 等于0或1的时候只有一种情况 dp[0] = 1; dp[1] = 1; // 状态转换方程为 f[i] += f...

package LeetCode.OneToFiveHundred;import java.util.Arrays;public class ThreeHundredsAndFifty { public int[] intersect(int[] nums1, int[] nums2) { int m = nums1.length, n = nums2.length; // 为空的情况 if (m == 0 || n == 0) return

package LeetCode.OneToFiveHundred;public class OneHundredAndSeventhFour { // 记忆每次计算之后最小值 int[][] memo; public int calculateMinimumHP(int[][] dungeon) { int m = dungeon.length, n = dungeon[0].length; memo = new int[m][n];

图片来源图解：先上代码package study;public class Dijkstra { public int[] getShortestPaths(int[][] adjMatrix){ int len = adjMatrix.length; // 用于存放顶点 o 到其他顶点的最小距离 int[] result = new int[len]; // 表示是否遍历过 boolean[]

package LeetCode.面试题;import java.util.HashMap;import java.util.Map;public class Respace { public int respace(String[] dictionary, String sentence) { // 进行暴力寻找，找到字典中所有的能被找到的单词的长度 int len = sentence.length(); Map<String, I

package LeetCode.面试题;public class DivingBoard { public int[] divingBoard(int shorter, int longer, int k) { if (k == 0) return new int[0]; if (shorter == longer) return new int[]{longer * k}; // 上面很好解释，一个是不用构建，因为 k 是0，另一个是长短相等，

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;public class OneHundredAndTwelve { public boolean hasPathSum(TreeNode root, int sum) { // 进行递归搜索 if (root == null) return false; // 特殊情况判断 if (root.left == n

package LeetCode.OneToFiveHundred;public class SixthThree { public int uniquePathsWithObstacles(int[][] obstacleGrid) { int m = obstacleGrid.length, n = obstacleGrid[0].length; int[] dp = new int[n]; // 判断 [0][0] 是不是障碍

package LeetCode.OneToFiveHundred;public class ThirtyTwo { public int longestValidParentheses(String s) { // 默认将‘（’置为 0 int max = 0; char[] cs = s.toCharArray(); int len = s.length(); int[] dp = new int[len];

package LeetCode.OneToFiveHundred;import LeetCode.TreeNode;public class OneHundredAndEight { public TreeNode sortedArrayToBST(int[] nums) { // 平衡二叉树的中序遍历是从小到大的，我们可以反向构造平衡二叉树 return inverseMiddleOrderTraversal(nums ,0 , nums.length -

今天先挖坑，明天来填归并排序的解法package LeetCode.OneToFiveHundred;import java.util.Arrays;public class ThreeHundredsAndSeventyEight { public int kthSmallest(int[][] matrix, int k) {// // 暴力法// int len = matrix.length;// int[] nums = new i

package LeetCode.FiveHundredOneToOneThousand;public class SevenHundredAndEighteen { public int findLength(int[] a, int[] b) {// // 暴力法// int ans = Integer.MIN_VALUE;// for (int i = 0; i < a.length; i++){// for (

package LeetCode.OneToFiveHundred;import java.util.Arrays;public class Sixteen { public int threeSumClosest(int[] nums, int target) { // 排序，然后固定一个数，从后一个到末尾开始寻找 Arrays.sort(nums); int ans = nums[0] + nums[1] + nums[2];

package LeetCode.OneToFiveHundred;public class Fourteen { public String longestCommonPrefix(String[] strS) { // 暴力法破解，第一个字符串的长度进行遍历，与后面的所有的字符串进行对比 if (strS == null || strS.length == 0) return ""; int len = strS[0].length();

package LeetCode.OneThousandMore;import java.util.Arrays;public class OneThousandAndThreeHundreds { public int findBestValue(int[] arr, int target) { // 思路是：先排序，然后按照四舍五入规则求取target与当前size-i个元素的整数平均值m。 // 如果，平均值小于等于当前arr[i],即最小值，则说明，v

package LeetCode.OneToFiveHundred;import java.util.ArrayList;import java.util.Arrays;import java.util.List;public class Fifteen { public List<List<Integer>> threeSum(int[] nums) { // 这道题，我们要判度三数之和是否为0，我们可以对数组进行排序，对数组进行遍历

package LeetCode.FiveHundredOneToOneThousand;import java.util.Deque;import java.util.LinkedList;public class SevenHundredAndThirtyNine { public int[] dailyTemperatures(int[] t) { // 我们用栈将 t 的下标进行记录，如果栈顶的值比栈底的值大，我们就移除比他大的数，并将两个下标相减进行记录

这题没啥写的package LeetCode.OneToFiveHundred;public class Nine { public boolean isPalindrome(int x) { String str = String.valueOf(x); StringBuffer sb = new StringBuffer(str); sb.reverse(); StringBuffer sb1 = new StringBuff

package LeetCode.剑指offer;public class TranslateNum { public int translateNum(int num) { // 这道题我们可以首先把每个下标看成单独的数字进行翻译，然后和它的前一位进行合并 // 看他们是否合法，即前一位和当前为组合为 10 - 25，如果合法，就将其进行统计，否则就不计数 String str = String.valueOf(num); //

昨天的每日一题太难了，没费工夫看，就没写题解package LeetCode.FiveHundredOneToOneThousand;public class NineHundredAndNinety { public boolean equationsPossible(String[] equations) { // 把所有的式子用无向图来表示，用下标和内容来表示他们和它们的父节点 // 最初的父节点是自己，所以要进行初始化，然后把所有图的关系表示进去，下标代

挖坑，明天填，今天配置Clion的opencv配置了五六个小时还没好，哎，烦死了class Solution { public int longestConsecutive(int[] nums) { Set<Integer> num_set = new HashSet<Integer>(); for (int num : nums) { num_set.add(num); } int

package LeetCode.OneThousandMore;public class OneThousandOneHundredAndTwentyTwo { public int[] relativeSortArray(int[] arr1, int[] arr2) { // 进行计数排序 // 因为题目中最长长度为 1000 int [] nums = new int[1001]; // 将所有的数据都存入桶中

package LeetCode.OneToFiveHundred;public class TwoHundredAndThirtyEight { public int[] productExceptSelf(int[] nums) { // 我们可以记录每个下标的左右的值，然后计算每个下标左右值相乘即可 int len = nums.length; // 我们用answer记录左边的值相乘的结果 int[] answer = ne

package LeetCode.FiveHundredOneToOneThousand;public class EightHundredAndThirtySeven { public double new21Game(int N, int K, int W) { // 从 1 - w 抽卡，当大于 n 的时候小于 k 的概率 // 我们从最后一格开始计算几率，每次抽卡的概率都是 1/w，在 N 之前我们都可以一次抽卡就达到 // N 之后不行，

package LeetCode.FiveHundredOneToOneThousand;public class EightHundredAndSixtySeven { public int[][] transpose(int[][] a) { // 按照题目所说将矩阵按照对角线进行转置 // 就是将原矩阵的行和列进行转换，所以我们直接把原矩阵复制，将原来的XY进行转置即可 int[][] answer = new int[a[0].length

package LeetCode.OneThousandMore;import java.util.ArrayList;import java.util.List;public class OneThousandFourHundredAndThirtyOne { public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) { // 这是一道很简单的题目，我们可以将找出所有孩子中拥有糖

package LeetCode.FiveHundredOneToOneThousand;public class SevenHundredAndSeventhFive { public boolean isIdealPermutation(int[] a) { // 只要是局部倒置，就说明是全局倒置，所以我们可以找出非局部倒置 // 我们可以计算出每个区间的最小值，只要检查a[i] > a[i + 2:](Python语法，表示从i+2到数组末尾)、