自定义博客皮肤VIP专享

*博客头图:

格式为PNG、JPG,宽度*高度大于1920*100像素,不超过2MB,主视觉建议放在右侧,请参照线上博客头图

请上传大于1920*100像素的图片!

博客底图:

图片格式为PNG、JPG,不超过1MB,可上下左右平铺至整个背景

栏目图:

图片格式为PNG、JPG,图片宽度*高度为300*38像素,不超过0.5MB

主标题颜色:

RGB颜色,例如:#AFAFAF

Hover:

RGB颜色,例如:#AFAFAF

副标题颜色:

RGB颜色,例如:#AFAFAF

自定义博客皮肤

-+

转载 每日一题算法: 2020年8月8日[恢复二叉搜索树] recoverTree

2020年8月8日恢复二叉搜索树 recoverTree/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, Tree

2020-08-08 23:19:51 9

原创 每日一题算法:2020年8月7日 [相同的树] isSameTree

2020年8月7日 相同的树 isSameTree/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode

2020-08-07 13:42:39 13

原创 每日一题算法:2020年8月6日 [回文对] palindromePairs

2020年8月6日 回文对 palindromePairsclass Solution { public List<List<Integer>> palindromePairs(String[] words) { }}解题思路:刚看到这题,思考了3、4分钟没有想到什么好的解决方案,只好先尝试使用暴力算法,暴力算法的时间复杂度非常高,不过在编写算法的过程中可能会有新的思路。暴力算法:public List<List<Integer&gt

2020-08-06 23:36:25 12

原创 每日一题算法:2020年8月5日 [打家劫舍 III] rob

