m0_56033865的博客

给你一个整数数组 nums 和一个整数 target 。向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。public int findTargetSumWays(int[] nums, int target) { /

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？典型dp问题；dp数组是网格里到达此位的路径数；递推公式是dp[i][j]=dp[i-1][j]+dp[i][j-1]//从上面或左面来初始化则是第一行和第一列全部为1（只有一条路径）从上到下，从左到右依次遍历即可；最后返回右下角的路径值； public int unique

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。示例 1：输入：cost = [10,15,20] 输出：15 解释：你将从下标为 1 的台阶开始。支付 15 ，向上爬两个台阶，到达楼梯顶部。 总花费为 15 。这题是个dp问题，类似普通爬楼梯，不过加了一个体力，就需要比较最值；dp数组含义：达到

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。示例 1:输入: intervals = [[1,2],[2,3],[3,4],[1,3]] 输出: 1 解释: 移除 [1,3]后，剩下的区间没有重叠。 public int eraseOverlapIntervals(int[][] intervals) { Arrays.sort(intervals,(a,b)-

给定一个二叉树，我们在树的节点上安装摄像头。节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。计算监控树的所有节点所需的最小摄像头数量。示例 1：输入：[0,0,null,0,0] 输出：1 解释：如图所示，一台摄像头足以监控所有节点。本题使用贪心算法（遇事不决用贪心），从下往上进行搜索（从上往下后期要解决的节点数量过多），叶子节点的父节点作为摄像头所覆盖的区域是最多的，因此使用后序遍历，使用类似回溯的方式遍历整棵树并及时记录状态；0表示未覆盖，1表示有摄像头，2表示已覆盖；

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。示例 1：输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]]解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].按照左边界排序，排序之后局部最优：每次合并都取最大的右边界，

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。示例：输入：S = “ababcbacadefegdehijhklij” 输出：[9,7,8] 解释： 划分结果为 “ababcbaca”,“defegde”, “hijhklij”。 每个字母最多出现在一个片段中。 像 “ababcbacadefegde”,“hijhklij” 的划分是错误的，因为划分的片段数较少。本题与其说是贪心，更像是一道模拟题，我们

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。你需要按照以下要求，给这些孩子分发糖果：每个孩子至少分配到 1 个糖果。相邻两个孩子评分更高的孩子会获得更多的糖果。请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。示例 1：输入：ratings = [1,0,2] 输出：5 解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。感觉算是hard里面比较简单的一道题；贪心的思路，从前到后，满足一定条件下（相邻两个孩子评分更高的孩子会获得

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。重复这个过程恰好 k 次。可以多次选择同一个下标 i 。以这种方式修改数组后，返回数组 可能的最大和 。示例 1：输入：nums = [4,2,3], k = 1 输出：5 解释：选择下标 1 ，nums 变为 [4,-2,3] 。两次贪心，第一波，选择负值修改为正值（优先选绝对值大的），第二波，选择正值修改为负值（优先选绝对值小的）代码还是有点难度的：

