simmons6666的博客

一、标准动归class Solution { public int rob(int[] nums) { //不能进连续的屋子 int n=nums.length; if(n==1){ return nums[0]; } if(n==2){ return Math.max(nums[0],nums[1]); } int[] dp=new i

一、01背包class Solution { public boolean canPartition(int[] nums) { int len=nums.length; int sum=0; for(int num:nums){ sum+=num; } if(sum%2!=0) return false; int target=sum/2; boolea

1.判断括号有效一般使用栈进行判断（1）（），{}，[]使用一个栈class Solution { public boolean isValid(String s) { //java中推荐使用Deque替代Stack，Deque堆栈操作方法：push()、pop()、peek() Deque<Character> stack=new LinkedList<>(); char[] c=s.toCharArray();

1.寻找左侧边界的二分查找某比赛已经进入了淘汰赛阶段,已知共有n名选手参与了此阶段比赛，他们的得分分别是a_1,a_2….a_n,小美作为比赛的裁判希望设定一个分数线m，使得所有分数大于m的选手晋级，其他人淘汰。但是为了保护粉丝脆弱的心脏，小美希望晋级和淘汰的人数均在**[x,y]**之间。显然这个m有可能是不存在的，也有可能存在多个m，如果不存在，请你输出-1，如果存在多个，请你输出符合条件的最低的分数线。==解题：==使用二分搜索查找满足条件的左侧边界import java.lang.refl

1.获取一个数int N=sc.nextInt();2.获取整行String temp = sc.nextLine();返回的是一个字符串如果该句是在第一行获得，直接这样写就行；如果是在第一行后面获得，则需要在前面加上一句sc.nextLine()，即：sc.nextLine();String temp = sc.nextLine();...

1.跳跃游戏class Solution { public boolean canJump(int[] nums) { //使用贪心算法 int n=nums.length; int farthest=0; for(int i=0;i<n-1;i++){ farthest=Math.max(farthest,nums[i]+i); //遇到0卡住，跳不了

目录1.无重复区间2.用最少数量的箭引爆气球1.无重复区间class Solution { public int eraseOverlapIntervals(int[][] intervals) { if(intervals.length==0) return 0; //贪心算法：区间调度，找到最多不重合子区间，用集合长度减去不重合子区间个数就是答案 //1.让二维数组按照每个一维数组的end进行排序（从小到大） //2.找到最小

目录1.二叉树的最小深度2.打开转盘锁3.滑动谜题1.二叉树的最小深度/** * 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

目录1.二叉树的序列化与反序列化2.二叉搜索树中第k小的元素3.把二叉树转换为累加树1.二叉树的序列化与反序列化/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Codec {

写递归算法的秘诀：写递归算法的关键是要明确函数的「定义」是什么然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。怎么理解呢，我们用一个具体的例子来说，比如说让你计算一棵二叉树共有几个节点：// 定义：count(root) 返回以 root 为根的树有多少节点int count(TreeNode root) { // base case if (root == null) return 0; // 自己加上子树的节点数就是整棵树的节点数 return

1.递归＋迭代：反转链表/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode reverseList(ListNode head) { //1.递归解法

1.回溯：组合总和class Solution { List<List<Integer>> res=new LinkedList<>(); public List<List<Integer>> combinationSum(int[] candidates, int target) { if(candidates==null || candidates.length==0){ return

1.回溯算法：全排列class Solution { List<List<Integer>> res=new LinkedList<>(); public List<List<Integer>> permute(int[] nums) { if(nums==null ||nums.length==0){ return res; } LinkedList&lt

1.滑动窗口算法：最小覆盖子串class Solution { public String minWindow(String s, String t) { //使用滑动窗口算法 //base case if(s==null || s.length()==0){ return ""; } //使用needs记录target字符串中的字符以及个数 Map<Character,

1.二分查找右边界：爱吃香蕉的珂珂class Solution { public int minEatingSpeed(int[] piles, int h) { //使用二分查找法寻找速度的左边界，即最小速度 //速度的左右边界，最大速度就是数组的最大值，因为一小时吃完这堆香蕉不会再吃更多的香蕉 int left=1,right=getMax(piles)+1; while(left<right){

1.逻辑+hashset：扑克牌中的顺子//构成顺子的充分条件：//(1)无重复牌(2)最大牌-最小牌<=5class Solution { public boolean isStraight(int[] nums) { //构成顺子的充分条件： //(1)无重复牌(2)最大牌-最小牌<=5 //可以使用hashset实现 Set<Integer> set=new HashSet<>();

1.单调队列：滑动窗口的最大值class Solution { public int[] maxSlidingWindow(int[] nums, int k) { // //1.暴力法 // int n=nums.length; // if(n==0 || k==0) return new int[0]; // int[] res=new int[n-k+1]; // for(int i=0;i<n-k+1;

1.hashmap：数组中数字出现的次数2class Solution { public int singleNumber(int[] nums) { Map<Integer,Integer> map=new HashMap<>(); int res=0; for(int i:nums){ map.put(i,map.getOrDefault(i,0)+1); } fo

1.数组+哈希表+等差数列class Solution { public int missingNumber(int[] nums) { // //1.我的笨方法 // int n=nums.length; // int res=-1; // //使用hashmap进行记录,map中先放好0到n共n+1个键值对, // Map<Integer,Integer> map=new HashMap<&g

1.hashmap：最长不含重复字符的子字符串class Solution { public int lengthOfLongestSubstring(String s) { if(s==null || s.length()==0){ return 0; } char[] c=s.toCharArray(); int start=0,maxLength=0; HashMap<Charac

1.数组：数组中出现次数超过一半的数字class Solution { public int majorityElement(int[] nums) { Arrays.sort(nums); //由于该数出现次数超过一般，所以排序后一定位于中间 //元素个数为偶数：是在中间的缝的右边那个元素；奇数：中间元素 return nums[nums.length/2]; }}2.数组：最小的k个数class Solutio

1.二叉树中和为某一值的路径->回溯/** * 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

1.链表中倒数第k个节点->快慢指针/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode getKthFromEnd(ListNode head, int k) {

1.两数之和->hashmapclass Solution { public int[] twoSum(int[] nums, int target) { int[] res=new int[2]; if(nums.length==0){ return res; } Map<Integer,Integer> map=new HashMap<>(); for(int

1.机器人的运动范围->递归class Solution { int res=0; public int movingCount(int m, int n, int k) { boolean[][] used=new boolean[m][n]; dfs(m,n,k,0,0,used); return res; } public void dfs(int m,int n,int k,int i,int j,boolea

1.旋转数组的最小数字->二分法class Solution { public int minArray(int[] numbers) { //1.暴力 O(N),O(1) int n=numbers.length; // if(n==1) return numbers[0]; // int res=numbers[0]; // for(int i=0;i<n-1;i++){ //