老痒的农舍

错题备忘录 双指针解题思路证明 假设：存在l, r，使得[l, r]之间的部分构成最优解，双指针i, j分别从最左和最优向中间逼近至最优解的位置，则有一侧优先到达指定位置 可证明：若i / j其中之一优先到达指定位置（这里假设i先到达l），那么[r, j)的所有竖线长度均小于等于l处竖线长度（反证法可证明） 得出结论：双指针向置定位逼近时遵循，那侧小那侧移动的原则。 代码 class Solution { public: int maxArea(vector<int>& h) {

剑指 Offer 60. n个骰子的点数 从递归到动递推 记忆化搜索 最后一个数据点混不过去，会超时 class Solution { public: int dfs(vector<vector<int>> &f, int n, int s) { if (s < 0) return 0; if (n == 0) return !s; if (f[n][s] != 0) return f[n][s];

思路 使用“类后序遍历”的做法可以使得时间复杂度为O(n)，这里我们需要考虑这样一些情况，若以2进制位表示是否有我们需要的节点（000：中间为根，左右为孩子，0表示无，1表示有），即有： 101：根满足情况 110、011：根亦满足情况（易被忽略） 代码 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right;

剑指 Offer 46. 把数字翻译成字符串 思路 简单递推，dp[i]表示的是以当前字符结尾可能存在的字符串种类数量，其中字符有1位和2位可以组合，因此有dp[i] = dp[i - 1] + dp[i - 2]，此外有两种特殊情况需要注意： 数位组合超过25不能构成字符 数位首位为0（第一次做就忽略了这种情况） 代码 递推方法 const int N = 105; class Solution { public: string num; int dp[N]; int tran

题目连接点击这里 解决思路 使用哈希表 + 双链表进行存储数据，hash主要负责key -> 链表node 的映射，而node中除了存储key、val其主要作用是判断当前键值的优先级，使用频次越高的键值对放在链表的头起，使用频次低的节点向后放置。详细见代码。 代码 class LRUCache { public: typedef struct Node { int key, val; Node *left, *right; Node(int k

思路 自定义排序，自定义排序规则的合理性可以使用“全序关系”来证明（离散数学知识点） 0的问题，除去相同元素0，见代码 代码 class Solution { public: // 我们自定义一种排序规则 // 该规则是否可以用来进行排序？使用“全序关系”进行证明后，满足3个条件，可用 // 1.反对称性：如果 a ≤ b 且 b ≤ a 则 a = b （易证） // 2.传递性：如果 a ≤ b 且 b ≤ c 则 a ≤ c（有点复杂，略） // 3.完整性

题目链接 投票法（不一定非要按照这种做法，但是这种做法效率最高），感觉如果之前没见过，现场去想这种做法还是不现实的，现在记录一下 思路 可以这样理解这个问题：我们要得到的数相当于“水晶”，其他的数相当于消耗水晶的物品，因为水晶个数大于一半，所以无论最终怎么消耗，剩下的还是水晶。具体见下代码。 class Solution { public: int majorityElement(vector<int>& nums) { int n = nums.size();

针对Byte Dance某一次面试的算法题目（LC 337. 打家劫舍 III ），现做如下整理。 目录 LC 198. 打家劫舍 - 递推 LC 213. 打家劫舍 II - 递推 LC 337. 打家劫舍 III - 树形dp 声明：以下“选”和“劫取”是同义词，自由替换 LC 198. 打家劫舍 思路 对于每一所房子有两种状态，要么选择，要么不选择，使用dp[i]记录当前位置房子所能劫取到的最大价值，即有：dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]) 代码

题目连接 将可以蕴含的总水量划分成局部区间来求 当前区间可以蕴含的水量 = min(其左边区间最大高度, 其右边区间的最大高度) - 当前区间的高度 LC特色：特判一下（n == 0时），不然要RE C++ 代码 class Solution { public: int trap(vector<int>& height) { int n = height.size(); if (n == 0) return 0; vector&lt

这里选取LeetCode两道子集生成的问题 LC 78. 子集（集合中无重复元素) LC 90. 子集II（集合包含重复元素) LC 78. 子集（集合中无重复元素） DFS const int N = 15; class Solution { public: bool vis[N]; vector<vector<int>> ans; void dfs(vector<int>& nums, int x) { if

题目点击这里 next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存的做法。其中 h 是树的高度，O(1)为平均时间复杂度。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), righ

进程与线程的区别 程序与进程 程序就是我们平时说的代码（静态的） 进程是程序的一次执行过程（即把代码装载到内存中跑一次，是动态的） 进程与线程的区别 1.从定义上区分： 进程是程序的一次执行过程，是程序执行的最小单位 线程是资源分配的基本单位，是调度运行的基本单位，是系统中并发执行的单位 ！可以这么理解，一段代码跑一趟这一趟就是一个进程，代码中的一条执行路径就是该进程中的一个线程 2.一个线程只能属于一个进程，一个进程能够拥有多个进程；多线程就是允许一个进程在同一时刻执行多个任务 3.

谈一谈CAS CAS（Compare And Swap）即比较并交换 public class CASDemo { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(5); // true, 2020 System.out.println(atomicInteger.compareAndSet(5, 2020) + ", "

题目描述 给定一个整数序列：a1, a2, …, an，一个132模式的子序列 ai, aj, ak 被定义为：当 i < j < k 时，ai < ak < aj。设计一个算法，当给定有 n 个数字的序列时，验证这个序列中是否含有132模式的子序列。 注意：n 的值小于15000。 样例 example1: 输入: [1, 2, 3, 4] 输出: False 解释: 序列中不存在132模式的子序列。 example2: 输入: [3, 1, 4, 2] 输出: Tru

HTTPS要点总结 1.HTTPS的特点 HTTPS的本质还是HTTP 在TCP层加上了SSL或TLS 端口： HTTP：80 HTTPS：443 2.HTTPS安全性 1）提供验证服务，验证本次会话身份的合法性 2）提供加密服务，强加密机制能保证通信中的消息不被破译 3）提供防篡改服务，利用Hash算法对消息进行签名，通过验证签名保证通信内容不被篡改 3.图解 |----------------------------------------| |

TCP/IP协议的三次握手与四次挥手 TCP报文的格式 先明确一个问题：每一次client与server交换的东西叫 —— 报文段 TCP是面向连接的，安全可靠的协议，三次握手正是为了保证能够建立一个安全可靠的连接 何为安全，如何保证安全？ 双方都已经就绪 已经做好后续数据交换的准备（协商得知对方的序列号） 三次握手的全过程（客户端企图建立连接） 1.客户端向服务端发起建立连接的请求 在这个建立连接的请求中，标志位至1（SYN=1），随机生成一个初始的32位序列号seq=x（initial seq

题目描述 给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。 列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。 样例 输入: [[1,1],2,[1,1]] 输出: [1,1,2,1,1] 解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。 使用dfs先将原List中的元素依次存储到一个数组中，完后对数组中的元素一次操作即可 注意数组尺寸1e5+，题目

多线程基础知识复习 程序、进程、线程的作用 程序：一组指定集合（一段静态代码）- 静 进程：程序的一次执行过程（把程序加载到内存让它跑起来，即运行起来的程序）- 动 线程：进程可以进一步细化为线程，是程序内部的一条执行路径 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器 补充无关知识点：单核与多核 单核：一个时间只能做一件事，假的多线程 多核：一个时间可以做多件事情，真正的多线程 一个java应用程序至少有3个线程：main、gc、异常处理 并行与并发 并行：多个CPU同一时间

题目描述 给你单链表的头节点 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。 样例 输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5] 做链表题目的关键是 画图、画图、画图！ 1.数组记录并交换存储的值 Java 代码 /** * Definition for singly-linked list. * pub

题目描述 给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7], 样例 3 / \ 9 20 / \ 15 7 返回其自底向上的层序遍历为： [ [15,7], [9,20], [3] ] Java 代码 /** * Definition for a binary tree node. * public class Tree

面试题：关于静态块、构造块、构造函数、普通代码块的优先级问题 静态块：的优先级最高，伴随类的加载而加载，且只会加载一次 构造块：即成员代码块（写在类体中的代码块），优先级次于静态块，高于构造函数，且每次创建新对象都会执行 构造函数：优先级次于静态块、构造块，每次创建新对象都会调用 普通快：最没地位，优先级最低 总结： 静态块 > 构造块 > 构造函数 > 普通快 看下面一段代码，了解在继承关系中，四者的优先级及调用顺序 父类 public class Father { //

题目描述 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。 样例 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5] 之前自己写的模拟太蠢了，参考了下y总的思路，很清晰，高频题目，要求快速准确写出 Java 代码 class Solution { boolean[][] vis; List<Integer> list = new ArrayList<

汉诺塔问题 解决思路（分治） 以三根柱子，n个圆盘为例； 将一根柱子上的所有圆盘分成上n - 1堆和最下面一个，先设法将n - 1个移动到第二根柱子上（中转站），再将最大的一个盘子移动到目标柱子上； 随后再将第一根柱子作为中转站，将第二根柱子上的n - 1个圆盘设法移动到目标柱子上 递归求解方式 详解点击这里 class Solution { int ans = 0; void dfs(int n, List<Integer> A, List<Integer&gt

题目描述 不使用任何内建的哈希表库设计一个哈希集合（HashSet）。 实现 MyHashSet 类： void add(key) 向哈希集合中插入值 key 。 bool contains(key) 返回哈希集合中是否存在这个值 key 。 void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。 样例 输入： ["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "

题目描述 序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如#。 _9_ / \ 3 2 / \ / \ 4 1 # 6 / \ / \ / \ # # # # # # 样例 输入: "9,3,4,#,#,1,#,#,2,#,6,#,#" 输出: true 算法 dfs模拟建树 Java 代码 class Solution { Strin

题目描述 给你一个字符串表达式s，请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 样例 输入：s = "3+2*2" 输出：7 算法 栈模拟 时间复杂度 O(n)O(n)O(n) Java 代码 class Solution { int[] stk1; char[] stk2; int tt1 = 0, tt2 = 0; int solve(int a, int b, char op) { int ans = 0;

题目描述 实现一个基本的计算器来计算一个简单的字符串表达式 s 的值。 样例 输入：s = "(1+(4+5+2)-3)+(6+8)" 输出：23 算法 栈模拟 本题不难，难在怎么一次做对 开两个栈一个存放操作数和括号（栈1，为方便负数运算，这里栈建议定义成数值型，括号可以使用特殊数值替代），一个存放运算符+、-（栈2） 遇到’('直接入栈1，遇到运算符直接入栈2； 遇到’)‘先不要让其入栈，弹出栈1的栈顶元素放入temp保存，再弹出栈1的栈顶元素（这个元素一定是’(’，没有为什么，按照这套

题目描述 给你一个字符串 s，请你将s分割成一些子串，使每个子串都是回文。 返回符合要求的 最少分割次数 。 样例 输入：s = "aab" 输出：1 解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。 算法 动态规划 f(i)表示的是以i结尾的字符串所包含回文子串的数量 0-i 划分为 0-k-1（以k-1结尾包含回文串的最小数量）、k-i（最后一段） 即递推式：f[i] = min(f[k - 1] + 1, f[i]) ！因为我这里下标是从0开始的，所以当k==0时要

题目描述 给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。 返回 s 所有可能的分割方案。 样例 输入: "aab" 输出: [ ["aa","b"], ["a","a","b"] ] 算法 dfs + 剪枝 在回文判断中预先打表 Java 代码 class Solution { List<List<String>> ans = new ArrayList<>(); List<String> part = new

题目描述 给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。 样例 输入: [1,2,1] 输出: [2,-1,2] 解释: 第一个 1 的下一个更大的数是 2； 数字 2 找不到下一个更大的数； 第二个 1 的下一个最大的数需要循环搜索，结果也是 2。 注意: 输入数组的长度不会超过 10000。 算法1 暴

题目描述 给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。 请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。 说明: 不允许旋转信封。 样例 输入: envelopes = [[5,4],[6,4],[6,7],[2,3]] 输出: 3 解释: 最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。

题目描述 找到给定字符串（由小写字符组成）中的最长子串 T ， 要求 T 中的每一字符出现次数都不少于 k 。输出 T 的长度。 样例 输入: s = "aaabb", k = 3 输出: 3 最长子串为 "aaa" ，其中 'a' 重复了 3 次。 算法 (枚举 + 双指针) 时间复杂度 O(26∗n)O(26 * n)O(26∗n) 参考文献 Java 代码 class Solution { int[] word = new int [26]; int K, x, y;

题目描述 今天，书店老板有一家店打算试营业 customers.length 分钟。每分钟都有一些顾客（customers[i]）会进入书店，所有这些顾客都会在那一分钟结束后离开。 在某些时候，书店老板会生气。 如果书店老板在第 i 分钟生气，那么 grumpy[i] = 1，否则 grumpy[i] = 0。 当书店老板生气时，那一分钟的顾客就会不满意，不生气则他们是满意的。 书店老板知道一个秘密技巧，能抑制自己的情绪，可以让自己连续 X 分钟不生气，但却只能使用一次。 请你返回这一天营业下来，最多有多少

题目描述 给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。 如果不存在满足条件的子数组，则返回 0 。 样例 输入：nums = [8,2,4,7], limit = 4 输出：2 解释：所有子数组如下： [8] 最大绝对差 |8-8| = 0 <= 4. [8,2] 最大绝对差 |8-2| = 6 > 4. [8,2,4] 最大绝对差 |8-2| = 6 > 4. [8,

剑指 Offer 26. 树的子结构 题目描述 输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构， 即 A中有出现和B相同的结构和节点值。 例如: 给定的树 A: 3 / \ 4 5 / \ 1 2 给定的树 B： 4 / 1 返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。 样例 输入：A = [1,2,3], B = [3,1] 输出：false 算法 (dfs) O(mn)

剑指 Offer 07. 重建二叉树 题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 样例 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 解决思路 (分治) O(logn)O(logn)O(logn) 这道题目关键思路在于利用preorder和i