qq_44688635的博客

LeetCode322.零钱兑换解法记忆化搜索动态规划记忆化搜索/*返回可以凑成总金额的最少的硬币个数*/func coinChange(coins []int, amount int) int { var f = make([]int, amount) /* 记忆化搜索，自顶向下, f[i]表示兑换i+1元需要的最少硬币数 */ var searchChange func(coins []int, amount int) int searchChange = func(coin

LeetCode312. 戳气球 解题思路记忆化搜索动态规划解题思路官方题解参考题解核心思想:由于戳气球的操作会导致两个气球从不相邻变成相邻，使得后续操作难以处理。于是我们倒过来看这些操作，将全过程看成每次添加一个气球。solve(i, j)表示 开区间(i, j) 所能获得的最大硬币数。当开区间只包含一个气球mid时，solve(i, j) = val[i] * val[mid] * val[j]记忆化搜索自顶向下分治+递归+记忆/*解法一: 记忆化搜索 由于戳气球的操作

LeetCode309. 最佳买卖股票时机含冷冻期 /*计算最大利润，不能同时参与多笔交易，卖出后无法在第二天买入（冷冻期为1天）动态规划 每一天会有三种不同的状态： 1. 目前持有一支股票，对应的[累计最大收益]为dp[i][0] 2. 目前不持有任何股票，且处于冷冻期中，对应的[累计最大收益]为dp[i][1] 3. 目前不持有任何股票，且不处于冷冻期中，对应的[累计最大收益]为dp[i][2] 注意：这里处于冷冻期是指第二天即i+1不处于冷冻期 状态转移： 1. 目

LeetCode301. 删除无效的括号/*一次遍历获取需要删除的左括号的个数和右括号的个数，遇到右括号： 如果左括号个数不为0，则左括号个数--； 如果左括号个数为0，则右括号个数++；遇到左括号： 左括号个数++这样子一次遍历后，左括号个数和右括号个数即为各自需要删除的个数。然后通过深度遍历+剪枝尝试删除，使用hash表去重。需要严格保证 [已经遍历到的左括号的数量] 大于 [已经遍历到的右括号的数量] 的时候，才可以继续添加 [右括号]，并且只有当该删除的括号都删除完全即左括号

牛客NC138 矩阵最长递增路径leetcode329 矩阵中的最长递增路径记忆化的深度优先遍历每个点的最长递增路径是确定，因此我们可以记录每个点的最长递增路径的长度，下一次访问到该点时就直接返回路径长度即可。会不会出现路径重复的情况(如下图的情况)呢？很明显是不会的，因为路径是递增的，这种情况会破坏路径的递增关系。 private int[][] dirs = new int[][]{{1, 0}, {0, -1}, {-1, 0}, {0, 1}}; private in

约瑟夫环问题问题定义解法1. 模拟链表2. 数学方法(时间复杂度较低)例题问题定义0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。解法1. 模拟链表该方法时间复杂度为O(n * m)/** * @author 49367 * @date 20

牛客网原题链接leetcode剑指Offer39如何理解摩尔投票算法核心思路：对拼消耗玩一个诸侯争霸的游戏，假设你方人口超过总人口一半以上，并且能保证每个人口出去干仗都能一对一同归于尽。最后还有人活下来的国家就是胜利。那就大混战呗，最差所有人都联合起来对付你，或者其他国家也会相互攻击），但是只要你们不要内斗，最后肯定你赢。最后能剩下的必定是自己人。 /** * 找出数组中出现次数超过数组长度len的一半的数，若没有则返回0 * 最佳解法： * 候选法

原题链接相关题目，相关数据结构及其设计：设计一个能够获得最小值的栈能够获取最大值的队列class MaxQueue { private Deque<Integer> dataQueue; private Deque<Integer> maxQueue; public MaxQueue() { dataQueue = new LinkedList<>(); maxQueue = new LinkedList&l

set集合法 （时间复杂度O(n)， 空间复杂度O(n)）快慢指针法（时间复杂度O(n)，空间复杂度O(1)）逐个删除法 （时间复杂度O(n)，空间复杂度O(1)） class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } }set集合法 （时间复杂度O(n)， 空间复杂度O(.

原题链接 /** * 动态规划 * 状态 dp[i][j] 表示 text1前i个字符 和 text2前j个字符 的最长公共子序列的长度 * * 状态转移方程 * if text1[i] == text2[j]， dp[i + 1][j + 1] = dp[i][j] + 1; * if text1[i] != text2[j], dp[i + 1][j + 1] = Math.max

目录[LeetCode105. 从前序与中序遍历序列构造二叉树](https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)[LeetCode106. 从中序与后序遍历序列构造二叉树](https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)[LeetCo

原题链接class Solution { /** * 动态规划 * left[i] 为 a[i] 左边元素的乘积 (不包含 a[i]) * right[i] 为 a[i] 右边元素的乘积 (不包含 a[i]) * 则结果 res[i] = left[i] * right[i] * * @param a * @return */ public int[] construc

原题链接class Solution { /** * 动态规划 * dp[] 记录点数和的概率 * 已知 n = 1 时，f(1, dp[]) = {1/6, 1/6, 1/6, 1/6, 1/6, 1/6} * 新增骰子的点数只能是 1 - 6，原先 n - 1 个骰子的点数和分别加上新增骰子的点数，即为 n 个骰子的点数和 * dp[i] 即为 n 个骰子投出的最小点数和的概率 * 已

原题链接class Solution { /** * 时间复杂度 O(n), 空间复杂度 O(1) * 方法：异或 * 2 ^ 3 ^ 2 ^ 1 ^ 4 ^ 3 = 2 ^ 2 ^ 3 ^ 3 ^ 1 ^ 4 = 1 ^ 4 * 异或得到结果，值为 1 的位是两个只出现一次的数不相同的位， * 例： 3 ^ 5 = 011 ^ 101 = 110 * 作用：通过获取一个不相同的

原题链接(官方题解视频讲的很好)核心思想：在归并排序的过程中计算逆序对的数目 /** * 归并排序 * @param nums * @return */ public int reversePairs(int[] nums) { int len = nums.length; if(len < 2) return 0; int[] copy = new int[len]; //

原题链接 动态规划双指针动态规划class Solution { /** * 动态规划 * dp[j] 表示以第 j 个字符为结尾的最长不重复字符串的长度 * * 设 s[j] 的前一个相同字符 为 s[i]，用 hashMap 存储对应 * 的字符和它最后一次出现的位置 * * 状态转移方程： * 如果 i < j - 1 - dp[j - 1] +

Leetcode 130.被围绕的区域 深度遍历并查集深度遍历只从边界 ‘0’ 开始遍历，就不用考虑如何恢复没符合条件的标记class Solution { public void solve(char[][] board) { int n = board.length; if(n == 0) return; int m = board[0].length; /* 只从矩阵

原题链接class Solution { public int findNthDigit(int n) { /* n: 第几位数，从第0位开始，第0位是0 digit: 数字有几位 start: 每digit位数的起始数字；例：2位数的起始数字是10 count：每digit位数系列化后拥有的数字数量； count = 9 * start * di

原题链接class Solution { public int countDigitOne(int n) { /* digit: 当前处在第几位 （个位: 1, 十位: 10） cur: 当前位的数值 high: 高位的数值 low: 低位的数值 countOne: 当前位1出现的次数 例: 若n为3201，当前digit为10，则

原题链接题解写的很好，请参考题解回溯法 （深度遍历 + 剪枝）class Solution { // 返回结果字符串的List集合 private List<String> res = new LinkedList<>(); // 字符串s的字符数组sArray private char[] sArray; public String[] permutation(String s) { sArray = s.toChar

原题链接核心思想是中序遍历 (LDR)，难点是如何在中序遍历的过程中修改指针。解决方法:定义一个记录上一个被访问的根结点的 pre 变量，一个记录当前被访问根结点的 cur 变量每次访问根节点都使得 pre.right = cur， cur.left = pre/*// Definition for a Node.class Node { public int val; public Node left; public Node right; public

原题链接递归算法 /** * 4可剪成2 * 2， 5可以剪成2 * 3... * * 要么剪成长度为2的，要么剪成长度为3的，递归找到乘积 * 最大的剪法。 */ public int cut(int n){ if(n <= 3){ return n; } return Math.max( 2 * cut(n - 2), 3 * cut(n

原题链接递归方法 (深度遍历加剪枝)递归方法比较容易剪枝class Solution { public boolean exist(char[][] board, String word) { char[] words = word.toCharArray(); for(int i = 0; i < board.length; i++) { for(int j = 0; j < board[0].length; j++)

原题链接递归方法核心思想：对于任意一颗树而言，前序遍历的形式总是[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]public class RebuildBinaryTreeRecursion { class TreeNode { int val; TreeNode left; T

原题链接方法：线性查找法只能从右上角或者左下角开始。如果从左上角开始，target < matrix[i][j]时，既可以向右查找也可以向下查找；如果从右下角开始，target > matrix[i][j]时，既可以向左查找也可以向上查找；这两种情况其实就是暴力解法。从右上角开始：如果target < matrix[i][j]， 就直接向左查找，并划掉原先所处的那一列。如果target > matrix[i][j]， 就直接向下查找，并划掉原先所处的那一行。很容易证明

原题链接分治算法class Solution { // 分治算法 public int longestSubstring(String s, int k) { // 如果string的长度小于k，那么必不包含重复出现k次及以上的字母 if(s.length() < k) return 0; // 记录每个字母出现的次数 HashMap<Character, Integer> charCount = n

方法一：二进制状态压缩代码方法一：二进制状态压缩题目的本质就是要找出每个 puzzle 对应的 valid word 的 数目valid 的定义是 word 里必须包含 puzzle 的首字母，且不包含 puzzle 没有的字母。这定义表明了，word 里字母的顺序、重复次数都没有关系，本质只是一个字母的集合，且只要一个字母出现一次和出现多次并没有区别，只有出现0次和出现1次的区别。puzzle 也是如此用一个26位的二进制数就可以表示每一个 word 或 puzzle (用如下形式表示)。.

原题链接：995. Minimum Number of K Consecutive Bit Flips核心思想： 具体的翻转次数并不重要，只需知道是奇数次还是偶数次即可class Solution{ public int minKBitFlips(int[] A, int K) { int len = A.length; int i; int kn = 0, revCnt = 0; /* * 当前A[i]为0

leetcode算法题45方法方法一方法二方法一从后往前找public int jump(int[] nums) { int len = nums.length; nums[len-1] = 0; for(int i = len - 2; i >= 0; i--){ int min = nums[i+1]; int boundary = Math.min(i + nums[i], len - 1); for(int j

天际线问题原题链接解法用到了优先队列 PriorityQueue，和可以排序的 TreeMap主要思想为从左到右扫描，扫描的高度更新时，结果集更新class Solution { public List<List<Integer>> getSkyline(int[][] buildings) { int length = buildings.length; /*优先队列，当两个点位置不同时，位于左边的点放在前面；

原题链接方法方法一（堆）方法二（动态规划）方法一（堆）class Solution { public int[] nums = new int[1690]; Solution(){ HashSet<Long> seen = new HashSet<>(); PriorityQueue<Long> heap = new PriorityQueue<>(); seen.add(1L);

原题链接解决方法方法一方法二（双向队列）方法一class Solution { /** * 向右滑动窗口一位，相当于当前窗口弹出最左边的元素， * 最右边加入相邻的元素。 * @param list 结果链表 * @param i 向右滑动窗口后， * 窗口最左边元素在数组中的位置 * @param k 窗口的大小 * @param maxI

原题链接严格按照后序遍历逻辑的代码（自己写出来的代码）//二叉树结点的定义class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; }}class Solution { public List<Integer&g...

方法回溯法（深度优先）递归实现回溯法（深度优先）递归实现class Solution { /** * 回溯法（深度优先），先添加左括号，再匹配右括号 * @param ans 结果链表 * @param cur 当前函数体内的括号串 * @param left 当前函数体内左括号个数 * @p...

字典树解法//字典树的结点class TireNode{ public char val; //一个字母结点的后代可能有26个（a - z） public TireNode[] children = new TireNode[26]; public TireNode() { val = ' '; } public TireNo...

解题方法堆排序希尔排序快速排序用递归实现非递归实现原题链接堆排序class Solution { //调整堆，让每个非叶子结点与它的子结点比较，使得最后该叶子结点的位置上一定是最大的元素 public void adjustHeapNode(int i, int[] nums, int len){ int temp = nums[i]; fo...

原题链接解题方法暴力解法暴力解法实在没办法了，就一定要用暴力解法试一试class solution{ //暴力遍历解法 public int maximalRectangle(char[][] matrix) { int m = matrix.length; if(m == 0) return 0; int n = matri...

方法栈方法分治算法栈方法class Solution { public int largestRectangleArea(int[] heights) { //定义新数组，使得访问栈时不用考虑栈为空的情况 int[] new_heights = new int[heights.length + 1]; //用栈存位置 De...

快慢指针法原题链接class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } //快慢指针法class Solution { public ListNode middleNode(ListNode head) { //快慢指针 ListNo...

栈 + HashMap + HashSetimport java.util.Deque;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedList;class Solution { public boolean canMeasureWater(int x, int y, int ...