咸鱼之井的博客

LeetCode

典型的题目，拼单词注意是两个状态累加，不是单纯的+1，而且注意下标的问题class Solution { public int numDecodings(String s) { int[] dp = new int[s.length()+1]; dp[0] = 1; for(int i=1; i<=s.length(); i++){ if(s.charAt(i-1)!='0') dp[i] = dp[

动规+贪心跳跃，思路是OK的，但是实现上一直有问题，需要多理解class Solution { public int jump(int[] nums) { int ans = 0; int end = 0; int maxlen = 0; for(int i=0; i<nums.length-1; i++){ maxlen = Math.max(maxlen,i+nums[i]);

递归，居然一次写出来了，注意细节，比如child要变null，cnt可能为null/*// Definition for a Node.class Node { public int val; public Node prev; public Node next; public Node child;};*/class Solution { public Node flatten(Node head) { //if(head==null)

一开始写成了找平均数，其实应该找中位数class Solution { public int minMoves2(int[] nums) { int res = 0; int avg = 0; Arrays.sort(nums); avg = nums[nums.length/2]; for(int num : nums){ res += Math.abs(avg-num);

一次过了，但还需要总结class Solution { int res = 0; int[][] visited; public int maxAreaOfIsland(int[][] grid) { if(grid.length==0||grid[0].length==0) return 0; this.visited = new int[grid.length][grid[0].length]; for(int i

树的深搜计数，记路径/** * 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 left, TreeNode

回溯和深搜还是要练/** * 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 left, TreeNode r

层序遍历过了，但是有点耗时/** * 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 left, TreeNo

层序一遍过了时间好像略高也可以用dfs，感觉和树的左视图很像/** * 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, Tr

暂存吧，不是很难的题，但是一直想不出思路/** * 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 left,

基础想法是对的，但是做法和实现方式要学习，下标方法/** * 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

看来这个Sysytem.out很占时间/*// Definition for a Node.class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) { val = _val; } public Node(int _val, List<Node> _children) {

写出来了但是耗时很长再提交又不耗时了，很怪/*// Definition for Employee.class Employee { public int id; public int importance; public List<Integer> subordinates;};*/class Solution { int value = 0; Map<Integer,Employee> map = new HashMap&l

N叉树层序，无大区别/*// Definition for a Node.class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) { val = _val; } public Node(int _val, List<Node> _children) { val

层序遍历处理overqueue队列的函数是 add/offer poll/** * 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

写递归程序，重要的是四点，输入参数、输出结果、函数的功能、终止条件。二叉树本身就具有递归这种性质的数据结构，我们需要把它看成“左子树-根节点-右子树”这种结构，就不要再囿于左子节点／右子节点这个思维里了。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {}

一遍过，但是好像用时很久看了下都是这个思路/** * 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 lef

写出来了但是耗时很长，应该考虑怎么剪枝也不是，感觉自己把该递归判断的地方写错了/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int

一开始的思路对了80%，但是还是细节上有问题/** * 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 lef

自己写出来了，但是很耗时，应该要优化一下在哪里递归需要考虑一下基础语法上，map的遍历，ArrayList转int数组需要学习/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val =

/** * 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 left, TreeNode right) { *

感觉自己好像又明白一些啦/** * 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 left, TreeNod

深搜的写法也没写明白，先想清楚逻辑再写/** * 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 left,

还是没必要新建节点/** * 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 left, TreeNode r

/** * 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 left, TreeNode right) { *

这道题学的是，求二叉树的深度，节点个数，在完全二叉树的基础上，怎么简化深度以及完全二叉树求节点个数的优化求二叉树的深度private int countLevel(TreeNode root){ if(root == null){ return 0; } return Math.max(countLevel(root.left),countLevel(root.right)) + 1;}求二叉树的节点个数public int countNodes(Tre

注意不能加等于的判断/** * 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 left, TreeNode

/** * 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 left, TreeNode right) { *

/** * 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 left, TreeNode right) { *

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

class Solution { public int maxSubarraySumCircular(int[] nums) { int len = nums.length; int all = nums[0]; int[] fmax = new int[len]; int[] fmin = new int[len]; int rmax = nums[0]; int rmin = nums[0];

打家劫舍变形class Solution { public int deleteAndEarn(int[] nums) { int len = nums.length; if(len<=1) return nums[0]; int[] f = new int[10001]; int[] tmp = new int[10001]; for(int num:nums){ tmp[num]++;

class Solution { public int rob(int[] nums) { int len = nums.length; if(len<=1) return nums[0]; int[] f = new int[len+1]; int[] d = new int[len+1]; f[1]=nums[0]; d[2]=nums[1]; for(int i=2; i&lt

class Solution { public int rob(int[] nums) { int len = nums.length; int[] f = new int[len+1]; f[0]=0; f[1]=nums[0]; for(int i=2; i<=len; i++){ f[i] = Math.max(f[i-2]+nums[i-1],f[i-1]); }

class Solution { public int minCostClimbingStairs(int[] cost) { int len = cost.length; int[] f = new int[len+1]; f[0]=0; f[1] = cost[0]; for(int i=2; i<=len; i++){ f[i] = Math.min(f[i-1],f[i-2]) +