给定一个数组 prices ，其中 prices[i] 表示股票第 i 天的价格。在每一天，你可能会决定购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以购买它，然后在 同一天 出售。返回 你能获得的 最大 利润 。示例 1:输入: prices = [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格= 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分。输入：nums = [-2,1,-3,4,-1,2,1,-5,4]输出：6解释：连续子数组 [4,-1,2,1] 的和最大，为 6贪心在于发现当前和小于0的时候直接置为0，因为一个小于0的count不管怎么样都会拖累总结果; public int maxSubArray(int[] nums) { if(nums.length==1){

回溯的题做完了，感觉非常通透，来做贪心~假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。输入: g = [1,2,3], s = [1,1]输出: 1解释:你有三个孩子和两块小饼

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：0 <= a, b, c, d < na、b、c 和 d 互不相同nums[a] + nums[b] + nums[c] + nums[d] == target你可以按 任意顺序 返回答案使用排序+双指针法，和三数之和一个套路甚至一个模板，

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。使用迭代法，建立哨兵头节点（方便返回） public ListNode swapPairs(ListNode head) { ListNode dummy=new ListNode(-1,head); ListNode pre=dummy; while (pre.next!=null&&pre.next.next!=

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。在链表类中实现这些功能：get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> ans=new ArrayList<>(); if(matrix.length==0){ return ans; } int

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。这是一道模拟题，按照从左上到右上，从右上到右下，从右下到左下，从左下到左上，谨记一个原则是左闭右开，这样最后都能填充到，并且需要修改偏移量（每次加2）和起始坐标（每次加1）。如果矩阵的维度是奇数，则会有中心元素，额外填充即可。填充轮数通过n/2来确定，如3维，则只需一轮，4维则需要两轮。 public int[][] generateMatrix(int n) {

给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。使用后序遍历求高度，一旦左右子树有一方不满足高度差大于1就返回-1，这样一层一层的返回后都是-1，否认返回左右子树的最大高度以方便比较。 public boolean isBalanced(TreeNode root) { return getDepth(root)!=-1; } public int getDepth(Tre

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。dfs(后序遍历往上返回结果)需要注意的是，左子树为空，应当返回的是右子树高度+1；反之同理。不能像判断最大深度一样不加以判断。 public int minDepth(TreeNode root) { if(root==null){ return 0; } int leftde=minDepth(ro

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。输入：root = [4,2,7,1,3,6,9]输出：[4,7,2,9,6,3,1]dfs的代码还是比较简单的，从整体分析，翻转二叉树只需把每个节点的左右子树翻转即可，可以使用前序和后序遍历，如果使用中序遍历，可能会导致重新交换（使得交换无效）； public TreeNode invertTree(TreeNode root) { if(root==null){ return nul

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。本题的思路是层次遍历，不过需要额外维护一个index,来记录当前应当是顺序还是逆序。 public List<List<Integer>> zigzagLevelOrder(TreeNode root) { if(root==null){ return new ArrayList<>();

整数数组 nums 按升序排列，数组中的值 互不相同 。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。给你 旋转后 的数组 nums 和一个整数 ta

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reverse-linked-list-ii著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。class Solution { public ListNode reverseBetwee

/** * @className: Selfmap * @description: TODO 类描述 * @author: whz * @date: 2022/1/16 **/public class ThirdHashMap<K,V> { class Node<K,V>{ private K key; private V value; private Node<K,V> next;

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。法一：转换成数组然后双指针比较，直到left不满足小于right.public boolean isPalindrome(ListNode head) { List<Integer> vals=new ArrayList<>(); ListNode current=head; while (curr

颠倒给定的 32 位无符号整数的二进制位。提示：请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。法一：不论你的示例是多少，通通循环32次 public int reverseBits(int n

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。提示：请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。右移统计 public int hammingWeig

给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。示例 1：输入：nums = [3,0,1] 输出：2 解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2是丢失的数字，因为它没有出现在 nums 中。异或性质 public int missingNumber(int[] nums) { int n=nums.length; int ans=0; for (

给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3x输入：n = 27 输出：true打表（预处理）static Set<Integer> set=new HashSet<>(); static { int cur=1; set.add(cur); while (cur<Integer.MAX_VA

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。push(x) —— 将元素 x 推入栈中。pop() —— 删除栈顶的元素。top() —— 获取栈顶元素。getMin() —— 检索栈中的最小元素。输入： [“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”][[],[-2],[0],[-3],[],[],[],[]]输出： [null,null,null,null,-3,nul

给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。如果链表中存在环，则返回 true 。 否则，返回 false 。set检验是否添加成功public boolean hasCycle(ListNode

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。说明：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？输入: [2,2,1] 输出: 1灰常简单但是要求线性的时间复杂度和常数的空间复杂度。hash计数（简单但慢） public int singleNumber(int[] nums) { Map<Integer,Integer> map=new HashMap<>();

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。说明：本题中，我们将空字符串定义为有效的回文串。考察对字符串处理api的使用，重要的是使用Character.isLetterOrDigit(ch)对字符进行预处理，然后采用翻转或双指针的方法判断是否为回文串。反转 public boolean isPalindrome(String s) { StringBuffer sb=new StringBuffer(); int length=s

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。来源：力扣（LeetCode） public TreeNode sortedArrayToBST(int[] nums) { return helper(nums,0,nums.length-1); } public TreeNode helper(int[] nums,int le

给你一个二叉树的根节点 root ， 检查它是否轴对称。递归法 public boolean isSymmetric(TreeNode root) { return check(root,root); } public boolean check(TreeNode p,TreeNode q){ if(p==null&&q==null){ return true; } if(p==nul

给你一棵二叉树的根节点 root ，返回其节点值的 前中后序遍历 。前序：按照访问根节点——左子树——右子树的方式遍历这棵树 public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); preorder(root, res); return res; } pub

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。示例 1：输入：x = 4 输出：2 public int mySqrt(int x) { int l=0,r=x,ans=-1; while (l<=r){ int mid=l+(r-l)/2;

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/plus-one输入：digits = [1,2,3] 输出：[1,2,4] 解释：输入数组表示数字 123。题目理解：让末位+1，然后遵循十进制样式进位，左侧为高位（在数组中操作）public int[]

实现 strStr() 函数。给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/implement-strstr当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C