悲伤的小霉的博客

题目描述：解题思路：因为存在一个ans比这个ans小的一定不能按照规定运送完货物，比ans大的一定能按照规定运送完，所以ans可以通过二分查找来确定。左边界和右边界分别是数组中最大值，和数组总和。参考代码： public int shipWithinDays(int[] weights, int D) { int l=0,r=0; for (int i = 0; i < weights.length; i++) { l=Math

题目描述：解题思路：先中序遍历保存所有节点的信息，然后模拟构建。 List<Integer> list=new ArrayList<>(); public TreeNode increasingBST(TreeNode root) { LDR(root); TreeNode resTree=new TreeNode(list.get(0)); TreeNode temp=resTree;

题目描述：解题思路：这是一道简单的dp，转移方程是dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);当前偷窃到的金额等于前面[i-2]偷到的金额，加上这次要偷窃的，也就是说这次偷加上隔一个前面偷，或者这次不偷加上前一次偷，这两个情况取最大值。参考代码： public int rob(int[] nums) { if(nums.length<=2){ if(nums.length<=1)

153.寻找旋转排序数组中的最小值33. 搜索旋转排序数组81. 搜索旋转排序数组 II33. 搜索旋转排序数组解题思路：这些题都是利用二分查找的思想，因为本来有序的数组，在经过旋转后，分成了两部分各自有序的排列，在旋转后的数组中寻找一个target，可以证明的是target一定会落在一个有序的区间内，那么只需要去确定这个区间就可以了。nums[mid] > nums[left]) { //前半部分有序中间的这个值大于left，根据数组是有序旋转得到的，说明落到了前半部分有序的地方，例如

题目描述：解题思路：1、这道题一开始想尝试用dfs去解决，但是边界和判断的地方一直有问题，但是dfs是肯定能解开的，调试了好久，最终过了，但是解法的效率很低。2、看别人的题解，分别有O(n+m)和O(1)的解法。3、我也太菜了。参考代码：dfs int[][] res; boolean[][] pan; int[][] arr; public void setZeroes(int[][] matrix) { this.res = matrix;

题目描述：解题思路：利用栈，记录数字前的符号，遇到+号就将数字压入栈中，-号就将数字的相反数压入栈中，遇到乘除，需要将栈顶数字取出后进行运算再放入栈中，最后将栈里元素相加即可。注意整数的个数不止有一位，所以要先将遍历的字符存起来。参考代码： public int calculate(String s) { char[] c = s.toCharArray(); Stack<Integer> stack = new Stack<>();

题目描述：解题思路：首先将两个字符串的差值存入数组，然后根据滑动窗口的思想，利用双指针解题，定义变量来储存left和right区间内的总和，因为窗口是一个只增大，不减小的，所以当总和小于等于maxcost的时候，就让right++窗口增大，反之，则让left++，同时因为窗口不可能变小，所以right也要++，同时更新总和，这样最后的窗口大小就是该题目的答案，可以在增大窗口的时候设置变量，也可以直接让length减去left的位置都正确。这道题需要注意的地方是判断小于还是小于等于的地方容易搞错，需

题目描述：解题思路：利用双指针或者滑动窗口解决，只是在最基础的滑动窗口上面加了个k，在判断的时候，只需要历史最长的连续序列+k即可。参考代码： public int characterReplacement(String s, int k) { int[] map=new int[26]; char[] c=s.toCharArray(); if(s.length()<=0) { return 0;

题目描述：解题思路：遍历链表，按照大小分成两个链表，然后将两个合并。参考代码： public ListNode partition(ListNode head, int x) { ListNode smallHead=new ListNode(); ListNode bigHead=new ListNode(); ListNode smallTail=smallHead; ListNode bigTail=bigHead;

题目描述：解题思路：这道题之前用贪心写的，没去看dp的解法，现在补上。甜姨题解参考题解： public int maxProfit(int[] prices) { int dp[][]=new int[prices.length][2]; //[i][0]不持有 //[i][1]持有 dp[0][0]=0; dp[0][1]=-prices[0]; for (int i = 1; i <

题目描述：解题思路：这道题贪心的去写，一开始暴力，超时了。甜姨的题解从前面往后面寻找，找到第一个str[i]>str[i+1],就将str[i]-1，后面位置全部变成9，但是有特殊情况，比如2333332，这就需要把第一个最大3变成2，然后后面的全变成9，res = 2299999，也就是从开始找，最大的数，但是要index值最小，一旦找到str[i]>str[i+1]的时候，就可以执行操作了，然后break。参考代码： public static int monotone

题目描述：解题思路：给定一个翻转方案，则它们之间任意交换顺序后，得到的结果保持不变。因此，我们总可以先考虑所有的行翻转，再考虑所有的列翻转。为了使最大，第一列要先全变成1，然后后面的列，如果0比1多，就变换。参考代码： public static int matrixScore(int[][] A) { //更改第一列 for (int i = 0; i < A.length; i++) { if(A[i][0]!=1)

题目描述：解题思路：12月是贪心月，难受参考代码： public List<Integer> splitIntoFibonacci(String S) { List<Integer> res=new ArrayList<>(); backtrack(S.toCharArray(),res,0); return res; } private boolean backtrack(char[]

题目描述：解题思路：每一行第一个和最后一个数是1，中间的数等于上一行的(index-1)+index参考代码： public List<List<Integer>> generate(int numRows) { List<List<Integer>> res=new ArrayList<>(); for (int i = 0; i <numRows ; i++) {

题目描述：解题思路：10^6的数据范围，暴力超时了，需要用素数筛，欧拉筛看了几篇博客没看懂，还有另一种埃氏筛，就是先把所有都当成质数，然后从2开始他的倍数都标记为合数，csdn看半天，不如去看甜姨的题解，动图一下子就明白了，至于原理，不证明也行，会用就行。参考代码： public int countPrimes(int n) { boolean[] isprime = new boolean[n]; int count=0; Arrays.fi

题目描述：原题链接解题思路：这道题类似与leetcode的第三题求无重复字符的最长子串，利用滑动窗口的思想，去不断更新left，维护max从一开始遍历整个字符串，每次遍历到就添加进去，添加进去后判断是否包含n p y三个字母，如果不是全部包含，max = Math.max(max,i-left+1);维护max的值即可，如果都包含了，就找到n p y 三个字母那个位置再最左边，也就是位置坐标最小的一个，将left指针更新到该处+1即可，然后还是维护max的值。参考代码： public

题目描述：解题思路：一开始用暴力写了，没注意到题目要 O(log n)，然后这道题一看复杂度，而且是有序的，就要想到二分。但是这道题要考虑开始位置和结束位置不同二分，也就是找左边界的时候，要找到最左边，就是当mid等于target的时候，也要继续向左找，相反，对于右边界也是一样。这里注意一下二分的坑，就是需要注意mid的下取整，mid要变成int mid = left + (right - left + 1) / 2;这里需要多调试才能有熟练。可以去看liweiwei的视频更好理解参考代码：

题目描述：解题思路：这道题利用哈希表做。可以讲4个数组分成2个map,每一个map用双重for循环，所有相加的和保存到Key中，如果出现多个相同，则Value+1，当两个是相反数的时候，说明符合条件，具体其实一个map就可以实现了。参考代码： public int fourSumCount(int[] A, int[] B, int[] C, int[] D) { HashMap<Integer, Integer> map = new HashMap<&g

题目描述：解题思路：1、 一开始做这道题，我思路想错了，以为是合并区间后，然后看还有多少个区间就是答案。其实这道题不是这样的。因为前面如果按照合并区间后，可能出现几个区间需要多个子弹射击才能符合条件，但是由于前面吧区间合并了，所有最后计算的时候也会出错。这道题正确的做法，是按照右端端点升序排序后利用贪心。重点是要理解为什么用右端排序。2、 右端升序排序后，第一个区间的结束位置和下一个区间的开始位置比较，如果比下一个区间小的话，说明两个区间不连续，无法做到一个子弹射击掉，所有count++,然

题目描述：解题思路：第一种方法，统计零的个数，然后重构数组第二种方法，双指针，其实和第一种方法差不多。第三种方法，利用快排的思路，遍历一次。参考代码： public void moveZeroes(int[] nums) { int zc=0; for (int i = 0; i < nums.length; i++) { if(nums[i]==0) zc++; } i

题目描述：参考代码： public static int canCompleteCircuit(int[] gas, int[] cost) { int len=gas.length; //每一个节点可以走到终点，就放入index否则放入-1；最后返回数组中最大的元素即是答案 int f=-1; int[] res=new int[len]; int count; for (int i = 0;

题目描述：解题思路：方法一：直接排序,根据曼哈顿距离，lambda表达式写法很简单。方法二：BFS（待补充）方法三：桶排序（待补充）参考代码： public int[][] allCellsDistOrder(int R, int C, int r0, int c0) { int[][] re = new int[R * C][2]; for (int i = 0; i < R; i++) {

题目描述：解题思路：威哥的题解dp[i]中存放以nums[i]结尾的最长上升子序列的长度，遍历到i的时候，将i前面的遍历一遍，如果出现比nums[i]小的数，那么可以直接将nums[i]对应的dp[i]+1当成当前的dp[i],也就是把新的nums[i]接到子序列后。在下标 i 之前严格小于 nums[i] 的所有状态值中的最大者 + 1+1 如果不懂可以去看力扣ppt的动图演示。最后在遍历一遍dp,返回最大值即可。这道题还有很多优化的地方，以后再补。参考代码： public int l

题目描述：解题思路：这是一道经典的动态规划题目，动态规划类的题目，要了解动态规划的思想，把问题分解成若干个子问题，而这些子问题之间又存在某种递推关系。废话不多说。这道题参考大佬的题解真正了解了动态规划的做法。参考代码：//动态规划 //样例9个数字， //每个数字为结尾的子序列一共有9种，下一个数字结尾的子序列可以由上一个数字结尾的子序列构成 //外面不关心子序列的类型，只关心最大值，当上一个子序列的值大于0的时候，下一个子序列的最大值就是上一个子序列最大值

题目描述：解题思路：甜姨总结了力扣里面的区间题，秒懂区间题代码中解释很清楚，直接给出代码：参考代码： public int[][] merge(int[][] intervals) { //按第一个元素排序 Arrays.sort(intervals,(v1,v2)-> v1[0] - v2[0]); int[][] res=new int[intervals.length][2]; int idx=-1;

题目描述：解题思路：这种题，自己真的不好想，看了题解，才勉强明白大佬的思路：首先先根据身高排序，h大的排前面，如果h相同，就把k小的排前面。然后再遍历一遍，根据k当作LinkList的index插入集合中，就是答案。参考代码： public int[][] reconstructQueue(int[][] people) { Arrays.sort(people,(o1,o2)-> o1[0]==o2[0] ? o1[1]-o2[1] : o2[0]-o1[0]);

题目描述：解题思路：TopK问题，我还没去看题解，根据之前甜姨的56. 合并区间的题解，了解了Lambda表达式的写法，这道题感觉也可以写出来，就偷懒用这种方法写了，提交过了，就是效率都很低。之后再补一下TopK的解法吧。参考代码： public int[][] kClosest(int[][] points, int K) { Arrays.sort(points, (v1, v2) -> (Math.abs(v1[0]) * Math.abs(v1[0])

题目描述：解题思路：题意一开始没有搞懂，还以为是要判断链表值的奇偶，但这道题是把奇偶位置的分开，重新组成新的链表，方法就是把奇偶分开，然后再把偶数链表接在奇数后面就可以了。这种链表节点，就是看题解也要理解很久，很容易把自己搞晕，还是不太熟练吧，没有找到做这类题的感觉。先写个官方的题解吧，还有甜姨的秒懂奇偶链表题解还没去看，等国赛比完补吧。参考代码 public ListNode oddEvenList(ListNode head) { if (head == null) {

题目描述：参考代码： public List<List<Integer>> combine(int n, int k) { List<List<Integer>> lists=new ArrayList<>(); dfs(lists,n,k,new ArrayList<Integer>(),1); return lists; } private void dfs(L

题目描述：解题思路：深搜参考代码： boolean flag=false; int tempsum=0; public boolean hasPathSum(TreeNode root, int sum) { if(root==null) return flag; dfs(root,sum); return flag; } public void dfs(TreeNode root,in

题目描述：参考代码： public int lengthOfLongestSubstring(String s) { int ans=0; Map<Character,Integer> map=new HashMap<>(); for (int end = 0,start=0; end <s.length() ; end++) { char c=s.charAt(end);

题目描述：解题思路：第一种方法：统计数组中每一个元素中包含1的个数，存入新的数组，注意要先排序。这样再根据1的个数进行冒泡排序，将2个数组同步更新，就能实现按1的个数排序，而且如果1的个数相同时按照大小排序。参考代码： static char[] c; static String s; public static int[] sortByBits(int[] arr) { int[] res=new int[arr.length]; Array

题目描述：解题思路：之前总结过这类网格dfs模板题，多复习。参考代码： public int islandPerimeter(int[][] grid) { for (int i = 0; i < grid.length; i++) { for (int j = 0; j < grid[0].length; j++) { if(grid[i][j]==1) {

题目描述：解题思路：递归写不出，我是bb 艹 public int sumNumbers(TreeNode root) { return helper(root,0); } private int helper(TreeNode root, int pre) { if(root==null) { return 0; } int sum=pre*10+root.val;

题目描述：解题思路：1、可以把链表中的值存起来，然后判断是不是符合回文。2、这道题最好的做法是利用双指针，快慢指针，slow next, fast next.next，然后当fast指针到终点的时候，slow就是中间，然后将slow后面的链表反转，再将fast指向head，开始比较即可。注意要对链表的反转熟练。3、另一种方法是利用栈先进先出的特点，实现判断。参考代码：方法1 public boolean isPalindrome(ListNode head) { Lis

public int climbStairs(int n) { double sqrt_5 = Math.sqrt(5); double fib_n = Math.pow((1 + sqrt_5) / 2, n + 1) - Math.pow((1 - sqrt_5) / 2,n + 1); return (int)(fib_n / sqrt_5); }

题目描述：解题思路：简单题，一般都不需要绕什么弯，第一种很傻的思路，就是遍历所有节点，存起来，然后找最小的差，利用搜索二叉树的性质，中序遍历后得到的是一个升序的序列，这道题的答案一定是某两个相邻的节点差。所有我们可以用一个变量存储前一个节点的值，这样直接省去了开辟新的空间。参考代码：//笨比做法 public int getMinimumDifference(TreeNode root) { List<Integer> rootval=new ArrayLi

题目描述：解题思路：这道题直接套深搜的模板即可做出来。参考代码： List<List<Integer>> lists=new ArrayList<>(); public List<List<Integer>> combinationSum(int[] candidates, int target) { List<Integer> list=new ArrayList<>();

题目描述：解题思路：递归回溯，看代码应该能看懂。注意剪枝，也就是当left>n或者右括号大于左边的话都return掉。参考代码： List<String> list = new ArrayList<>(); public List<String> generateParenthesis(int n) { if (n == 0) { return list; } String

题目描述：解题思路：如果题目不要求O(1)的内存解决的话，就很简单的一道题，存入set中，每次放入节点，当有重复的出现说明有环。不开新的空间的话，这道题需要用快慢指针的做法，一个指针遍历的速度快另一个慢，如果有环存在的话，这两个指针必定会重合，否则就没有环，利用这个思路可以写成代码。参考代码：//方法一 public boolean hasCycle(ListNode head) { Set<ListNode> list=new HashSet<&gt