2020年8月5日 打家劫舍 III rob/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public int rob(TreeNode root) {

2020-08-05 23:42:12 16

原创 每日一题算法:2020年8月4日 [课程表]canFinish

2020年8月4日 课程表 canFinishclass Solution { public boolean canFinish(int numCourses, int[][] prerequisites) { }}解题思路:首先要读懂题目,一开始我以为题目的介绍不够明确,有很多的疑问,然后去查阅资料,了解了什么是边缘列表表示的图形。因为给我们的数组是一个边缘列表,所以,二维数组的大小是N*2,每一个子数组都只有两个数字,也就是要修第一门课必须先修第二门课,这是一个有方向的关

2020-08-04 23:40:39 26

原创 每日一题算法:2020年8月3日 [字符串相加] addStrings

2020年8月3日 字符串相加 addStringsclass Solution { public String addStrings(String num1, String num2) { }}解题思路:可以模仿加法寄存器的方式,使用一位进制位来进行加法计算,从尾部开始读取数据。通过比较ASCII码来确定数字类型。这里可以通过使用StringBuilder或者自己实现StringBuilder的功能来降低时间复杂度 public String addStri

2020-08-03 22:22:49 10

原创 每日一题算法:2020年8月2日 [二叉树展开为链表] flatten

2020年8月2日 二叉树展开为链表 flatten/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNod

2020-08-02 21:59:19 783

原创 每日一题算法:2020年8月1日 [最小区间]smallestRange

2020年8月1日 最小区间 smallestRangeclass Solution { public int[] smallestRange(List<List<Integer>> nums) { }}解题思路:首先我们理解题意,要我们求什么?题目中给出了对于最小区间一词中“最小”的概念的定义。b-a<d-c那么 区间[a,b]小于[d,c],也就是数组[1,3]小于数组[1,4],这里的小是指能够表示的范围更小b-a==d-c时 a&l

2020-08-01 21:43:26 36

原创 每日一题算法:2020年7月31日 [魔术索引] findMagicIndex

2020年7月31日 魔术索引 findMagicIndexclass Solution { public int findMagicIndex(int[] nums) { }}解题思路:方法1,遍历这道题遍历解决起来非常简单,只需要循环比较A[i]和i的值就可以了。 public int findMagicIndex(int[] nums) { int len=nums.length; for(int i=0;i<len;i++

2020-07-31 23:34:19 37

原创 2020年7月30日 2020年7月30日 [整数拆分] integerBreak

2020年7月30日 整数拆分 integerBreakclass Solution { public int integerBreak(int n) { }}解题思路:这道题必定有他动态规划来解决的一种算法,不过实际上不需要那么麻烦,我们只需稍微总结一下规律就能发现。2=1*1=13=1*2=24=2*2=45=2*3=66=3*3=97=3*4=3*2*2=128=3*3*2=18我们把一个数字拆分成若干个数字,要保证这个乘积最大,那么这个被拆分出的数字必定

2020-07-30 22:51:00 23

原创 每日一题算法:2020年7月29日 [寻宝] minimalSteps

2020年7月29日 寻宝 minimalStepsclass Solution { public int minimalSteps(String[] maze) { }}解题思路:首先,我们整理一下流程。S->O->M->O->…->M->T我们可以把它分为两个过程。第一个过程:计算每一个机关到达离他最近的石碓的距离(动态规划),这个难度不大,之前也做过类似的。第二个过程,找到离起点最近的石碓以及终点遍历所有机关的最短距离。(动态

2020-07-29 21:26:53 12

原创 每日一题算法:2020年7月28日 [二叉树的最大深度]maxDepth

2020年7月28日 二叉树的最大深度 maxDepth/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public int maxDepth(TreeNode r

2020-07-28 22:01:27 40

原创 每日一题算法:2020年7月27日 判断子序列isSubsequence

2020年7月27日 判断子序列 isSubsequenceclass Solution { public boolean isSubsequence(String s, String t) { }}解题思路:初级解法:同时遍历长数组t和段数组s,从短数组的第一个开始,如果在数组t中找到相同的字符,则对字符数组的s下一个字符进行查询。代码实现: public boolean isSubsequence(String s, String t) { i

2020-07-27 21:34:08 11

原创 每日一题算法:2020年7月26日 [矩阵中的最长递增路径] longestIncreasingPath

2020年7月26日 矩阵中的最长递增路径 longestIncreasingPathclass Solution { public int longestIncreasingPath(int[][] matrix) { }}解题思路:这道题还是使用动态规划+递归的思想,首先使用递归+遍历的方式,计算每一个节点作为起点时最大的长度。比如下面图所示。递归步骤:第一步,坐标(0,0)寻找周围四个点的值进行判断,先根据大小分为以下两种情况。1:大于该点的值2:小于该点的

2020-07-26 23:32:12 12

原创 每日一题算法:2020年7月25日 [分割数组的最大值 ]splitArray

2020年7月25日 分割数组的最大值 splitArrayclass Solution { public int splitArray(int[] nums, int m) { }}解题思路:首先,这道题是指分割连续的数组,而不是取出数组中的值来组成新的数组。如果是用元素来组成,那么这案例的答案应该就是[7,8][10,5,2] 最小和17思路1暴力递归:数组nums需要切割成4组。遍历前1个字符单独切割到前len-3个字符的情况,并且每种情况将剩余的数组和3进

2020-07-25 23:16:17 9

原创 2020年7月24日 2020年7月24日 [除数博弈]divisorGame

2020年7月24日 除数博弈 divisorGameclass Solution { public boolean divisorGame(int N) { }}解题思路:首先,我们已知2时爱丽丝胜,3是鲍勃胜。我们继续推测:4:4可以变为2和3,选择变为2会导致鲍勃选择后自己输掉,所以必定会选择变为3,此时爱丽丝胜5,5只能变成4,变成4之后鲍勃会获胜然后,我们找到一个规律,由于使用以下操作选出任一 x,满足 0 < x < N 且 N % x =

2020-07-24 08:52:49 15

原创 每日一题算法:2020年7月23日 [最小路径和]minPathSum

2020年7月23日 最小路径和 minPathSumclass Solution { public int minPathSum(int[][] grid) { }}解题思路:这道题和之前写的两道题几乎一模一样,首先思路是使用dp动态规划,从末尾开始,遍历所有点,判断该点到达右下角时的的最小路径。dp的思路是这样的右下角的左边[2,2]的点,先计算最下面一行到达[2,2]的最短距离由于只能向右移动,所以很明显只有唯一的结果。之后我们判断第二行,第二行都是第三列只能

2020-07-23 21:05:15 13

原创 每日一题算法:2020年7月22日 [旋转数组的最小数字]minArray

2020年7月22日 旋转数组的最小数字 minArrayclass Solution { public int minArray(int[] numbers) { }}解题思路:这道题看起来很简单,实际上有一个非常大的坑在里面,而且这个坑非常难发现。这个坑不再题目中,而是存在于注意后面的连接里。为什么一道简单的题会和一道困难的题相同?这道题到底有哪里比较特殊?普通的算法:遍历数组找到最小的值,这个值必定是数组的最小值。进阶的算法:二分查找法。快速

2020-07-22 23:31:25 14

原创 每日一题算法:2020年7月21日 [不同的二叉搜索树 II] generateTrees

2020年7月21日 不同的二叉搜索树 II generateTrees/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int va

2020-07-21 22:14:35 16

原创 每日一题算法:2020年7月20日 [两数之和 II - 输入有序数组]twoSum

2020年7月20日 两数之和 II - 输入有序数组 twoSumclass Solution { public int[] twoSum(int[] numbers, int target) { }}解题思路:暴力破解,每一个数和其他所有数进行求和,这样就能找到结果了。这个方法太笨了,不稀罕用。使用双指针,一个放在头部,一个放在尾部,先根据头部的值算出尾部最大允许的值。比如头部为10,target=50,那么就找到尾部小于等于40的第一个值。然后继

2020-07-20 21:31:39 10

原创 每日一题算法:2020年7月19日 [戳气球] maxCoins

2020年7月18日 交错字符串 isInterleaveclass Solution { public boolean isInterleave(String s1, String s2, String s3) { }}解题思路:之前已经做了几次类似的题目,某一个字符串是否由某一个字典中的单词组成的,都有一个比较难解决的点,就在于可能出现重复的字符匹配,需要递归所有可能的情况,在本题中就可能出现下面的情况我们判断出s3中的a来自于s1,e来自于s2,但是之后的b就需要判断

2020-07-18 22:31:17 36

原创 每日一题算法:2020年7月17日 [搜索插入位置] searchInsert

2020年7月17日 搜索插入位置 searchInsert默认格式:class Solution { public int searchInsert(int[] nums, int target) { }}解题思路:这道题,太简单了吧,非常标准的二分查找啊。public int searchInsert(int[] nums, int target) { int max=nums.length-1; if (max

2020-07-17 22:12:42 42

原创 每日一题算法: 2020年7月16日 [判断二分图] isBipartite

2020年7月16日 判断二分图 isBipartite默认格式:class Solution { public boolean isBipartite(int[][] graph) { }}解题思路:这道题比较抽象,我们先尽可能多地挖掘信息。graph[i]表示的是和i相连的点的值。比如题中的graph[0]={1,2,3}表示0和1,2,3相连所有的数都是连续的,并且不会出现重复。问题1:什么叫做分割为两个独立的子集。也就是所谓的二分图。特点有以下两点。每

2020-07-16 22:37:36 14

原创 每日一题算法:2020年7月15日 不同的二叉搜索树 numTrees

2020年7月15日 不同的二叉搜索树 numTrees默认格式:class Solution { public int numTrees(int n) { }}解题思路:这道题我觉得应该是可以找到规律的,可以直接通过公式来计算种类数。。。。找不出规律,所以还是老老实实想解题的方法吧。首先需要注意的一点,这道题说的是一个搜索树,搜索树的特点就是,父节点的左子树都比父节点小,父节点的右子树都比父节点大。递归:一个连续n个的连续整数,求搜索树种类数,那么就相当于求以1、2、3

2020-07-15 22:46:44 23

原创 每日一题算法: 2020年7月14日 [三角形最小路径和]minimumTotal

2020年7月14日 三角形最小路径和 minimumTotal默认格式:class Solution { public int minimumTotal(List<List<Integer>> triangle) { }}解题思路:我一眼就看出你是dp!拆解问题!定义状态!推导方程!代码实现逻辑!一个节点的值向下传递能够传递给第n个和第n+1个,那么反过来,第n个元素向上传递是由第n-1个和第n个较小的那一个累加得到的。我们从最后一层开始判断,

2020-07-14 17:04:44 28

原创 每日一题算法:2020年7月13日 [两个数组的交集 II] intersect

2020年7月13日 两个数组的交集 II intersect默认格式:class Solution { public int[] intersect(int[] nums1, int[] nums2) { }}解题思路:使用哈希Map来存储一个数组,键为数组中的值,值为出现的次数。然后遍历另外一个数组,如果在哈希表中存在,那么就加入结果集中,并且哈希表中的值-1,如果等于0就在哈希表中删除,如果不存在则不加入结果交集中。代码部分: public int[] i

2020-07-13 13:48:32 34

原创 每日一题算法:2020年7月12日 [地下城游戏] calculateMinimumHP

2020年7月12日 地下城游戏 calculateMinimumHP默认格式:class Solution { public int calculateMinimumHP(int[][] dungeon) { }}解题思路:1,动态规划前几天计算过一个不同路径的算法题,其实和这道题是差不多的,动态规划的核心思想,n位上的值是可以由n-1推理得到的。这里需要注意的是,我们需要计算的是整个过程中的最低健康点数,也就是-5->10->3 这个流程中最低健康点数是6

2020-07-12 23:15:24 35

原创 每日一题算法: 2020年7月11日 [计算右侧小于当前元素的个数] countSmaller

2020年7月11日 计算右侧小于当前元素的个数默认格式:class Solution { public List<Integer> countSmaller(int[] nums) { }}解题思路:1,暴力破解第n个元素遍历后面len-n个元素,找到比他本身小的个数。意料之中。 public List<Integer> countSmaller(int[] nums) { if(nums==null)

2020-07-11 22:12:24 24

原创 每日一题算法:2020年7月10日 [最佳买卖股票时机含冷冻期] maxProfit

2020年7月10日 最佳买卖股票时机含冷冻期 maxProfit默认格式:class Solution { public int maxProfit(int[] prices) { }}解题思路:首先,看一看能否使用动态规划的方式来做该题。第n天获得的最大利益和第n-1天有关系吗?没有,那就没有办法做动态规划。1,暴力迭代第1天买入,第2、3、4、5…最后一天卖出,计算出最低收入。然后计算第二天买入的最低收入。第二天买入的比第一天买入的收入高计算第三天买入的收

2020-07-10 23:12:52 52

原创 每日一题算法: 2020年7月9日 面试题 17.13. 恢复空格 respace

2020年7月9日 面试题 17.13. 恢复空格 respace默认格式:class Solution { public int respace(String[] dictionary, String sentence) { }}解题思路:前几天写过一个差不多的,拆分单词。如果只是做判断其实很简单,遍历数组,每个单词去字典里找是否有以该单词开头的,如果有的话就继续,没有的话记录为无法匹配,然后继续算,找出所有的无法匹配的。实际上,难点是存在于如何控制条件而减少匹配的次数

2020-07-09 22:04:18 53

原创 每日一题算法:2020年7月8日 面试题 16.11. 跳水板 divingBoard

2020年7月8日 面试题 16.11. 跳水板 divingBoard默认格式:class Solution { public int[] divingBoard(int shorter, int longer, int k) { }}解题思路:这道题也太简单了,必须使用k块板的约定导致了组合数是固定的0s+kl,1s+(k-1)l,…ks+0l一共k+1种,并且这些组合在s不等于l的情况下是不会重复的。因为:设一个方程:L=xs+(k-x)l 他是单调递减的一个函数

2020-07-08 09:17:37 63

原创 每日一题算法:2020年7月7日 路径总和 hasPathSum

2020年7月7日 路径总和 hasPathSum默认格式:/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean hasPathSum(

2020-07-07 21:15:07 24

原创 每日一题算法:2020年7月6日 不同路径 II uniquePathsWithObstacles

2020年7月6日 不同路径 II uniquePathsWithObstacles默认格式:class Solution { public int uniquePathsWithObstacles(int[][] obstacleGrid) { }}解题思路:感觉这道题可以使用动态规划来做,我们从一个点的角度上来看,如果他同时能够向右和向下移动,那么道路的选择就多了一条。如果只有一个可以选择,那么道路数不变,如果下和右都是障碍,那么表示当前位置没有道路可以选择。图解:动

2020-07-06 22:40:04 18

原创 每日一题算法:2020年7月5日 通配符匹配 isMatch

2020年7月5日 通配符匹配 isMatch默认格式:class Solution { public boolean isMatch(String s, String p) { }}解题思路:这道题前几天看到过类似的,叫做正则表达式。区别在于,上一次需要匹配上一个字符,使用.来表示任意某个字符,使用*表示任意个之前那一个元素。也没有用到什么特殊的思想,所以也没有什么可以借鉴的,这次还是要自己来理清逻辑。不过上一次我没有写出来。但是这次的比较简单,我相信我一定能够做出来

2020-07-05 22:04:12 25

原创 每日一题算法:2020年7月4日 最长有效括号 longestValidParentheses

2020年7月4日 最长有效括号 longestValidParentheses默认格式:class Solution { public int longestValidParentheses(String s) { return 0; }}解题思路:这道题感觉没有困难的难度啊,这不就是使用简单的栈的思想就能实现的吗?插入的是右括号的情况下,如果栈顶是左括号就弹出,否则就压入。这样计算弹出的个数,就能知道匹配的长度是多少了。仔细一想并不是这样,因为使用该方式得

2020-07-04 20:13:44 29

原创 每日一题算法:2020年7月3日 将有序数组转换为二叉搜索树 sortedArrayToBST

2020年7月3日 将有序数组转换为二叉搜索树 sortedArrayToBST默认格式:/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeN

2020-07-03 21:36:33 34

原创 每日一题算法:2020年7月2日 [有序矩阵中第K小的元素]kthSmallest

2020年7月2日 有序矩阵中第K小的元素 kthSmallest默认格式:class Solution { public int kthSmallest(int[][] matrix, int k) { }}解题思路:维护一个数组记录每一行当前的位置。遍历这个数组,找到原数组中实际值的最小坐标,维护数组中的位置后移一位。起始状态:找一个最小值,地址+1找下一个最小值,地址+1找第三个最小值,地址+1预计时间复杂度(K*N)空间复杂度(N)这么做有一个问题

2020-07-02 22:20:03 35

原创 每日一题算法:2020年7月1日 最长重复子数组 findLength

2020年7月1日 最长重复子数组 findLength默认格式:class Solution { public int findLength(int[] A, int[] B) { }}解题思路:1,暴力算法遍历数组1中的每一个元素用这个元素和数组2的每一个元素对比,如果相同循环读取两个数组的下一个元素,直到不相同为止这个算法太复杂,就不做实现了。2,使用哈希表+链表遍历一遍数组1,将其每个元素出现的位置存入到一个List中,然后存入hashmap中。遍历数

2020-07-01 21:40:56 21

原创 每日一题算法:2020年6月30日 用两个栈实现队列 CQueue

2020年6月30日 用两个栈实现队列 CQueue默认格式:class CQueue { public CQueue() { } public void appendTail(int value) { } public int deleteHead() { }}/** * Your CQueue object will be instantiated and called as such: * CQueue obj

2020-06-30 21:21:46 21

原创 每日一题算法:2020年6月29日 数组中的第K个最大元素 findKthLargest

2020年6月29日 数组中的第K个最大元素 findKthLargest默认格式:class Solution { public int findKthLargest(int[] nums, int k) { }}解题思路:这不就是直接排序吗?那用这方法不就等于在用暴力算法吗?所以作为一道中等难度的题目,必定有它巧妙的地方存在。目前想到能够实现的最好的方法。先对前k项进行一次冒泡排序,找到最小的元素就是第k大的元素。一个新元素出现,先判断是否比第k个元素大,如果比第k

2020-06-29 13:56:08 59

提示
确定要删除当前文章?
取消 删除