diff --git "a/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\347\237\245\350\257\206\346\242\263\347\220\206.xmind" "b/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\347\237\245\350\257\206\346\242\263\347\220\206.xmind"
new file mode 100644
index 0000000..37630b4
Binary files /dev/null and "b/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\347\237\245\350\257\206\346\242\263\347\220\206.xmind" differ
diff --git "a/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\345\244\247\345\216\202\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\345\210\267\351\242\230\347\217\255" "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\345\244\247\345\216\202\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\345\210\267\351\242\230\347\217\255"
new file mode 100644
index 0000000..4e53141
--- /dev/null
+++ "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\345\244\247\345\216\202\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\345\210\267\351\242\230\347\217\255"
@@ -0,0 +1,2752 @@
+大厂高频算法和数据结构面试题
+
+01 大厂高频算法和数据结构面试题1
+
+题目：
+
+给定一个有序数组arr，代表坐落在X轴上的点，给定一个正数K，代表绳子的长度，返回绳子最多压中几个点？
+即使绳子边缘处盖住点也算盖住
+
+给定一个文件目录的路径，写一个函数统计这个目录下所有的文件数量并返回，隐藏文件也算，但是文件夹不算
+
+给定一个非负整数num，如何不用循环语句，返回>=num，并且离num最近的，2的某次方
+
+一个数组中只有两种字符'G'和'B'，可以让所有的G都放在左侧，所有的B都放在右侧
+或者可以让所有的G都放在右侧，所有的B都放在左侧，但是只能在相邻字符之间进行交换操作，返回至少需要交换几次
+
+给定一个二维数组matrix，你可以从任何位置出发，走向上、下、左、右四个方向，返回能走出来的最长的递增链长度
+
+给定两个非负数组x和hp，长度都是N，再给定一个正数range
+x有序，x[i]表示i号怪兽在x轴上的位置
+hp[i]表示i号怪兽的血量
+再给定一个正数range，表示如果法师释放技能的范围长度
+被打到的每只怪兽损失1点血量。返回要把所有怪兽血量清空，至少需要释放多少次AOE技能？
+
+给定一个数组arr，你可以在每个数字之前决定+或者-但是必须所有数字都参与，再给定一个数target
+请问最后算出target的方法数
+
+
+
+02 大厂高频算法和数据结构面试题2
+
+题目：
+
+给定数组hard和money，长度都为N，hard[i]表示i号工作的难度， money[i]表示i号工作的收入
+给定数组ability，长度都为M，ability[j]表示j号人的能力，每一号工作，都可以提供无数的岗位，难度和收入都一样
+但是人的能力必须>=这份工作的难度，才能上班。返回一个长度为M的数组ans，ans[j]表示j号人能获得的最好收入
+
+贩卖机只支持硬币支付，且收退都只支持10 ，50，100三种面额
+一次购买只能出一瓶可乐，且投钱和找零都遵循优先使用大钱的原则
+需要购买的可乐数量是m，其中手头拥有的10、50、100的数量分别为a、b、c，可乐的价格是x(x是10的倍数)
+请计算出需要投入硬币次数
+
+已知一个消息流会不断地吐出整数1~N，但不一定按照顺序依次吐出，如果上次打印的序号为i， 那么当i+1出现时
+请打印i+1及其之后接收过的并且连续的所有数，直到1~N全部接收并打印完，请设计这种接收并打印的结构
+
+现有司机N*2人，调度中心会将所有司机平分给A、B两区域，i号司机去A可得收入为income[i][0]，去B可得收入为income[i][1]
+返回能使所有司机总收入最高的方案是多少钱?
+
+设计有setAll功能的哈希表，put、get、setAll方法，时间复杂度O(1)
+
+给定一个数组arr，只能对arr中的一个子数组排序，但是想让arr整体都有序，返回满足这一设定的子数组中最短的是多长
+
+
+
+03 大厂高频算法和数据结构面试题3
+
+题目：
+
+求一个字符串中，最长无重复字符子串长度
+
+只由小写字母（a~z）组成的一批字符串，都放在字符类型的数组String[] arr中，如果其中某两个字符串所含有的字符种类完全一样
+就将两个字符串算作一类，比如baacbba和bac就算作一类，返回arr中有多少类
+
+给定一个只有0和1组成的二维数组，返回边框全是1（内部无所谓）的最大正方形面积
+
+给定一个数组arr，代表每个人的能力值。再给定一个非负数k，如果两个人能力差值正好为k，那么可以凑在一起比赛
+一局比赛只有两个人，返回最多可以同时有多少场比赛
+
+给定一个正数数组arr，代表若干人的体重，再给定一个正数limit，表示所有船共同拥有的载重量，每艘船最多坐两人，且不能超过载重
+想让所有的人同时过河，并且用最好的分配方法让船尽量少，返回最少的船数
+Leetcode链接 : https://leetcode.com/problems/boats-to-save-people/
+
+给定整数数组nums和目标值goal，需要从nums中选出一个子序列，使子序列元素总和最接近goal
+也就是说如果子序列元素和为sum ，需要最小化绝对差abs(sum - goal)，返回 abs(sum - goal)可能的最小值
+注意数组的子序列是通过移除原始数组中的某些元素（可能全部或无）而形成的数组。
+
+电子游戏“辐射4”中，任务“通向自由”要求玩家到达名为“Freedom Trail Ring”的金属表盘，并使用表盘拼写特定关键词才能开门
+给定一个字符串 ring，表示刻在外环上的编码；给定另一个字符串 key，表示需要拼写的关键词。您需要算出能够拼写关键词中所有字符的最少步数
+最初，ring 的第一个字符与12:00方向对齐。您需要顺时针或逆时针旋转 ring 以使 key 的一个字符在 12:00 方向对齐，然后按下中心按钮，以此逐个拼写完 key 中的所有字符
+旋转 ring 拼出 key 字符 key[i] 的阶段中：
+您可以将 ring 顺时针或逆时针旋转一个位置，计为1步。旋转的最终目的是将字符串 ring 的一个字符与 12:00 方向对齐，并且这个字符必须等于字符 key[i] 。
+如果字符 key[i] 已经对齐到12:00方向，您需要按下中心按钮进行拼写，这也将算作 1 步。按完之后，您可以开始拼写 key 的下一个字符（下一阶段）, 直至完成所有拼写。
+Leetcode题目：https://leetcode.com/problems/freedom-trail/
+
+给定三个参数，二叉树的头节点head，树上某个节点target，正数K。从target开始，可以向上走或者向下走，返回与target的距离是K的所有节点
+
+
+
+04 大厂高频算法和数据结构面试题4
+
+题目：
+
+数组为{3, 2, 2, 3, 1}，查询为(0, 3, 2)，意思是在数组里下标0~3这个范围上，有几个？答案返回2
+假设给你一个数组arr，对这个数组的查询非常频繁，且都给了查询组，请返回所有查询的结果
+
+返回一个数组中子数组最大累加和
+
+返回一个二维数组中子矩阵最大累加和
+
+返回一个数组中所选数字不能相邻的情况下最大子序列累加和
+
+老师想给孩子们分发糖果，有N个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分
+你需要按照以下要求，帮助老师给这些孩子分发糖果：
+每个孩子至少分配到 1 个糖果。
+评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
+那么这样下来，返回老师至少需要准备多少颗糖果
+进阶：在原来要求的基础上，增加一个要求，相邻的孩子间如果分数一样，分的糖果数必须一样，返回至少需要准备多少颗糖果
+
+生成长度为size的达标数组，什么叫达标？对于任意的i<k<j，满足[i]+[j]!=[k]*2。给定一个正数size，返回长度为size的达标数组
+
+给定三个字符串s1、s2、s3，请你帮忙验证s3是否是由s1和s2交错组成的
+Leetcode题目：https://leetcode.com/problems/interleaving-string/
+
+大楼轮廓线问题
+Leetcode题目：https://leetcode.com/problems/the-skyline-problem/
+
+
+
+05 大厂高频算法和数据结构面试题5
+
+题目：
+
+已知一棵搜索二叉树上没有重复值的节点，现在有一个数组arr，是这棵搜索二叉树先序遍历的结果，请根据arr生成整棵树并返回头节点
+
+如果一个节点X，它左树结构和右树结构完全一样，那么我们说以X为头的树是相等树，给定一棵二叉树的头节点head，返回head整棵树上有多少棵相等子树
+
+编辑距离问题
+
+给定两个字符串s1和s2，问s2最少删除多少字符可以成为s1的子串？比如 s1 = "abcde"，s2 = "axbc"，s2删掉'x'即可，返回1
+
+
+
+06 大厂高频算法和数据结构面试题6
+
+数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，返回arr的最大子数组异或和
+
+数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，想知道arr中哪两个数的异或结果最大，返回最大的异或结果
+Leetcode题目：https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/
+
+给定一个非负整数组成的数组nums。另有一个查询数组queries，其中queries[i]=[xi, mi]
+第i个查询的答案是xi和任何nums数组中不超过mi的元素按位异或（XOR）得到的最大值
+换句话说，答案是max(nums[j] XOR xi)，其中所有j均满足nums[j]<= mi。如果nums中的所有元素都大于mi，最终答案就是-1
+返回一个整数数组answer作为查询的答案，其中answer.length==queries.length且answer[i]是第i个查询的答案
+Leetcode题目：https://leetcode.com/problems/maximum-xor-with-an-element-from-array/
+
+数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，可以任意切分成若干个不相交的子数组。其中一定存在一种最优方案，使得切出异或和为0的子数组最多，返回这个最多数量
+
+Nim博弈，给定一个正数数组arr，先手和后手每次可以选择在一个位置拿走若干值，这个值要大于0，但是要小于该处的剩余，谁最先拿空arr谁赢，根据arr返回谁赢
+
+
+
+07 大厂高频算法和数据结构面试题7
+
+给定一个非负数组成的数组，长度一定大于1，想知道数组中哪两个数&的结果最大，返回这个最大结果。要求时间复杂度O(N)，额外空间复杂度O(1)
+
+给定一个二叉树，我们在树的节点上安装摄像头，节点上的每个摄影头都可以监视其父对象、自身及其直接子对象，计算监控树的所有节点所需的最小摄像头数量
+
+给定一个数组arr，返回如果排序之后（注意是如果排序），相邻两数的最大差值。要求时间复杂度O(N)，不能使用非基于比较的排序
+
+给定一个有序数组arr，其中值可能为正、负、0。返回arr中每个数都平方之后不同的结果有多少种？
+给定一个数组arr，先递减然后递增，返回arr中有多少个不同的数字？
+
+假设所有字符都是小写字母，大字符串是str，arr是去重的单词表, 每个单词都不是空字符串且可以使用任意次。使用arr中的单词有多少种拼接str的方式，返回方法数。
+
+String str, int K, String[] parts, int[] record
+Parts和records的长度一样长，str一定要分割成k个部分，分割出来的每部分在parts里必须得有，那一部分的得分在record里，请问str切成k个部分，返回最大得分
+
+
+
+08 大厂高频算法和数据结构面试题8
+
+给定一个字符串表达式str，str表示一个公式，公式里可能有整数、加减乘除符号和左右括号。返回公式的计算结果
+难点在于括号可能嵌套很多层，str="48*((70-65)-43)+8*1"，返回-1816。str="3+1*4"，返回7。str="3+(1*4)"，返回7。
+1，可以认为给定的字符串一定是正确的公式，即不需要对str做公式有效性检查
+2，如果是负数，就需要用括号括起来，比如"4*(-3)"但如果负数作为公式的开头或括号部分的开头，则可以没有括号，比如"-3*4"和"(-3*4)"都是合法的
+3，不用考虑计算过程中会发生溢出的情况。
+测试链接 : https://leetcode.cn/problems/basic-calculator-iii/
+
+给定n个非负整数a1，a2，...an，每个数代表坐标中的一个点 (i, ai)。在坐标内画n条垂直线
+垂直线i的两个端点分别为(i, ai)和(i, 0)，找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水
+Leetcode题目：https://leetcode.com/problems/container-with-most-water/
+
+给定一个char[][] matrix，也就是char类型的二维数组，再给定一个字符串word，
+可以从任何一个某个位置出发，可以走上、下、左、右，能不能找到word？
+ char[][] m = {  { 'a', 'b', 'z' }, 
+                 { 'c', 'd', 'o' }, 
+                 { 'f', 'e', 'o' } }
+设定1：可以走重复路的情况下，返回能不能找到
+比如，word = "zoooz"，是可以找到的，z -> o -> o -> o -> z，因为允许走一条路径中已经走过的字符
+设定2：不可以走重复路的情况下，返回能不能找到
+比如，word = "zoooz"，是不可以找到的，因为允许走一条路径中已经走过的字符不能重复走 
+
+给定一个矩阵matrix，值有正、负、0。蛇可以空降到最左列的任何一个位置，初始增长值是0。蛇每一步可以选择右上、右、右下三个方向的任何一个前进
+沿途的数字累加起来，作为增长值；但是蛇一旦增长值为负数，就会死去。蛇有一种能力，可以使用一次：把某个格子里的数变成相反数
+蛇可以走到任何格子的时候停止，返回蛇能获得的最大增长值
+
+
+
+09 大厂高频算法和数据结构面试题9
+
+题目：
+
+给定一个数组arr，长度为N，arr中的值不是0就是1。arr[i]表示第i栈灯的状态，0代表灭灯，1代表亮灯
+每一栈灯都有开关，但是按下i号灯的开关，会同时改变i-1、i、i+1栈灯的状态
+问题一：如果N栈灯排成一条直线,请问最少按下多少次开关？
+i为中间位置时，i号灯的开关能影响i-1、i和i+1
+0号灯的开关只能影响0和1位置的灯
+N-1号灯的开关只能影响N-2和N-1位置的灯
+问题二：如果N栈灯排成一个圈,请问最少按下多少次开关,能让灯都亮起来
+i为中间位置时，i号灯的开关能影响i-1、i和i+1
+0号灯的开关能影响N-1、0和1位置的灯
+N-1号灯的开关能影响N-2、N-1和0位置的灯
+
+给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。返回所有可能的结果。答案可以按任意顺序返回
+Leetcode题目：https://leetcode.com/problems/remove-invalid-parentheses/
+
+给定一个数组arr，求最长递增子序列长度
+Leetcode题目：https://leetcode.com/problems/longest-increasing-subsequence
+
+给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度
+当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样
+请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）
+注意：不允许旋转信封
+
+定义何为step sum？比如680，680 + 68 + 6 = 754，680的step sum叫754。给定一个正数num，判断它是不是某个数的step sum
+
+
+
+10 大厂高频算法和数据结构面试题10
+
+题目：
+
+给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。
+你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。
+
+Top K Frequent Words II
+Implement three methods for Topk Class:
+TopK(k). The constructor.
+add(word). Add a new word.
+topk(). Get the current top k frequent words.
+LintCode题目：https://www.lintcode.com/problem/550/
+
+给出两个整数n和k，找出所有包含从1到n的数字，且恰好拥有k个逆序对的不同的数组的个数
+逆序对的定义如下：对于数组的第i个和第 j个元素，如果满i < j且 a[i] > a[j]，则其为一个逆序对，否则不是
+由于答案可能很大，只需要返回 答案 mod 10^9 + 7 的值
+Leetcode题目：https://leetcode.com/problems/k-inverse-pairs-array/
+
+给定一棵搜索二叉树头节点，转化成首尾相接的有序双向链表（节点都有两个方向的指针）
+
+给定一个布尔表达式和一个期望的布尔结果 result，布尔表达式由 0 (false)、1 (true)、& (AND)、 | (OR) 和 ^ (XOR) 符号组成。实现一个函数，算出有几种可使该表达式得出 result 值的括号方法。
+Leetcode题目：https://leetcode-cn.com/problems/boolean-evaluation-lcci/
+
+
+
+11 大厂高频算法和数据结构面试题11
+
+题目：
+
+问题一：一个字符串至少需要添加多少个字符能整体变成回文串
+问题二：返回问题一的其中一种添加结果
+问题三：返回问题一的所有添加结果
+
+问题一：一个字符串至少要切几刀能让切出来的子串都是回文串
+问题二：返回问题一的其中一种划分结果
+问题三：返回问题一的所有划分结果
+
+
+
+12 大厂高频算法和数据结构面试题12
+
+题目：
+
+给定长度为m的字符串aim，以及一个长度为n的字符串str，问能否在str中找到一个长度为m的连续子串，
+使得这个子串刚好由aim的m个字符组成，顺序无所谓，返回任意满足条件的一个子串的起始位置，未找到返回-1
+
+给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数
+进阶，在两个都有序的数组中找整体第K小的数，可以做到O(log(Min(M,N)))
+
+给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
+
+给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
+'.' 匹配任意单个字符
+'*' 匹配零个或多个前面的那一个元素
+所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。
+返回p能否匹配s
+
+
+
+13 大厂高频算法和数据结构面试题13
+
+题目：
+
+谷歌面试题扩展版，面值为1~N的牌组成一组，每次你从组里等概率的抽出1~N中的一张，下次抽会换一个新的组，有无限组
+当累加和<a时，你将一直抽牌；当累加和>=a且<b时，你将获胜；当累加和>=b时，你将失败
+返回获胜的概率，给定的参数为N，a，b
+
+假设有 n 台超级洗衣机放在同一排上。开始的时候，每台洗衣机内可能有一定量的衣服，也可能是空的
+在每一步操作中，你可以选择任意 m （1 ≤ m ≤ n） 台洗衣机，与此同时将每台洗衣机的一件衣服送到相邻的一台洗衣机
+给定一个非负整数数组代表从左至右每台洗衣机中的衣物数量，请给出能让所有洗衣机中剩下的衣物的数量相等的最少的操作步数
+如果不能使每台洗衣机中衣物的数量相等，则返回-1
+Leetcode题目：https://leetcode.com/problems/super-washing-machines/
+
+旋变字符串
+使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：
+如果字符串的长度为 1 ，算法停止
+如果字符串的长度 > 1 ，执行下述步骤：
+在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
+随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
+在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
+给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。
+Leetcode题目：https://leetcode.com/problems/scramble-string/
+
+有一个 m x n 的二元网格，其中 1 表示砖块，0 表示空白。砖块 稳定（不会掉落）的前提是：
+一块砖直接连接到网格的顶部，或者至少有一块相邻（4 个方向之一）砖块稳定不会掉落时
+给你一个数组 hits ，这是需要依次消除砖块的位置。每当消除 hits[i] = (rowi, coli) 位置上的砖块时，对应位置的砖块（若存在）会消失
+然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落，它会立即从网格中消失（即，它不会落在其他稳定的砖块上）
+返回一个数组 result ，其中 result[i] 表示第 i 次消除操作对应掉落的砖块数目
+注意，消除可能指向是没有砖块的空白位置，如果发生这种情况，则没有砖块掉落。
+Leetcode题目：https://leetcode.com/problems/bricks-falling-when-hit/
+
+
+
+14 大厂高频算法和数据结构面试题14
+
+题目：
+
+给定一个只由左括号和右括号的字符串，返回最长的有效括号子串的长度
+
+arr中求子数组的累加和是<=K的并且是最大的，返回这个最大的累加和
+
+从二叉树的某个节点x开始，往下子节点都要的，叫子树；在二叉树上只要能连起来的任何结构，叫子拓扑结构；
+返回二叉树上满足搜索二叉树性质的、最大子拓扑结构的节点数
+
+给定一个棵完全二叉树，返回这棵树的节点个数，要求时间复杂度小于O(树的节点数)
+
+给定一个棵搜索二叉树的头节点head，其中有两个节点错了，交换过来就能让整棵树重新变成搜索二叉树，怎么找到并调整正确？
+Leetcode题目：https://leetcode.com/problems/recover-binary-search-tree/
+
+给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
+ 
+
+
+15 大厂高频算法和数据结构面试题15
+
+题目：股票系列问题
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/
+
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
+
+
+
+16 大厂高频算法和数据结构面试题16
+
+题目：
+
+给定一个有正、有负、有0的数组arr，
+给定一个整数k，
+返回arr的子集是否能累加出k
+1）正常怎么做？
+2）如果arr中的数值很大，但是arr的长度不大，怎么做？
+
+给定一个正数数组arr，
+返回arr的子集不能累加出的最小正数
+1）正常怎么做？
+2）如果arr中肯定有1这个值，怎么做？
+
+给定一个已排序的正整数数组 nums，和一个正整数 n 。从 [1, n] 区间内选取任意个数字补充到 nums 中，
+使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示，请输出满足上述要求的最少需要补充的数字个数
+
+给定整数power，给定一个数组arr，给定一个数组reverse。含义如下：
+arr的长度一定是2的power次方，reverse中的每个值一定都在0~power范围。
+例如power = 2, arr = {3, 1, 4, 2}，reverse = {0, 1, 0, 2}
+任何一个在前的数字可以和任何一个在后的数组，构成一对数。可能是升序关系、相等关系或者降序关系。
+比如arr开始时有如下的降序对：(3,1)、(3,2)、(4,2)，一共3个。
+接下来根据reverse对arr进行调整：
+reverse[0] = 0, 表示在arr中，划分每1(2的0次方)个数一组，然后每个小组内部逆序，那么arr变成[3,1,4,2]，此时有3个逆序对。
+reverse[1] = 1, 表示在arr中，划分每2(2的1次方)个数一组，然后每个小组内部逆序，那么arr变成[1,3,2,4]，此时有1个逆序对
+reverse[2] = 0, 表示在arr中，划分每1(2的0次方)个数一组，然后每个小组内部逆序，那么arr变成[1,3,2,4]，此时有1个逆序对。
+reverse[3] = 2, 表示在arr中，划分每4(2的2次方)个数一组，然后每个小组内部逆序，那么arr变成[4,2,3,1]，此时有5个逆序对。
+所以返回[3,1,1,5]，表示每次调整之后的逆序对数量。
+输入数据状况：
+power的范围[0,20]
+arr长度范围[1,10的7次方]
+reverse长度范围[1,10的6次方]
+
+约瑟夫环问题
+给定一个链表头节点head，和一个正数m，从头开始，每次数到m就杀死当前节点，然后被杀节点的下一个节点从1开始重新数，周而复始直到只剩一个节点，返回最后的节点
+Leetcode题目：https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/
+
+
+
+17 大厂高频算法和数据结构面试题17
+
+题目：
+
+给定一个每一行有序、每一列也有序，整体可能无序的二维数组，再给定一个数num，返回二维数组中有没有num这个数
+
+给定一个每一行有序、每一列也有序，整体可能无序的二维数组，再给定一个正数k，返回二维数组中第k小的数
+Leetcode题目：https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/
+
+给定一个字符串数组arr，里面都是互不相同的单词，找出所有不同的索引对(i, j)，使得列表中的两个单词，words[i] + words[j]，可拼接成回文串。
+Leetcode题目：https://leetcode.com/problems/palindrome-pairs/
+
+给定两个字符串S和T，返回S的所有子序列中有多少个子序列的字面值等于T
+
+给定一个字符串str，返回str的所有子序列中有多少不同的字面值
+Leetcode题目：https://leetcode.com/problems/distinct-subsequences-ii/
+
+
+
+18 大厂高频算法和数据结构面试题18
+
+题目：
+
+给定一个数组arr，长度为N，arr中的值只有1，2，3三种
+arr[i] == 1，代表汉诺塔问题中，从上往下第i个圆盘目前在左
+arr[i] == 2，代表汉诺塔问题中，从上往下第i个圆盘目前在中
+arr[i] == 3，代表汉诺塔问题中，从上往下第i个圆盘目前在右
+那么arr整体就代表汉诺塔游戏过程中的一个状况，如果这个状况不是汉诺塔最优解运动过程中的状况，返回-1
+如果这个状况是汉诺塔最优解运动过程中的状态，返回它是第几个状态
+
+在给定的二维二进制数组 A 中，存在两座岛。（岛是由四面相连的 1 形成的一个最大组。）现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。
+返回必须翻转的 0 的最小数目。（可以保证答案至少是1）
+Leetcode题目：https://leetcode.com/problems/shortest-bridge/
+
+给定一个矩阵matrix，先从左上角开始，每一步只能往右或者往下走，走到右下角。然后从右下角出发，每一步只能往上或者往左走，再回到左上角。任何一个位置的数字，只能获得一遍。返回最大路径和。
+输入描述:
+第一行输入两个整数M和N，M,N<=200
+接下来M行，每行N个整数，表示矩阵中元素
+输出描述:
+输出一个整数，表示最大路径和
+牛客网题目：https://www.nowcoder.com/questionTerminal/8ecfe02124674e908b2aae65aad4efdf
+
+给定两个有序数组arr1和arr2，再给定一个整数k，返回来自arr1和arr2的两个数相加和最大的前k个，两个数必须分别来自两个数组，按照降序输出
+时间复杂度为O(klogk)
+输入描述：
+第一行三个整数N, K分别表示数组arr1, arr2的大小，以及需要询问的数
+接下来一行N个整数，表示arr1内的元素
+再接下来一行N个整数，表示arr2内的元素
+输出描述：
+输出K个整数表示答案
+牛客网题目：https://www.nowcoder.com/practice/7201cacf73e7495aa5f88b223bbbf6d1
+
+
+
+19 大厂高频算法和数据结构面试题19
+
+题目：
+
+LRU内存/缓存替换算法
+Leetcode题目：https://leetcode.com/problems/lru-cache/
+
+LFU内存/缓存替换算法
+Leetcode题目：https://leetcode.com/problems/lfu-cache/
+
+给定一个正数N，比如N = 13，在纸上把所有数都列出来如下：
+1 2 3 4 5 6 7 8 9 10 11 12 13
+可以数出1这个字符出现了6次，给定一个正数N，如果把1~N都列出来，返回1这个字符出现的多少次
+
+你有k个非递减排列的整数列表。找到一个最小区间，使得k个列表中的每个列表至少有一个数包含在其中
+我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。
+Leetcode题目：https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/
+
+一张扑克有3个属性，每种属性有3种值（A、B、C）
+比如"AAA"，第一个属性值A，第二个属性值A，第三个属性值A
+比如"BCA"，第一个属性值B，第二个属性值C，第三个属性值A
+给定一个字符串类型的数组cards[]，每一个字符串代表一张扑克
+从中挑选三张扑克，一个属性达标的条件是：这个属性在三张扑克中全一样，或全不一样
+挑选的三张扑克达标的要求是：每种属性都满足上面的条件
+比如："ABC"、"CBC"、"BBC"
+第一张第一个属性为"A"、第二张第一个属性为"C"、第三张第一个属性为"B"，全不一样
+第一张第二个属性为"B"、第二张第二个属性为"B"、第三张第二个属性为"B"，全一样
+第一张第三个属性为"C"、第二张第三个属性为"C"、第三张第三个属性为"C"，全一样
+每种属性都满足在三张扑克中全一样，或全不一样，所以这三张扑克达标
+返回在cards[]中任意挑选三张扑克，达标的方法数
+
+
+
+20 大厂高频算法和数据结构面试题20
+
+题目：
+
+如果只给定一个二叉树前序遍历数组pre和中序遍历数组in，能否不重建树，而直接生成这个二叉树的后序数组并返回，已知二叉树中没有重复值
+
+给定一个由不同正整数的组成的非空数组 A，考虑下面的图：有 A.length 个节点，按从 A[0] 到 A[A.length - 1] 标记；
+只有当 A[i] 和 A[j] 共用一个大于 1 的公因数时，A[i] 和 A[j] 之间才有一条边。返回图中最大连通集合的大小
+Leetcode题目：https://leetcode.com/problems/largest-component-size-by-common-factor/
+
+完美洗牌问题
+给定一个长度为偶数的数组arr，假设长度为N*2
+左部分：arr[L1...Ln] 右部分： arr[R1...Rn]
+请把arr调整成arr[L1,R1,L2,R2,L3,R3,...,Ln,Rn]
+要求时间复杂度O(N)，额外空间复杂度O(1)
+
+给定一个字符串str，当然可以生成很多子序列，返回有多少个子序列是回文子序列，空序列不算回文
+比如，str = “aba”，回文子序列：{a}、{a}、 {a,a}、 {b}、{a,b,a}，返回5
+
+
+
+21 大厂高频算法和数据结构面试题21
+
+题目：
+
+树链剖分专题
+给定数组father，大小为N，表示一共有N个节点
+father[i] = j 表示点i的父亲是点j， father表示的树一定是一棵树而不是森林
+给定数组values，大小为N，values[i]=v表示节点i的权值是v
+实现如下4个方法，保证4个方法都很快！
+1)让某个子树所有节点值加上v，入参：int head, int v
+2)查询某个子树所有节点值的累加和，入参：int head
+3)在树上从a到b的整条链上所有加上v，入参：int a, int b, int v
+4)查询在树上从a到b的整条链上所有节点值的累加和，入参：int a, int b
+
+
+
+22 大厂高频算法和数据结构面试题22
+
+题目：
+
+给定数组 nums 由正整数组成，找到三个互不重叠的子数组的最大和。每个子数组的长度为k，我们要使这3*k个项的和最大化。返回每个区间起始索引的列表（索引从 0 开始）。如果有多个结果，返回字典序最小的一个。
+Leetcode题目：https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/
+
+给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水
+Leetcode题目：https://leetcode.com/problems/trapping-rain-water/
+
+给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。
+Leetcode题目：https://leetcode.com/problems/trapping-rain-water-ii/
+
+一个不含有负数的数组可以代表一圈环形山，每个位置的值代表山的高度
+比如， {3,1,2,4,5}、{4,5,3,1,2}或{1,2,4,5,3}都代表同样结构的环形山
+山峰A和山峰B能够相互看见的条件为: 
+1.如果A和B是同一座山，认为不能相互看见
+2.如果A和B是不同的山，并且在环中相邻，认为可以相互看见
+3.如果A和B是不同的山，并且在环中不相邻，假设两座山高度的最小值为min
+       1)如果A通过顺时针方向到B的途中没有高度比min大的山峰，认为A和B可以相互看见
+       2)如果A通过逆时针方向到B的途中没有高度比min大的山峰，认为A和B可以相互看见
+两个方向只要有一个能看见，就算A和B可以相互看见
+给定一个不含有负数且没有重复值的数组 arr，请返回有多少对山峰能够相互看见
+进阶，给定一个不含有负数但可能含有重复值的数组arr，返回有多少对山峰能够相互看见
+
+你正在安装一个广告牌，并希望它高度最大。这块广告牌将有两个钢制支架，两边各一个。每个钢支架的高度必须相等。
+你有一堆可以焊接在一起的钢筋 rods。举个例子，如果钢筋的长度为 1、2 和 3，则可以将它们焊接在一起形成长度为 6 的支架。
+返回广告牌的最大可能安装高度。如果没法安装广告牌，请返回 0。
+Leetcode题目：https://leetcode.com/problems/tallest-billboard/
+
+
+
+23 大厂高频算法和数据结构面试题23
+
+题目：
+
+给定数组father大小为N，表示一共有N个节点
+father[i] = j 表示点i的父亲是点j， father表示的树一定是一棵树而不是森林
+queries是二维数组，大小为M*2，每一个长度为2的数组都表示一条查询
+[4,9], 表示想查询4和9之间的最低公共祖先… 
+[3,7], 表示想查询3和7之间的最低公共祖先…
+tree和queries里面的所有值，都一定在0~N-1之间
+返回一个数组ans，大小为M，ans[i]表示第i条查询的答案
+
+给定一个数组arr，长度为N > 1，从中间切一刀，保证左部分和右部分都有数字，一共有N-1种切法
+如此多的切法中，每一种都有:绝对值(左部分最大值 – 右部分最大值)，返回最大的绝对值是多少
+
+定义什么是可整合数组：一个数组排完序之后，除了最左侧的数外，有arr[i] = arr[i-1]+1
+则称这个数组为可整合数组比如{5,1,2,4,3}、{6,2,3,1,5,4}都是可整合数组，返回arr中最长可整合子数组的长度
+
+超级水王问题
+给定一个数组arr，长度为N，如果某个数出现次数大于N/2，称该数为水王数，如果arr中有水王数，打印这个数；如果没有水王数，打印没有水王数
+要求时间复杂度O(N)，额外空间复杂度O(1)
+扩展1：摩尔投票
+扩展2：给定一个正数K，返回所有出现次数>N/K的数
+
+有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。
+找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。
+Leetcode题目：https://leetcode.com/problems/minimum-cost-to-merge-stones/
+
+
+
+24 大厂高频算法和数据结构面试题24
+
+题目：
+
+给定一个正数数组arr，长度一定大于6（>=7），一定要选3个数字做分割点，从而分出4个部分，并且每部分都有数
+分割点的数字直接删除，不属于任何4个部分中的任何一个。返回有没有可能分出的4个部分累加和一样大
+如：{3,2,3,7,4,4,3,1,1,6,7,1,5,2}。可以分成{3,2,3}、{4,4}、{1,1,6}、{1,5,2}。分割点是不算的！
+
+长度为N的数组arr，一定可以组成N^2个数字对。例如arr = [3,1,2]，数字对有(3,3) (3,1) (3,2) (1,3) (1,1) (1,2) (2,3) (2,1) (2,2)
+也就是任意两个数都可以，而且自己和自己也算数字对。数字对怎么排序？第一维数据从小到大；第一维数据一样的，第二维数组也从小到大
+所以上面的数值对排序的结果为：(1,1)(1,2)(1,3)(2,1)(2,2)(2,3)(3,1)(3,2)(3,3)。给定一个数组arr，和整数k，返回第k小的数值对
+
+正常的里程表会依次显示自然数表示里程
+吉祥的里程表会忽略含有4的数字而跳到下一个完全不含有4的数
+正常：1 2 3 4 5 6 7 8  9 10 11 12 13 14 15
+吉祥：1 2 3 5 6 7 8 9 10 11 12 13 15 16 17 ... 38 39 50 51 52 53 55
+给定一个吉祥里程表的数字num(当然这个数字中不含有4)
+返回这个数字代表的真实里程
+
+N * M的棋盘（N和M是输入参数），每种颜色的格子数必须相同的，上下左右的格子算相邻，相邻格子染的颜色必须不同，所有格子必须染色，返回至少多少种颜色可以完成任务
+
+给定两个字符串str1和str2，在str1中寻找一个最短子串，能包含str2的所有字符，字符顺序无所谓，str1的这个最短子串也可以包含多余的字符，返回这个最短包含子串
+
+给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）
+Leetcode题目：https://leetcode.com/problems/remove-duplicate-letters/
+
+
+
+25 大厂高频算法和数据结构面试题25
+
+题目：
+
+An IP address is a formatted 32-bit unsigned integer where each group of 8 bits is printed as a decimal number and the dot character '.' splits the groups.
+For example, the binary number 00001111 10001000 11111111 01101011 (spaces added for clarity) formatted as an IP address would be "15.136.255.107".
+A CIDR block is a format used to denote a specific set of IP addresses. It is a string consisting of a base IP address, followed by a slash, followed by a prefix length k.
+The addresses it covers are all the IPs whose first k bits are the same as the base IP address.
+For example, "123.45.67.89/20" is a CIDR block with a prefix length of 20. Any IP address whose binary representation matches
+01111011 00101101 0100xxxx xxxxxxxx, where x can be either 0 or 1, is in the set covered by the CIDR block.
+You are given a start IP address ip and the number of IP addresses we need to cover n. 
+Your goal is to use as few CIDR blocks as possible to cover all the IP addresses in the inclusive range [ip, ip + n - 1] exactly
+No other IP addresses outside of the range should be covered.
+Return the shortest list of CIDR blocks that covers the range of IP addresses. If there are multiple answers, return any of them.
+Leetcode题目：https://leetcode.com/problems/ip-to-cidr/
+
+给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组
+注意：答案中不可以包含重复的三元组
+Leetcode题目：https://leetcode.com/problems/3sum/
+
+给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。
+Leetcode题目：https://leetcode.com/problems/max-points-on-a-line/
+
+良好加油站问题最优解
+Leetcode题目：https://leetcode.com/problems/gas-station/
+
+
+
+26 大厂高频算法和数据结构面试题26
+
+题目：
+
+有三个有序数组，分别在三个数组中挑出3个数，x、y、z。返回 |x-y| + |y-z| + |z-x|最小是多少？
+Leetcode题目：https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/
+
+给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words，找出所有同时在二维网格和字典中出现的单词
+单词必须按照字母顺序，通过 相邻的单元格 内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格
+同一个单元格内的字母在一个单词中不允许被重复使用。
+Leetcode题目：https://leetcode.com/problems/word-search-ii/
+
+给定一个仅包含数字 0-9 的字符串和一个目标值，在数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回所有能够得到目标值的表达式。
+输入: num = "123", target = 6
+输出: ["1+2+3", "1*2*3"] 
+示例 2:
+输入: num = "232", target = 8
+输出: ["2*3+2", "2+3*2"]
+示例 3:
+输入: num = "105", target = 5
+输出: ["1*0+5","10-5"]
+示例 4:
+输入: num = "00", target = 0
+输出: ["0+0", "0-0", "0*0"]
+Leetcode题目：https://leetcode.com/problems/expression-add-operators/
+
+按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足：
+每对相邻的单词之间仅有单个字母不同。
+转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词
+给你两个单词 beginWord 和 endWord ，以及一个字典 wordList
+请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表
+每个序列都应该以单词列表 [beginWord, s1, s2, ..., sk] 的形式返回
+Leetcode题目：https://leetcode.com/problems/word-ladder-ii/
+
+
+
+27 大厂高频算法和数据结构面试题27
+
+题目：
+
+每一个项目都有三个数，[a,b,c]表示这个项目a和b乐队参演，花费为c
+每一个乐队可能在多个项目里都出现了，但是只能被挑一次
+nums是可以挑选的项目数量，所以一定会有nums*2只乐队被挑选出来
+返回一共挑nums轮(也就意味着一定请到所有的乐队)，最少花费是多少？
+如果怎么都无法在nums轮请到nums*2只乐队且每只乐队只能被挑一次，返回-1
+nums<9，programs长度小于500，每组测试乐队的全部数量一定是nums*2，且标号一定是0 ~ nums*2-1
+
+企鹅厂每年都会发文化衫，文化衫有很多种，厂庆的时候，企鹅们都需要穿文化衫来拍照
+一次采访中，记者随机遇到的企鹅，企鹅会告诉记者还有多少企鹅跟他穿一种文化衫
+我们将这些回答放在answers数组里，返回鹅厂中企鹅的最少数量
+Leetcode题目：https://leetcode.com/problems/rabbits-in-forest/
+
+给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标
+你可以假设每种输入只会对应一个答案。但是数组中同一个元素在答案里不能重复出现，你可以按任意顺序返回答案
+Leetcode题目：https://leetcode.com/problems/two-sum/
+
+给你一个32位的有符号整数x，返回将x中的数字部分反转后的结果，如果反转后整数超过 32 位的有符号整数的范围，就返回0
+假设环境不允许存储 64 位整数（有符号或无符号）
+Leetcode题目：https://leetcode.com/problems/reverse-integer/
+
+
+
+28 大厂高频算法和数据结构面试题28
+
+题目：
+
+请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）
+函数 myAtoi(string s) 的算法如下：
+读入字符串并丢弃无用的前导空格
+检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
+读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
+将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
+如果整数数超过 32 位有符号整数范围 [−231,  231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为231 − 1。
+返回整数作为最终结果。
+注意：本题中的空白字符只包括空格字符 ' ' 。除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
+Leetcode题目：https://leetcode.com/problems/string-to-integer-atoi/
+
+罗马数字包含以下七种字符： I， V， X， L，C，D 和 M
+字符          数值
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
+通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
+X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
+给你一个整数，将其转为罗马数字
+Leetcode题目：https://leetcode.com/problems/integer-to-roman/
+
+罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
+字符          数值
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
+通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 
+同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
+X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
+给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
+Leetcode题目：https://leetcode.com/problems/roman-to-integer/
+
+编写一个函数来查找字符串数组中的最长公共前缀，如果不存在公共前缀，返回空字符串 ""。
+Leetcode题目：https://leetcode.com/problems/longest-common-prefix/
+
+给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
+给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
+按键2对应：'a', 'b', 'c'
+按键3对应：'d', 'e', 'f'
+按键4对应：'g', 'h', 'i'
+按键5对应：'j', 'k', 'l'
+按键6对应：'m', 'n', 'o'
+按键7对应：'p', 'q', 'r', 's'
+按键8对应：'t', 'u', 'v'
+按键9对应：'w', 'x', 'y', 'z'
+示例 1：
+输入：digits = "23"
+输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
+示例 2：
+输入：digits = ""
+输出：[]
+示例 3：
+输入：digits = "2"
+输出：["a","b","c"]
+Leetcode题目：https://leetcode.com/problems/letter-combinations-of-a-phone-number/
+
+给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
+进阶：你能尝试使用一趟扫描实现吗？
+Leetcode题目：https://leetcode.com/problems/remove-nth-node-from-end-of-list/
+
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
+有效字符串需满足：
+左括号必须用相同类型的右括号闭合。
+左括号必须以正确的顺序闭合。
+Leetcode题目：https://leetcode.com/problems/valid-parentheses/
+
+数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。
+示例 1：
+输入：n = 3
+输出：["((()))","(()())","(())()","()(())","()()()"]
+示例 2：
+输入：n = 1
+输出：["()"]
+Leetcode题目：https://leetcode.com/problems/generate-parentheses/
+
+给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
+不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
+示例 1：
+输入：nums = [1,1,2]
+输出：2, nums = [1,2,_]
+解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+示例 2：
+输入：nums = [0,0,1,1,1,2,2,3,3,4]
+输出：5, nums = [0,1,2,3,4,_,_,_,_,_]
+解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+Leetcode题目：https://leetcode.com/problems/remove-duplicates-from-sorted-array/
+
+给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
+如果数组中不存在目标值 target，返回 [-1, -1]。
+要求：设计并实现时间复杂度为 O(log n) 的算法
+Leetcode题目：https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
+
+请你判断一个 9x9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
+数独部分空格内已填入了数字，空白格用 '.' 表示。
+注意：
+一个有效的数独（部分已被填充）不一定是可解的。
+只需要根据以上规则，验证已经填入的数字是否有效即可。
+Leetcode题目：https://leetcode.com/problems/valid-sudoku/
+
+编写一个程序，通过填充空格来解决数独问题。
+数独的解法需遵循如下规则：
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次
+数独部分空格内已填入了数字，空白格用 '.' 表示。
+Leetcode题目：https://leetcode.com/problems/sudoku-solver/
+
+给定一个正整数 n ，输出的第 n 项。
+前五项如下：
+1.     1
+2.     11
+3.     21
+4.     1211
+5.     111221
+第一项是数字 1 
+描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
+描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
+描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
+描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
+返回第N项的字符串
+Leetcode题目：https://leetcode.com/problems/count-and-say/
+
+给定一个字符串数组，将字母异位词组合在一起。可以按任意顺序返回结果列表。
+字母异位词指字母相同，但排列不同的字符串。
+示例 1:
+输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+示例 2:
+输入: strs = [""]
+输出: [[""]]
+示例 3:
+输入: strs = ["a"]
+输出: [["a"]]
+Leetcode题目：https://leetcode.com/problems/group-anagrams/
+
+
+
+29 大厂高频算法和数据结构面试题29
+
+题目：
+
+整数数组 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 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1
+Leetcode题目：https://leetcode.com/problems/search-in-rotated-sorted-array/
+已知存在一个按非降序排列的整数数组 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,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4]
+给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中
+如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。
+你必须尽可能减少整个操作步骤。
+Leetcode题目：https://leetcode.cn/problems/search-in-rotated-sorted-array-ii/
+
+实现 pow(x, n) ，即计算 x 的 n 次幂函数
+Leetcode题目：https://leetcode.com/problems/powx-n/
+
+以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]
+请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间
+Leetcode题目：https://leetcode.com/problems/merge-intervals/
+
+一个机器人位于一个 m x n 网格的左上角
+机器人每次只能向下或者向右移动一步
+机器人试图达到网格的右下角
+问总共有多少条不同的路径？
+Leetcode题目：https://leetcode.com/problems/unique-paths/
+
+给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加1
+最高位数字存放在数组的首位， 数组中每个元素只存储单个数字
+你可以假设除了整数 0 之外，这个整数不会以零开头
+示例 1：
+输入：digits = [1,2,3]
+输出：[1,2,4]
+解释：输入数组表示数字 123。
+示例 2：
+输入：digits = [9,9,9]
+输出：[1,0,0,0]
+解释：输入数组表示数字 1000。
+示例 3：
+输入：digits = [0]
+输出：[1]
+Leetcode题目：https://leetcode.com/problems/plus-one/
+
+实现 int sqrt(int x) 函数。
+计算并返回 x 的平方根，其中 x 是非负整数。
+由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
+示例 1:
+输入: 4
+输出: 2
+示例 2:
+输入: 8
+输出: 2
+说明: 8 的平方根是 2.82842...，由于返回类型是整数，小数部分将被舍去。
+Leetcode题目：https://leetcode.com/problems/sqrtx/
+
+给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
+进阶：
+一个直观的解决方案是使用 O(m * n) 的额外空间，但这并不是一个好的解决方案。
+一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
+你能想出一个仅使用常量空间的解决方案吗？
+Leetcode题目：https://leetcode.com/problems/set-matrix-zeroes/
+
+
+
+30 大厂高频算法和数据结构面试题30
+
+题目：
+
+给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
+单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
+Leetcode题目 : https://leetcode.com/problems/word-search/
+
+给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
+初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
+示例 1：
+输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+输出：[1,2,2,3,5,6]
+示例 2：
+输入：nums1 = [1], m = 1, nums2 = [], n = 0
+输出：[1]
+Leetcode题目 : https://leetcode.com/problems/merge-sorted-array/
+
+一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：
+'A' -> 1
+'B' -> 2
+...
+'Z' -> 26
+要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：
+"AAJF" ，将消息分组为 (1 1 10 6)
+"KJF" ，将消息分组为 (11 10 6)
+注意，消息不能分组为  (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。
+给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
+题目数据保证答案肯定是一个 32 位 的整数。
+Leetcode题目 : https://leetcode.com/problems/decode-ways/
+
+一条包含字母 A-Z 的消息通过以下的方式进行了编码：
+'A' -> 1
+'B' -> 2
+...
+'Z' -> 26
+除了上述的条件以外，现在加密字符串可以包含字符 '*'了，字符'*'可以被当做1到9当中的任意一个数字。
+给定一条包含数字和字符'*'的加密信息，请确定解码方法的总数。
+同时，由于结果值可能会相当的大，所以你应当对109 + 7取模。（翻译者标注：此处取模主要是为了防止溢出）
+示例 1 :
+输入: "*"
+输出: 9
+解释: 加密的信息可以被解密为: "A", "B", "C", "D", "E", "F", "G", "H", "I".
+示例 2 :
+输入: "1*"
+输出: 9 + 9 = 18（翻译者标注：这里1*可以分解为1,* 或者当做1*来处理，所以结果是9+9=18）
+Leetcode题目 : https://leetcode.com/problems/decode-ways-ii/
+
+给定一个二叉树，判断其是否是一个有效的二叉搜索树。
+Leetcode题目 : https://leetcode.com/problems/validate-binary-search-tree/
+
+给定一个二叉树，检查它是否是镜像对称的。
+Leetcode题目 : https://leetcode.com/problems/symmetric-tree/
+
+给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+Leetcode题目 : https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
+
+给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
+高度平衡二叉树是一棵满足每个节点的左右两个子树的高度差的绝对值不超过1的二叉树
+Leetcode题目 : https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
+
+给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
+初始状态下，所有 next 指针都被设置为 NULL。
+进阶：
+这棵树如果是普通二叉树，该怎么做。
+你只能使用常量级额外空间。
+Leetcode题目 : https://leetcode.com/problems/populating-next-right-pointers-in-each-node/
+
+给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
+在「杨辉三角」中，每个数是它左上方和右上方的数的和。
+Leetcode题目 : https://leetcode.com/problems/pascals-triangle/
+
+给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
+在「杨辉三角」中，每个数是它左上方和右上方的数的和。
+你可以优化你的算法到 O(1) 空间复杂度吗？
+Leetcode题目 : https://leetcode.com/problems/pascals-triangle-ii/
+
+路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
+路径和 是路径中各节点值的总和。
+给你一个二叉树的根节点 root ，返回其 最大路径和。
+进阶：
+如果返回最大路径和上的所有节点，该怎么做？
+Leetcode题目 : https://leetcode.com/problems/binary-tree-maximum-path-sum/
+
+
+
+31 大厂高频算法和数据结构面试题31
+
+题目：
+
+给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
+说明：本题中，我们将空字符串定义为有效的回文串。
+示例 1:
+输入: "A man, a plan, a canal: Panama"
+输出: true
+解释："amanaplanacanalpanama" 是回文串
+示例 2:
+输入: "race a car"
+输出: false
+解释："raceacar" 不是回文串
+Leetcode题目 : https://leetcode.com/problems/valid-palindrome/
+
+字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：
+序列中第一个单词是 beginWord
+序列中最后一个单词是 endWord
+每次转换只能改变一个字母。
+转换过程中的中间单词必须是字典 wordList 中的单词
+给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0。
+Leetcode题目 : https://leetcode.com/problems/word-ladder/
+
+给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。
+Leetcode题目 : https://leetcode.com/problems/surrounded-regions/
+
+给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
+说明：拆分时可以重复使用字典中的单词。你可以假设字典中没有重复的单词。
+Leetcode题目 : https://leetcode.com/problems/word-break/
+Lintcode题目 : https://www.lintcode.com/problem/107/
+
+给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。
+说明：分隔时可以重复使用字典中的单词。你可以假设字典中没有重复的单词。
+示例 1：
+输入:
+s = "catsanddog"
+wordDict = ["cat", "cats", "and", "sand", "dog"]
+输出:
+[
+  "cats and dog",
+  "cat sand dog"
+]
+示例 2：
+输入:
+s = "pineapplepenapple"
+wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
+输出:
+[
+  "pine apple pen apple",
+  "pineapple pen apple",
+  "pine applepen apple"
+]
+解释: 注意你可以重复使用字典中的单词。
+示例 3：
+输入:
+s = "catsandog"
+wordDict = ["cats", "dog", "sand", "and", "cat"]
+输出:
+[]
+Leetcode题目 : https://leetcode.com/problems/word-break-ii/
+
+给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表头节点。
+进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
+Leetcode题目 : https://leetcode.com/problems/sort-list/
+
+根据 逆波兰表示法，求表达式的值。
+有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
+说明：整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
+示例 1：
+输入：tokens = ["2","1","+","3","*"]
+输出：9
+解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
+示例 2：
+输入：tokens = ["4","13","5","/","+"]
+输出：6
+解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
+示例 3：
+输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+输出：22
+解释：
+该算式转化为常见的中缀算术表达式为：
+  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+= ((10 * (6 / (12 * -11))) + 17) + 5
+= ((10 * (6 / -132)) + 17) + 5
+= ((10 * 0) + 17) + 5
+= (0 + 17) + 5
+= 17 + 5
+= 22
+Leetcode题目 : https://leetcode.com/problems/evaluate-reverse-polish-notation/
+
+
+
+32 大厂高频算法和数据结构面试题32
+
+题目：
+
+给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
+Leetcode题目 : https://leetcode.com/problems/maximum-product-subarray/
+
+给定一个有序无重复的数组nums， 和两个整数lower和upper， 返回[lower,upper]上所有缺失的数字段
+示例1:
+nums = [0,1,3,50,75], lower = 0, upper = 99
+输出:["2","4->49","51->74","76->99"]
+示例2:
+nums = [], lower = 1, upper = 1
+输出: ["1"]
+示例3:
+nums = [], lower = -3, upper = -1
+输出： ["-3->-1"]
+示例4:
+nums = [-1], lower = -1, upper = -1
+输出: []
+示例5: 
+nums = [-1], lower = -2, upper = -1
+输出: ["-2"]
+Leetcode题目 : https://leetcode.com/problems/missing-ranges/
+
+给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以 字符串形式返回小数 。
+如果小数部分为循环小数，则将循环的部分括在括号内。
+如果存在多个答案，只需返回 任意一个 。
+对于所有给定的输入，保证 答案字符串的长度小于 104 。
+示例 1：
+输入：numerator = 1, denominator = 2
+输出："0.5"
+示例 2：
+输入：numerator = 2, denominator = 1
+输出："2"
+示例 3：
+输入：numerator = 2, denominator = 3
+输出："0.(6)"
+示例 4：
+输入：numerator = 4, denominator = 333
+输出："0.(012)"
+示例 5：
+输入：numerator = 1, denominator = 5
+输出："0.2"
+Leetcode题目 : https://leetcode.com/problems/fraction-to-recurring-decimal/
+
+给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回该列名称对应的列序号。
+例如，
+
+    A -> 1
+    B -> 2
+    C -> 3
+    ...
+    Z -> 26
+    AA -> 27
+    AB -> 28 
+    ...
+示例 1:
+输入: columnTitle = "A"
+输出: 1
+示例 2:
+输入: columnTitle = "AB"
+输出: 28
+示例 3:
+输入: columnTitle = "ZY"
+输出: 701
+示例 4:
+输入: columnTitle = "FXSHRXW"
+输出: 2147483647
+Leetcode题目 : https://leetcode.com/problems/excel-sheet-column-number/
+
+给定一个整数 n，返回 n! 结果尾数中零的数量。
+示例 1:
+输入: 3
+输出: 0
+解释: 3! = 6, 尾数中没有零。
+示例 2:
+输入: 5
+输出: 1
+解释: 5! = 120, 尾数中有 1 个零.
+说明: 你算法的时间复杂度应为 O(log n) 。
+Leetcode题目 : https://leetcode.com/problems/factorial-trailing-zeroes/
+
+给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
+进阶：
+尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
+你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？
+示例 1:
+输入: nums = [1,2,3,4,5,6,7], k = 3
+输出: [5,6,7,1,2,3,4]
+解释:
+向右旋转 1 步: [7,1,2,3,4,5,6]
+向右旋转 2 步: [6,7,1,2,3,4,5]
+向右旋转 3 步: [5,6,7,1,2,3,4]
+示例 2:
+输入：nums = [-1,-100,3,99], k = 2
+输出：[3,99,-1,-100]
+解释: 
+向右旋转 1 步: [99,-1,-100,3]
+向右旋转 2 步: [3,99,-1,-100]
+Leetcode题目 : https://leetcode.com/problems/rotate-array/
+
+颠倒给定的 32 位无符号整数的二进制位。
+进阶:
+如果多次调用这个函数，你将如何优化你的算法？
+示例 1：
+输入：n = 00000010100101000001111010011100
+输出：964176192 (00111001011110000010100101000000)
+解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
+     因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
+示例 2：
+输入：n = 11111111111111111111111111111101
+输出：3221225471 (10111111111111111111111111111111)
+解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
+     因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。
+Leetcode题目 : https://leetcode.com/problems/reverse-bits/
+
+编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。
+示例 1：
+输入：00000000000000000000000000001011
+输出：3
+解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
+示例 2：
+输入：00000000000000000000000010000000
+输出：1
+解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
+示例 3：
+输入：11111111111111111111111111111101
+输出：31
+解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
+提示：
+输入必须是长度为 32 的 二进制串 。
+进阶：
+如果多次调用这个函数，你将如何优化你的算法？
+Leetcode题目 : https://leetcode.com/problems/number-of-1-bits/
+
+编写一个算法来判断一个数 n 是不是快乐数。
+「快乐数」定义为：
+对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
+然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
+如果 可以变为  1，那么这个数就是快乐数。
+如果 n 是快乐数就返回 true ；不是，则返回 false 。
+示例 1：
+输入：19
+输出：true
+解释：
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
+示例 2：
+输入：n = 2
+输出：false
+提示：
+1 <= n <= 2^31 - 1
+Leetcode题目 : https://leetcode.com/problems/happy-number
+
+统计所有小于非负整数 n 的质数的数量。
+示例 1：
+输入：n = 10
+输出：4
+解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
+示例 2：
+输入：n = 0
+输出：0
+示例 3：
+输入：n = 1
+输出：0
+提示：
+0 <= n <= 5 * 10^6
+Leetcode题目 : https://leetcode.com/problems/count-primes/
+
+拼多多笔试题 : 给定一个数组arr，arr[i] = j，表示第i号试题的难度为j。给定一个非负数M
+想出一张卷子，对于任何相邻的两道题目，前一题的难度不能超过后一题的难度+M
+返回所有可能的卷子种数
+
+
+
+33 大厂高频算法和数据结构面试题33
+
+题目：
+
+你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
+在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程  bi 。
+例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
+请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
+示例 1：
+输入：numCourses = 2, prerequisites = [[1,0]]
+输出：true
+解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
+示例 2：
+输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
+输出：false
+解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。
+Leetcode题目 : https://leetcode.com/problems/course-schedule/
+
+现在你总共有 n 门课需要选，记为 0 到 n-1。
+在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
+给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
+可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
+示例 1:
+输入: 2, [[1,0]] 
+输出: [0,1]
+解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
+示例 2:
+输入: 4, [[1,0],[2,0],[3,1],[3,2]]
+输出: [0,1,2,3] or [0,2,1,3]
+解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
+     因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
+Leetcode题目 : https://leetcode.com/problems/course-schedule-ii/
+
+你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。
+这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。
+同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
+给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
+示例 1：
+输入：nums = [2,3,2]
+输出：3
+解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
+示例 2：
+输入：nums = [1,2,3,1]
+输出：4
+解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
+     偷窃到的最高金额 = 1 + 3 = 4 。
+示例 3：
+输入：nums = [0]
+输出：0
+Leetcode题目 : https://leetcode.com/problems/house-robber-ii/
+
+请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
+Leetcode题目 : https://leetcode.com/problems/delete-node-in-a-linked-list/
+
+给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
+示例:
+输入: [1,2,3,4]
+输出: [24,12,8,6]
+说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
+进阶：
+你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）
+Leetcode题目 : https://leetcode.com/problems/product-of-array-except-self/
+
+给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
+注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
+示例 1:
+输入: s = "anagram", t = "nagaram"
+输出: true
+示例 2:
+输入: s = "rat", t = "car"
+输出: false
+Leetcode题目 : https://leetcode.com/problems/valid-anagram/
+
+给定一个二维数组，实现二维数组的迭代器，包含hasNext()和next()两个迭代器常见方法。
+Leetcode题目 : https://leetcode.com/problems/flatten-2d-vector/
+
+出版社印发了一个名单，名单上的每一行都是一个字符串，字符串都是小写字母，但是字符串出现的先后顺序和日常的字典序不一样
+现在怀疑出版社内部对于字符有自己的字典序规则，请根据字符串之间出现的顺序，返回可能存在的、出版社内部的字符顺序
+如果从名单来看不存在这样的字符顺序，返回空字符串
+Leetcode题目 : https://leetcode.com/problems/alien-dictionary/
+
+给定一个数n，所有人的编号从0到n-1
+给定一个函数 boolean know(int i, int j)，该函数表示i这个人认不认识j这个人，认识关系是单向的
+有了这个函数，你可以检查认识这件事情。
+规定何为明星？1）所有人都认识这个人。2）这个人不认识自己之外的所有人。那么这个人就是明星
+利用know函数，找到明星，返回明星的编号，如果没有明星返回-1。
+Leetcode题目 : https://leetcode.com/problems/find-the-celebrity/
+
+给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
+给你一个整数 n ，返回和为 n 的完全平方数的 最少数量 。
+完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
+示例 1：
+输入：n = 12
+输出：3 
+解释：12 = 4 + 4 + 4
+示例 2：
+输入：n = 13
+输出：2
+解释：13 = 4 + 9
+Leetcode题目 : https://leetcode.com/problems/perfect-squares/
+
+给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
+示例:
+输入: [0,1,0,3,12]
+输出: [1,3,12,0,0]
+说明:
+必须在原数组上操作，不能拷贝额外的数组。
+尽量减少操作次数。
+Leetcode题目 : https://leetcode.com/problems/move-zeroes/
+
+
+
+34 大厂高频算法和数据结构面试题34
+
+题目：
+
+给定一个包含 n + 1 个整数的数组 nums ，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。
+假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。
+你设计的解决方案必须不修改数组 nums 且只用常量级 O(1) 的额外空间。
+Leetcode题目 : https://leetcode.com/problems/find-the-duplicate-number/
+
+生命游戏，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。
+给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。
+每个细胞都具有一个初始状态：1 即为活细胞（live），或 0 即为死细胞（dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：
+如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
+如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
+如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
+如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
+下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。
+Leetcode题目 : https://leetcode.com/problems/game-of-life/
+
+中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。
+例如，
+[2,3,4] 的中位数是 3
+[2,3] 的中位数是 (2 + 3) / 2 = 2.5
+设计一个支持以下两种操作的数据结构：
+void addNum(int num) - 从数据流中添加一个整数到数据结构中。
+double findMedian() - 返回目前所有元素的中位数。
+Leetcode题目 : https://leetcode.com/problems/find-median-from-data-stream/
+
+给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。
+示例：
+输入：nums = [5,2,6,1]
+输出：[2,1,1,0] 
+解释：
+5 的右侧有 2 个更小的元素 (2 和 1)
+2 的右侧仅有 1 个更小的元素 (1)
+6 的右侧有 1 个更小的元素 (1)
+1 的右侧有 0 个更小的元素
+Leetcode题目 : https://leetcode.com/problems/count-of-smaller-numbers-after-self/
+
+给你一个整数数组 nums，将它重新排列成 nums[0] < nums[1] > nums[2] < nums[3]... 的顺序。
+你可以假设所有输入数组都可以得到满足题目要求的结果。
+示例 1：
+输入：nums = [1,5,1,1,6,4]
+输出：[1,6,1,5,1,4]
+解释：[1,4,1,5,1,6] 同样是符合题目要求的结果，可以被判题程序接受。
+示例 2：
+输入：nums = [1,3,2,2,3,1]
+输出：[2,3,1,3,1,2]
+进阶：你能用 O(n) 时间复杂度和原地 O(1) 额外空间来实现吗？
+Leetcode题目 : https://leetcode.com/problems/wiggle-sort-ii/
+
+给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。
+Leetcode题目 : https://leetcode.com/problems/power-of-three/
+
+给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
+请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。
+示例 1:
+输入: 1->2->3->4->5->NULL
+输出: 1->3->5->2->4->NULL
+示例 2:
+输入: 2->1->3->5->6->4->7->NULL 
+输出: 2->3->6->7->1->5->4->NULL
+说明:
+应当保持奇数节点和偶数节点的相对顺序。
+链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
+Leetcode题目 : https://leetcode.com/problems/odd-even-linked-list/
+
+给定一个字符串str，和一个正数k，返回字符种类不超过k种的最长子串长度。
+Leetcode题目 : https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/
+
+给你一个嵌套的整数列表 nestedList 。每个元素要么是一个整数，要么是一个列表；
+该列表的元素也可能是整数或者是其他列表。请你实现一个迭代器将其扁平化，使之能够遍历这个列表中的所有整数。
+实现扁平迭代器类 NestedIterator ：
+NestedIterator(List<NestedInteger> nestedList) 用嵌套列表 nestedList 初始化迭代器。
+int next() 返回嵌套列表的下一个整数。
+boolean hasNext() 如果仍然存在待迭代的整数，返回 true ；否则，返回 false 。
+你的代码将会用下述伪代码检测：
+initialize iterator with nestedList
+res = []
+while iterator.hasNext()
+    append iterator.next() to the end of res
+return res
+如果 res 与预期的扁平化列表匹配，那么你的代码将会被判为正确。
+示例 1：
+输入：nestedList = [[1,1],2,[1,1]]
+输出：[1,1,2,1,1]
+解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。
+示例 2：
+输入：nestedList = [1,[4,[6]]]
+输出：[1,4,6]
+解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。
+Leetcode题目 : https://leetcode.com/problems/flatten-nested-list-iterator/
+
+tic-tac-toe游戏，不知道的同学可以自行搜索。请实现以下类TicTacToe。
+构造方法：TicTacToe(int n) : TicTacToe游戏的类，n表示目前在n*n的棋盘上玩游戏。
+内部方法：int move(int i, int j, int p) : p只可能是1和2，表示玩家1还是玩家2。当前玩家在i行j列上走了一步。返回值只可能是0、1、2，0表示没有玩家赢；1表示玩家1赢了；2表示玩家2赢了。
+Leetcode题目 : https://leetcode.com/problems/design-tic-tac-toe/
+
+设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构。
+insert(val)：当元素 val 不存在时，向集合中插入该项。
+remove(val)：元素 val 存在时，从集合中移除该项。
+getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。
+Leetcode题目 : https://leetcode.com/problems/insert-delete-getrandom-o1/
+
+给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。
+实现 Solution class:
+Solution(int[] nums) 使用整数数组 nums 初始化对象
+int[] reset() 重设数组到它的初始状态并返回
+int[] shuffle() 返回数组随机打乱后的结果
+Leetcode题目 : https://leetcode.com/problems/shuffle-an-array/
+
+
+
+35 大厂高频算法和数据结构面试题35
+
+给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
+示例 1:
+输入: nums = [1,1,1,2,2,3], k = 2
+输出: [1,2]
+示例 2:
+输入: nums = [1], k = 1
+输出: [1]
+提示：
+1 <= nums.length <= 10^5
+k 的取值范围是 [1, 数组中不相同的元素的个数]
+题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的
+进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
+Leetcode题目 : https://leetcode.com/problems/top-k-frequent-elements/
+
+给你一个字符串 s 和一个整数 k ，请你找出 s 中的最长子串， 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。
+示例 1：
+输入：s = "aaabb", k = 3
+输出：3
+解释：最长子串为 "aaa" ，其中 'a' 重复了 3 次。
+示例 2：
+输入：s = "ababbc", k = 2
+输出：5
+解释：最长子串为 "ababb" ，其中 'a' 重复了 2 次， 'b' 重复了 3 次。
+提示：
+1 <= s.length <= 10^4
+s 仅由小写英文字母组成
+Leetcode题目 : https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/
+
+写一个程序，输出从 1 到 n 数字的字符串表示。
+1. 如果 n 是3的倍数，输出“Fizz”；
+2. 如果 n 是5的倍数，输出“Buzz”；
+3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。
+示例：
+n = 15,
+返回:
+[
+    "1",
+    "2",
+    "Fizz",
+    "4",
+    "Buzz",
+    "Fizz",
+    "7",
+    "8",
+    "Fizz",
+    "Buzz",
+    "11",
+    "Fizz",
+    "13",
+    "14",
+    "FizzBuzz"
+]
+Leetcode题目 : https://leetcode.com/problems/fizz-buzz/
+
+给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
+为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。
+例如:
+输入:
+A = [ 1, 2]
+B = [-2,-1]
+C = [-1, 2]
+D = [ 0, 2]
+输出:
+2
+解释:
+两个元组如下:
+1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
+2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
+Leetcode题目 : https://leetcode.com/problems/4sum-ii/
+
+给定一个未排序的整数数组，找到最长递增子序列的个数。
+示例 1:
+输入: [1,3,5,4,7]
+输出: 2
+解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
+示例 2:
+输入: [2,2,2,2,2]
+输出: 5
+解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。
+注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。
+Leetcode题目 : https://leetcode.com/problems/number-of-longest-increasing-subsequence/
+
+给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。
+注意：两个节点之间的路径长度由它们之间的边数表示。
+注意: 给定的二叉树不超过10000个结点。 树的高度不超过1000。
+Leetcode题目 : https://leetcode.com/problems/longest-univalue-path/
+
+来自真实笔试
+给定一个长度len，表示一共有几位
+所有字符都是小写(a~z)，可以生成长度为1，长度为2，
+长度为3...长度为len的所有字符串
+如果把所有字符串根据字典序排序，每个字符串都有所在的位置。
+给定一个字符串str，给定len，请返回str是总序列中的第几个
+比如len = 4，字典序的前几个字符串为:
+a aa aaa aaaa aaab ... aaaz ... azzz b ba baa baaa ... bzzz c ...
+a是这个序列中的第1个，bzzz是这个序列中的第36558个
+
+来自小红书
+[0,4,7] ： 0表示这里石头没有颜色，如果变红代价是4，如果变蓝代价是7
+[1,X,X] ： 1表示这里石头已经是红，而且不能改颜色，所以后两个数X无意义
+[2,X,X] ： 2表示这里石头已经是蓝，而且不能改颜色，所以后两个数X无意义
+颜色只可能是0、1、2，代价一定>=0
+给你一批这样的小数组，要求最后必须所有石头都有颜色，且红色和蓝色一样多，返回最小代价
+如果怎么都无法做到所有石头都有颜色、且红色和蓝色一样多，返回-1
+
+来自小红书
+一场电影开始和结束时间可以用一个小数组来表示["07:30","12:00"]
+已知有2000场电影开始和结束都在同一天，这一天从00:00开始到23:59结束
+一定要选3场完全不冲突的电影来观看，返回最大的观影时间
+如果无法选出3场完全不冲突的电影来观看，返回-1
+
+来自网易
+map[i][j] == 0，代表(i,j)是海洋，渡过的话代价是2
+map[i][j] == 1，代表(i,j)是陆地，渡过的话代价是1
+map[i][j] == 2，代表(i,j)是障碍，无法渡过
+每一步上、下、左、右都能走，返回从左上角走到右下角最小代价是多少，如果无法到达返回-1
+
+来自网易
+给定一个正数数组arr，表示每个小朋友的得分
+任何两个相邻的小朋友，如果得分一样，怎么分糖果无所谓，但如果得分不一样，分数大的一定要比分数少的多拿一些糖果
+假设所有的小朋友坐成一个环形，返回在不破坏上一条规则的情况下，需要的最少糖果数
+
+
+
+36 大厂高频算法和数据结构面试题36
+
+来自网易
+规定：L[1]对应a，L[2]对应b，L[3]对应c，...，L[25]对应y
+S1 = a
+S(i) = S(i-1) + L[i] + reverse(invert(S(i-1)));
+解释invert操作：
+S1 = a
+S2 = aby
+假设invert(S(2)) = 甲乙丙
+a + 甲 = 26, 那么 甲 = 26 - 1 = 25 -> y
+b + 乙 = 26, 那么 乙 = 26 - 2 = 24 -> x
+y + 丙 = 26, 那么 丙 = 26 - 25 = 1 -> a
+如上就是每一位的计算方式，所以invert(S2) = yxa
+所以S3 = S2 + L[3] + reverse(invert(S2)) = aby + c + axy = abycaxy
+invert(abycaxy) = yxawyba, 再reverse = abywaxy
+所以S4 = abycaxy + d + abywaxy = abycaxydabywaxy
+直到S25结束
+给定两个参数n和k，返回Sn的第k位是什么字符，n从1开始，k从1开始
+比如n=4，k=2，表示S4的第2个字符是什么，返回b字符
+ 
+来自京东
+把一个01字符串切成多个部分，要求每一部分的0和1比例一样，同时要求尽可能多的划分
+比如 : 01010101
+01 01 01 01 这是一种切法，0和1比例为 1 : 1
+0101 0101 也是一种切法，0和1比例为 1 : 1
+两种切法都符合要求，但是那么尽可能多的划分为第一种切法，部分数为4
+比如 : 00001111
+只有一种切法就是00001111整体作为一块，那么尽可能多的划分，部分数为1
+给定一个01字符串str，假设长度为N，要求返回一个长度为N的数组ans
+其中ans[i] = str[0...i]这个前缀串，要求每一部分的0和1比例一样，同时要求尽可能多的划分下，部分数是多少
+输入: str = "010100001"
+输出: ans = [1, 1, 1, 2, 1, 2, 1, 1, 3]
+ 
+来自美团
+给定两个字符串s1和s2
+返回在s1中有多少个子串等于s2
+ 
+来自美团
+() 分值为2
+(()) 分值为3
+((())) 分值为4
+也就是说，每包裹一层，分数就是里面的分值+1
+()() 分值为2 * 2
+(())() 分值为3 * 2
+也就是说，每连接一段，分数就是各部分相乘，以下是一个结合起来的例子
+(()())()(()) -> (2 * 2 + 1) * 2 * 3 -> 30
+给定一个括号字符串str，已知str一定是正确的括号结合，不会有违规嵌套
+返回分数
+ 
+来自美团
+给定一个数组arr，长度为N，做出一个结构，可以高效的做如下的查询
+1) int querySum(L,R) : 查询arr[L...R]上的累加和
+2) int queryAim(L,R) : 查询arr[L...R]上的目标值，目标值定义如下：
+       假设arr[L...R]上的值为[a,b,c,d]，a+b+c+d = s
+       目标值为 : (s-a)^2 + (s-b)^2 + (s-c)^2 + (s-d)^2
+3) int queryMax(L,R) : 查询arr[L...R]上的最大值
+要求：
+1) 初始化该结构的时间复杂度不能超过O(N*logN)
+2) 三个查询的时间复杂度不能超过O(logN)
+3) 查询时，认为arr的下标从1开始，比如 : 
+   arr = [ 1, 1, 2, 3 ];
+   querySum(1, 3) -> 4
+   queryAim(2, 4) -> 50
+   queryMax(1, 4) -> 3
+
+来自美团
+有一棵树，给定头节点h，和结构数组m，下标0弃而不用
+比如h = 1, m = [ [] , [2,3], [4], [5,6], [], [], []]
+表示1的孩子是2、3; 2的孩子是4; 3的孩子是5、6; 4、5和6是叶节点，都不再有孩子
+每一个节点都有颜色，记录在c数组里，比如c[i] = 4, 表示节点i的颜色为4
+一开始只有叶节点是有权值的，记录在w数组里，
+比如，如果一开始就有w[i] = 3, 表示节点i是叶节点、且权值是3
+现在规定非叶节点i的权值计算方式：
+根据i的所有直接孩子来计算，假设i的所有直接孩子，颜色只有a,b,k
+w[i] = Max {
+             (颜色为a的所有孩子个数 + 颜色为a的孩子权值之和), 
+             (颜色为b的所有孩子个数 + 颜色为b的孩子权值之和),
+             (颜色为k的所有孩子个数 + 颜色k的孩子权值之和)
+           }
+请计算所有孩子的权值并返回
+
+来自腾讯
+给定一个数组arr，当拿走某个数a的时候，其他所有的数都+a
+请返回最终所有数都拿走的最大分数
+比如: [2,3,1]
+当拿走3时，获得3分，数组变成[5,4]
+当拿走5时，获得5分，数组变成[9]
+当拿走9时，获得9分，数组变成[]
+这是最大的拿取方式，返回总分17
+ 
+来自腾讯
+给定一个正数数组arr，代表每个人的体重。给定一个正数limit代表船的载重，所有船都是同样的载重量
+每个人的体重都一定不大于船的载重
+要求：
+1, 可以1个人单独一搜船
+2, 一艘船如果坐2人，两个人的体重相加需要是偶数，且总体重不能超过船的载重
+3, 一艘船最多坐2人
+返回如果想所有人同时坐船，船的最小数量
+ 
+来自腾讯
+给定一个字符串str，和一个正数k
+返回长度为k的所有子序列中，字典序最大的子序列
+ 
+来自哈喽单车(Leetcode原题)
+Alice 和 Bob 两个人轮流玩一个游戏，Alice 先手。
+一开始，有 n 个石子堆在一起。每个人轮流操作，正在操作的玩家可以从石子堆里拿走 任意 非零 平方数 个石子。
+如果石子堆里没有石子了，则无法操作的玩家输掉游戏。
+给你正整数 n ，且已知两个人都采取最优策略。如果 Alice 会赢得比赛，那么返回 True ，否则返回 False 。
+leetcode原题 : https://leetcode.com/problems/stone-game-iv/
+
+来自三七互娱(Leetcode原题)
+给你一个数组 routes ，表示一系列公交线路，其中每个 routes[i] 表示一条公交线路，第 i 辆公交车将会在上面循环行驶。
+例如，路线 routes[0] = [1, 5, 7] 表示第 0 辆公交车会一直按序列 1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ... 这样的车站路线行驶。
+现在从 source 车站出发（初始时不在公交车上），要前往 target 车站。 期间仅可乘坐公交车。
+求出 最少乘坐的公交车数量 。如果不可能到达终点车站，返回 -1 。
+Leetcode原题 : https://leetcode.com/problems/bus-routes/
+
+
+
+37 大厂高频算法和数据结构面试题37
+
+给你二叉树的根结点 root ，请你将它展开为一个单链表：
+展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
+展开后的单链表应该与二叉树 先序遍历 顺序相同。
+Leetcode题目 : https://leetcode.com/problems/flatten-binary-tree-to-linked-list/
+
+在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。
+Leetcode题目 : https://leetcode.com/problems/maximal-square/
+
+翻转一棵二叉树
+任何节点的左右两个孩子交换
+Leetcode题目 : https://leetcode.com/problems/invert-binary-tree/
+
+给定一个经过编码的字符串，返回它解码后的字符串。
+编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
+你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
+此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。
+Leetcode题目 : https://leetcode.com/problems/decode-string/
+
+假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
+请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。
+输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
+输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
+解释：
+编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
+编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
+编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
+编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
+编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
+编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
+因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。
+Leetcode题目 : https://leetcode.com/problems/queue-reconstruction-by-height/
+
+给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
+路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
+Leetcode题目 : https://leetcode.com/problems/path-sum-iii/
+
+来自网易
+刚入职网易互娱，新人mini项目便如火如荼的开展起来。为了更好的项目协作与管理，
+小易决定将学到的甘特图知识用于mini项目时间预估。小易先把项目中每一项工作以任务的形式列举出来，
+每项任务有一个预计花费时间与前置任务表，必须完成了该任务的前置任务才能着手去做该任务。
+作为经验PM，小易把任务划分得井井有条，保证没有前置任务或者前置任务全数完成的任务，都可以同时进行。
+小易给出了这样一个任务表，请作为程序的你计算需要至少多长时间才能完成所有任务。
+输入第一行为一个正整数T，表示数据组数。
+对于接下来每组数据，第一行为一个正整数N，表示一共有N项任务。
+接下来N行，每行先有两个整数Di和Ki，表示完成第i个任务的预计花费时间为Di天，该任务有Ki个前置任务。
+之后为Ki个整数Mj，表示第Mj个任务是第i个任务的前置任务。
+数据范围：对于所有数据，满足1<=T<=3, 1<=N, Mj<=100000, 0<=Di<=1000, 0<=sum(Ki)<=N*2。
+
+来自字节
+扑克牌中的红桃J和梅花Q找不到了，为了利用剩下的牌做游戏，小明设计了新的游戏规则
+1) A,2,3,4....10,J,Q,K分别对应1到13这些数字，大小王对应0
+2) 游戏人数为2人，轮流从牌堆里摸牌，每次摸到的牌只有“保留”和“使用”两个选项，且当前轮必须做出选择
+3) 如果选择“保留”当前牌，那么当前牌的分数加到总分里，并且可以一直持续到游戏结束
+4) 如果选择“使用”当前牌，那么当前牌的分数*3，加到总分上去，但是只有当前轮，下一轮，下下轮生效，之后轮效果消失。
+5) 每一轮总分大的人获胜
+假设小明知道每一轮对手做出选择之后的总分，返回小明在每一轮都赢的情况下，最终的最大分是多少
+如果小明怎么都无法保证每一轮都赢，返回-1
+
+
+
+38 大厂高频算法和数据结构面试题38
+
+给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
+异位词 指字母相同，但排列不同的字符串。
+示例 1:
+输入: s = "cbaebabacd", p = "abc"
+输出: [0,6]
+解释:
+起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
+起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
+示例 2:
+输入: s = "abab", p = "ab"
+输出: [0,1,2]
+解释:
+起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
+起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
+起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
+提示:
+1 <= s.length, p.length <= 3 * 10^4
+s 和 p 仅包含小写字母
+Leetcode题目 : https://leetcode.com/problems/find-all-anagrams-in-a-string/
+
+给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
+示例 1：
+输入：nums = [4,3,2,7,8,2,3,1]
+输出：[5,6]
+示例 2：
+输入：nums = [1,1]
+输出：[2]
+提示：
+n == nums.length
+1 <= n <= 10^5
+1 <= nums[i] <= n
+进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗? 你可以假定返回的数组不算在额外空间内。
+Leetcode题目 : https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/
+
+给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
+你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
+Leetcode题目 : https://leetcode.com/problems/merge-two-binary-trees/
+
+给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。
+在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。
+然而，两个 相同种类 的任务之间必须有长度为整数 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。
+你需要计算完成所有任务所需要的 最短时间 。
+示例 1：
+输入：tasks = ["A","A","A","B","B","B"], n = 2
+输出：8
+解释：A -> B -> (待命) -> A -> B -> (待命) -> A -> B
+在本示例中，两个相同类型任务之间必须间隔长度为 n = 2 的冷却时间，而执行一个任务只需要一个单位时间，所以中间出现了（待命）状态。 
+示例 2：
+输入：tasks = ["A","A","A","B","B","B"], n = 0
+输出：6
+解释：在这种情况下，任何大小为 6 的排列都可以满足要求，因为 n = 0
+["A","A","A","B","B","B"]
+["A","B","A","B","A","B"]
+["B","B","B","A","A","A"]
+...
+诸如此类
+示例 3：
+输入：tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
+输出：16
+解释：一种可能的解决方案是：
+A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A
+Leetcode题目 : https://leetcode.com/problems/task-scheduler/
+
+给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
+回文字符串 是正着读和倒过来读一样的字符串。
+子字符串 是字符串中的由连续字符组成的一个序列。
+具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
+示例 1：
+输入：s = "abc"
+输出：3
+解释：三个回文子串: "a", "b", "c"
+示例 2：
+输入：s = "aaa"
+输出：6
+解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"
+提示：
+1 <= s.length <= 1000
+s 由小写英文字母组成
+Leetcode题目 : https://leetcode.com/problems/palindromic-substrings/
+
+请根据每日 气温 列表 temperatures ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。
+示例 1:
+输入: temperatures = [73,74,75,71,69,72,76,73]
+输出: [1,1,4,2,1,1,0,0]
+示例 2:
+输入: temperatures = [30,40,50,60]
+输出: [1,1,1,0]
+示例 3:
+输入: temperatures = [30,60,90]
+输出: [1,1,0]
+提示：
+1 <= temperatures.length <= 10^5
+30 <= temperatures[i] <= 100
+Leetcode题目 : https://leetcode.com/problems/daily-temperatures/
+
+字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
+示例：
+输入：S = "ababcbacadefegdehijhklij"
+输出：[9,7,8]
+解释：
+划分结果为 "ababcbaca", "defegde", "hijhklij"。
+每个字母最多出现在一个片段中。
+像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
+提示：
+S的长度在[1, 500]之间。
+S只包含小写字母 'a' 到 'z' 。
+Leetcode题目 : https://leetcode.com/problems/partition-labels/
+
+来自字节
+给定两个数a和b
+第1轮，把1选择给a或者b
+第2轮，把2选择给a或者b
+...
+第i轮，把i选择给a或者b
+想让a和b的值一样大，请问至少需要多少轮？
+
+360笔试题
+长城守卫军
+题目描述：
+长城上有连成一排的n个烽火台，每个烽火台都有士兵驻守。
+第i个烽火台驻守着ai个士兵，相邻峰火台的距离为1。另外，有m位将军，
+每位将军可以驻守一个峰火台，每个烽火台可以有多个将军驻守，
+将军可以影响所有距离他驻守的峰火台小于等于x的烽火台。
+每个烽火台的基础战斗力为士兵数，另外，每个能影响此烽火台的将军都能使这个烽火台的战斗力提升k。
+长城的战斗力为所有烽火台的战斗力的最小值。
+请问长城的最大战斗力可以是多少？
+输入描述
+第一行四个正整数n,m,x,k(1<=x<=n<=10^5,0<=m<=10^5,1<=k<=10^5)
+第二行n个整数ai(0<=ai<=10^5)
+输出描述 仅一行，一个整数，表示长城的最大战斗力
+样例输入
+5 2 1 2
+4 4 2 4 4
+样例输出
+6
+
+
+
+39 大厂高频算法和数据结构面试题39
+
+来自腾讯
+给定一个只由0和1组成的字符串S，假设下标从1开始，规定i位置的字符价值V[i]计算方式如下:
+1) i == 1时，V[i] = 1
+2) i > 1时，如果S[i] != S[i-1]，V[i] = 1
+3) i > 1时，如果S[i] == S[i-1]，V[i] = V[i-1] + 1
+你可以随意删除S中的字符，返回整个S的最大价值
+字符串长度<=5000
+
+来自腾讯
+给定一个长度为n的数组arr，求有多少个子数组满足:
+子数组两端的值，是这个子数组的最小值和次小值，最小值和次小值谁在最左和最右无所谓
+n<=100000
+
+来自百度
+给定一个字符串str，和一个正数k
+str子序列的字符种数必须是k种，返回有多少子序列满足这个条件
+已知str中都是小写字母
+
+来自京东
+给定一个二维数组matrix，matrix[i][j] = k代表:
+从(i,j)位置可以随意往右跳<=k步，或者从(i,j)位置可以随意往下跳<=k步
+如果matrix[i][j] = 0，代表来到(i,j)位置必须停止
+返回从matrix左上角到右下角，至少要跳几次
+已知matrix中行数n <= 5000, 列数m <= 5000
+matrix中的值 <= 1000
+
+真实笔试，忘了哪个公司，但是绝对大厂
+一个子序列的消除规则如下:
+1) 在某一个子序列中，如果'1'的左边有'0'，那么这两个字符->"01"可以消除
+2) 在某一个子序列中，如果'3'的左边有'2'，那么这两个字符->"23"可以消除
+3) 当这个子序列的某个部分消除之后，认为其他字符会自动贴在一起，可以继续寻找消除的机会
+比如，某个子序列"0231"，先消除掉"23"，那么剩下的字符贴在一起变成"01"，继续消除就没有字符了
+如果某个子序列通过最优良的方式，可以都消掉，那么这样的子序列叫做“全消子序列”
+一个只由'0'、'1'、'2'、'3'四种字符组成的字符串str，可以生成很多子序列，返回“全消子序列”的最大长度
+字符串str长度 <= 200
+
+
+
+40 大厂高频算法和数据结构面试题40
+
+腾讯
+分裂问题
+一个数n，可以分裂成一个数组[n/2, n%2, n/2]
+这个数组中哪个数不是1或者0，就继续分裂下去
+比如 n = 5，一开始分裂成[2, 1, 2]
+[2, 1, 2]这个数组中不是1或者0的数，会继续分裂下去，比如两个2就继续分裂
+[2, 1, 2] -> [1, 0, 1, 1, 1, 0, 1]
+那么我们说，5最后分裂成[1, 0, 1, 1, 1, 0, 1]
+每一个数都可以这么分裂，在最终分裂的数组中，假设下标从1开始
+给定三个数n、l、r，返回n的最终分裂数组里[l,r]范围上有几个1
+n <= 2 ^ 50，n是long类型
+r - l <= 50000，l和r是int类型
+我们的课加个码:
+n是long类型随意多大都行
+l和r也是long类型随意多大都行，但要保证l<=r
+
+来自去哪儿网
+给定一个arr，里面的数字都是0~9
+你可以随意使用arr中的数字，哪怕打乱顺序也行
+请拼出一个能被3整除的，最大的数字，用str形式返回
+
+给定int[][] meetings，比如
+{
+   {66, 70}   0号会议截止时间66，获得收益70
+   {25, 90}   1号会议截止时间25，获得收益90
+   {50, 30}   2号会议截止时间50，获得收益30
+ }
+一开始的时间是0，任何会议都持续10的时间，但是一个会议一定要在该会议截止时间之前开始
+只有一个会议室，任何会议不能共用会议室，一旦一个会议被正确安排，将获得这个会议的收益
+请返回最大的收益
+
+给定两个数组A和B，长度都是N
+A[i]不可以在A中和其他数交换，只可以选择和B[i]交换(0<=i<n)
+你的目的是让A有序，返回你能不能做到
+
+来自腾讯
+比如arr = {3,1,2,4}
+下标对应是：0 1 2 3
+你最开始选择一个下标进行操作，一旦最开始确定了是哪个下标，以后都只能在这个下标上进行操作
+比如你选定1下标，1下标上面的数字是1，你可以选择变化这个数字，比如你让这个数字变成2
+那么arr = {3,2,2,4}
+下标对应是：0 1 2 3
+因为你最开始确定了1这个下标，所以你以后都只能对这个下标进行操作，
+但是，和你此时下标上的数字一样的、且位置连成一片的数字，会跟着一起变
+比如你选择让此时下标1的数字2变成3，
+那么arr = {3,3,3,4} 可以看到下标1和下标2的数字一起变成3，这是规则！一定会一起变
+下标对应是：0 1 2 3
+接下来，你还是只能对1下标进行操作，那么数字一样的、且位置连成一片的数字(arr[0~2]这个范围)都会一起变
+决定变成4
+那么arr = {4,4,4,4}
+下标对应是：0 1 2 3
+至此，所有数都成一样的了，你在下标1上做了3个决定(第一次变成2，第二次变成3，第三次变成4)，
+因为联动规则，arr全刷成一种数字了
+给定一个数组arr，最开始选择哪个下标，你随意
+你的目的是一定要让arr都成为一种数字，注意联动效果会一直生效
+返回最小的变化数
+arr长度 <= 200, arr中的值 <= 10^6
+
+
+
+41 大厂高频算法和数据结构面试题41
+
+来自小红书
+一个无序数组长度为n，所有数字都不一样，并且值都在[0...n-1]范围上
+返回让这个无序数组变成有序数组的最小交换次数
+
+来自小红书
+有四种诗的韵律分别为: AABB、ABAB、ABBA、AAAA
+比如 : 1 1 3 3就属于AABB型的韵律、6 6 6 6就属于AAAA型的韵律等等
+一个数组arr，当然可以生成很多的子序列，如果某个子序列一直以韵律的方式连接起来，我们称这样的子序列是有效的
+比如, arr = { 1, 1, 15, 1, 34, 1, 2, 67, 3, 3, 2, 4, 15, 3, 17, 4, 3, 7, 52, 7, 81, 9, 9 }
+arr的一个子序列为{1, 1, 1, 1, 2, 3, 3, 2, 4, 3, 4, 3, 7, 7, 9, 9}
+其中1, 1, 1, 1是AAAA、2, 3, 3, 2是ABBA、4, 3, 4, 3是ABAB、7, 7, 9, 9是AABB
+可以看到，整个子序列一直以韵律的方式连接起来，所以这个子序列是有效的
+ 给定一个数组arr, 返回最长的有效子序列长度
+题目限制 : arr长度 <= 4000, arr中的值<= 10^9
+
+来自网易互娱
+N个结点之间，表世界存在双向通行的道路，里世界存在双向通行的传送门.
+若走表世界的道路，花费一分钟.
+若走里世界的传送门，不花费时间，但是接下来一分钟不能走传送门.
+输入： T为测试用例的组数，对于每组数据:
+第一行：N M1 M2 N代表结点的个数1到N
+接下来M1行 每行两个数，u和v，表示表世界u和v之间存在道路
+接下来M2行 每行两个数，u和v，表示里世界u和v之间存在传送门
+现在处于1号结点，最终要到达N号结点，求最小的到达时间 保证所有输入均有效，不存在环等情况
+
+实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
+如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
+必须 原地 修改，只允许使用额外常数空间。
+示例 1：
+输入：nums = [1,2,3]
+输出：[1,3,2]
+示例 2：
+输入：nums = [3,2,1]
+输出：[1,2,3]
+示例 3：
+输入：nums = [1,1,5]
+输出：[1,5,1]
+示例 4：
+输入：nums = [1]
+输出：[1]
+leetcode题目 : https://leetcode.com/problems/next-permutation/
+
+
+
+42 大厂高频算法和数据结构面试题42
+
+给定一个二维数组cost[N][K], 
+N表示有0...N-1这么多房子，所有房子排成一条直线，i号房子和i-1号房子相邻、也和i+1号房子相邻
+K表示有0...K-1这么多颜色，每个房子都必须选择一种颜色
+cost[i][j]表示i号房子涂上j颜色的花费，并且要求相邻的房子不能是一种颜色
+返回所有房子都涂上颜色，最小的总花费
+leetcode题目 : https://leetcode.com/problems/paint-house-ii/
+
+给定一棵搜索二叉树的头节点root，搜索二叉树默认是没有重复值的，给定一个double类型的数target，给定一个正数k
+请返回在这棵二叉树里最接近target的k个值，作为链表返回
+要求：如果二叉树的节点个数为n，而k相比于n较小的话，实现时间复杂度低于O(n)的方法
+leetcode题目 : https://leetcode.com/problems/closest-binary-search-tree-value-ii/
+
+给定一个整数num，返回一个字符串str，是num的英文表达
+leetcode题目 : https://leetcode.com/problems/integer-to-english-words/
+
+二维矩阵中只有0和1，每个1可以上、下、左、右的移动
+想让所有的1汇聚在一个点上开会，请返回所有1移动的最小距离和
+leetcode题目 : https://leetcode.com/problems/best-meeting-point/
+
+给定一个含有 n 个正数的数组 x。从点 (0,0) 开始，先向北移动 x[0] 米，然后向西移动 x[1] 米，向南移动 x[2] 米，向东移动 x[3] 米，持续移动
+也就是说，每次移动后你的方位会发生逆时针变化
+编写一个 O(1) 空间复杂度的一趟扫描算法，判断你所经过的路径是否相交。
+leetcode题目 : https://leetcode.com/problems/self-crossing/
+
+
+
+43 大厂高频算法和数据结构面试题43
+
+来自微软面试
+给定一个正数数组arr长度为n、正数x、正数y
+你的目标是让arr整体的累加和<=0
+你可以对数组中的数num执行以下三种操作中的一种，且每个数最多能执行一次操作 : 
+1）不变
+2）可以选择让num变成0，承担x的代价
+3）可以选择让num变成-num，承担y的代价
+返回你达到目标的最小代价
+数据规模 : 面试时面试官没有说数据规模
+
+来自360笔试
+给定一个正数数组arr，长度为n，下标0~n-1
+arr中的0、n-1位置不需要达标，它们分别是最左、最右的位置
+中间位置i需要达标，达标的条件是 : arr[i-1] > arr[i] 或者 arr[i+1] > arr[i]哪个都可以
+你每一步可以进行如下操作：对任何位置的数让其-1
+你的目的是让arr[1~n-2]都达标，这时arr称之为yeah！数组
+返回至少要多少步可以让arr变成yeah！数组
+数据规模 : 数组长度 <= 10000，数组中的值<=500
+
+
+
+44 大厂高频算法和数据结构面试题44
+
+给定两个字符串low和high，它们只由数字字符组成，代表两个数字并且low<=high，返回在[low, high]范围上旋转有效串的数量
+旋转有效串：一个字符串以中心点为支点，旋转180度之后依然是原来字符串，叫做旋转有效串，比如：
+181旋转之后还是181，是旋转有效串
+8008旋转之后还是8008，是旋转有效串
+689旋转之后还是689，是旋转有效串
+而6816就不是旋转有效串，因为旋转之后是9189
+leetcode题目 : https://leetcode.com/problems/strobogrammatic-number-iii/
+
+给定一个二维矩阵，其中的值0代表路，1代表人，2代表障碍
+每个人都可以上下左右移动，但是只能走值为0的格子
+想把所有的人聚集在某个值为0的地方开会，希望所有人到会议点的总距离最短
+返回最短的开会总距离
+如果无论如何都无法让所有的人聚集到一起，返回-1
+leetcode题目 : https://leetcode.com/problems/shortest-distance-from-all-buildings/
+
+给定一个正整数数组arr，和正数k
+如果arr的某个子数组中含有k种不同的数，称这个子数组为有效子数组
+返回arr中有效子数组的数量
+leetcode题目 : https://leetcode.com/problems/subarrays-with-k-different-integers/
+
+
+
+45 大厂高频算法和数据结构面试题45
+
+来自京东笔试
+小明手中有n块积木，并且小明知道每块积木的重量。现在小明希望将这些积木堆起来
+要求是任意一块积木如果想堆在另一块积木上面，那么要求：
+1) 上面的积木重量不能小于下面的积木重量
+2) 上面积木的重量减去下面积木的重量不能超过x
+3) 每堆中最下面的积木没有重量要求
+现在小明有一个机会，除了这n块积木，还可以获得k块任意重量的积木。
+小明希望将积木堆在一起，同时希望积木堆的数量越少越好，你能帮他找到最好的方案么？
+输入描述:
+第一行三个整数n,k,x，1<=n<=200000，0<=x,k<=1000000000
+第二行n个整数，表示积木的重量，任意整数范围都在[1,1000000000]
+样例输出：
+n = 13 k = 1 x = 38
+arr : 20 20 80 70 70 70 420 5 1 5 1 60 90
+输出：2
+解释：
+两堆分别是
+1 1 5 5 20 20 x 60 70 70 70 80 90
+420
+其中x是一个任意重量的积木，夹在20和60之间可以让积木继续往上搭
+
+给定两个字符串pattern和s，返回s是否符合pattern的规定
+这里的符合是指，pattern里的每个字母和字符串s中子串，存在着单一映射双向连接的对应
+例子1：
+输入：pattern = "abab", s = "redblueredblue"
+输出：true
+解释：
+映射如下
+'a' -> "red"
+'b' -> "blue"
+例子2
+输入：pattern = "aaaa", s = "asdasdasdasd"
+输出：true
+解释:
+映射如下
+'a' -> "asd"
+例子3
+输入: pattern = "abab", s = "asdasdasdasd"
+输出: true
+解释:
+映射如下
+'a' -> "a"
+'b' -> "sdasd"
+例子4
+输入：pattern = "aabb", s = "xyzabcxzyabc"
+输出：false
+Leetcode题目 : https://leetcode.com/problems/word-pattern-ii/
+
+一只青蛙想要过河。 假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。 青蛙可以跳上石子，但是不可以跳入水中
+给你石子的位置列表 stones（用单元格序号 升序 表示）， 请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）
+开始时， 青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格 1 跳至单元格 2 ）
+如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 另请注意，青蛙只能向前方（终点的方向）跳跃
+示例 1：
+输入：stones = [0,1,3,5,6,8,12,17]
+输出：true
+解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。
+示例 2：
+输入：stones = [0,1,2,3,4,8,9,11]
+输出：false
+解释：这是因为第 5 和第 6 个石子之间的间距太大，没有可选的方案供青蛙跳跃过去。
+leetcode题目：https://leetcode.com/problems/frog-jump/
+
+给你一个长度为 2 * n 的整数数组。你需要将 nums 分成 两个 长度为 n 的数组，分别求出两个数组的和，并 最小化 两个数组和之 差的绝对值 。nums 中每个元素都需要放入两个数组之一。
+请你返回 最小 的数组和之差。
+数据范围：
+1 <= n <= 15
+nums.length == 2 * n
+-10^7 <= nums[i] <= 10^7
+leetcode题目：https://leetcode.com/problems/partition-array-into-two-arrays-to-minimize-sum-difference/
+
+
+
+46 大厂高频算法和数据结构面试题46
+
+给你一个 m x n 的矩阵 matrix 和一个整数 k ，找出并返回矩阵内部矩形区域的不超过 k 的最大数值和。
+题目数据保证总会存在一个数值和不超过 k 的矩形区域。
+leetcode题目：https://leetcode.com/problems/max-sum-of-rectangle-no-larger-than-k/
+
+我们有 N 个与坐标轴对齐的矩形, 其中 N > 0, 判断它们是否能精确地覆盖一个矩形区域。
+每个矩形用左下角的点和右上角的点的坐标来表示。例如， 一个单位正方形可以表示为 [1,1,2,2]。 ( 左下角的点的坐标为 (1, 1) 以及右上角的点的坐标为 (2, 2) )。
+示例 1:
+rectangles = [
+  [1,1,3,3],
+  [3,1,4,2],
+  [3,2,4,4],
+  [1,3,2,4],
+  [2,3,3,4]
+]
+返回 true。5个矩形一起可以精确地覆盖一个矩形区域。
+示例 2:
+rectangles = [
+  [1,1,2,3],
+  [1,3,2,4],
+  [3,1,4,2],
+  [3,2,4,4]
+]
+返回 false。两个矩形之间有间隔，无法覆盖成一个矩形。
+示例 3:
+rectangles = [
+  [1,1,3,3],
+  [3,1,4,2],
+  [1,3,2,4],
+  [3,2,4,4]
+]
+返回 false。图形顶端留有间隔，无法覆盖成一个矩形。
+示例 4:
+rectangles = [
+  [1,1,3,3],
+  [3,1,4,2],
+  [1,3,2,4],
+  [2,2,4,4]
+]
+返回 false。因为中间有相交区域，虽然形成了矩形，但不是精确覆盖。
+leetcode题目：https://leetcode.com/problems/perfect-rectangle/
+
+一个字符串可以用缩写的形式来代替，比如单词"substitution"，可以有以下几种缩写：
+"s10n" ("s+省略10个字符+n")
+"sub4u4" ("sub+省略4个字符+u+省略4个字符")
+"12" ("省略12个字符")
+等等还有很多
+给定一个字符串target、给定一个字符串数组作为字典dictionary，要求把target缩写成长度最短的形式，但是又不会和dictionary中任何单词混淆
+返回缩写最短形式的一种结果就可以
+例子1：
+输入：target = "apple", dictionary = ["blade"]
+输出: "a4"
+解释：
+"apple"最短的缩写是"5"，但是字典中"blade"长度也是5，所以会混淆
+"apple"第二短的缩写，有一种是"4e"，但是"4e"也可以是字典中"blade"，所以会混淆
+"apple"第二短的缩写，有一种是"a4"，字典中"blade"不以a开头，所以不会混淆
+例子2：
+输入: target = "apple", dictionary = ["blade","plain","amber"]
+输出: "1p3"
+leetcode题目：https://leetcode.com/problems/minimum-unique-word-abbreviation/
+
+给定n个字符串，并且每个字符串长度一定是n，请组成单词方阵，比如：
+给定4个字符串，长度都是4，["ball","area","lead","lady"]
+可以组成如下的方阵：
+b a l l
+a r e a
+l e a d
+l a d y
+什么叫单词方阵？如上的方阵可以看到，第1行和第1列都是"ball"，第2行和第2列都是"area"，第3行和第3列都是"lead"，第4行和第4列都是"lady"
+所以如果有N个单词，单词方阵是指，一个N*N的二维矩阵，并且i行和i列都是某个单词，不要求全部N个单词都在这个方阵里。
+请返回所有可能的单词方阵。
+示例：
+输入: words = ["abat","baba","atan","atal"]
+输出: [["baba","abat","baba","atal"],["baba","abat","baba","atan"]]
+解释：
+可以看到输出里，有两个链表，代表两个单词方阵
+第一个如下：
+b a b a
+a b a t
+b a b a
+a t a l
+这个方阵里没有atan，因为不要求全部单词都在方阵里
+第二个如下：
+b a b a
+a b a t
+b a b a
+a t a n
+这个方阵里没有atal，因为不要求全部单词都在方阵里
+leetcode题目：https://leetcode.com/problems/word-squares/
+
+
+
+47 大厂高频算法和数据结构面试题47
+
+动态开点线段树详解
+
+给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。
+输入：nums = [5,2,6,1]
+输出：[2,1,1,0] 
+解释：
+5 的右侧有 2 个更小的元素 (2 和 1)
+2 的右侧仅有 1 个更小的元素 (1)
+6 的右侧有 1 个更小的元素 (1)
+1 的右侧有 0 个更小的元素
+leetcode题目：https://leetcode.com/problems/count-of-smaller-numbers-after-self/
+
+给定一个字符串s和一个正数k，重新组织s使得每一种相同的字符距离至少有k，如果无法做到返回空字符串
+示例1：
+输入：s = "aabbcc", k = 3
+输出："abcabc"
+示例2：
+输入：s = "aaabc", k = 3
+输出：""
+示例3：
+输入：s = "aaadbbcc", k = 2
+输出： "abacabcd"
+leetcode题目：https://leetcode.com/problems/rearrange-string-k-distance-apart/
+
+设计多叉树的序列化和反序列化方案
+序列化：给定一棵多叉树的头节点，把整棵二叉树变成一个字符串返回
+反序列化：给定一个字符串，一定是某棵多叉树的序列化结果，生成整棵多叉树并返回头节点
+leetcode题目：https://leetcode.com/problems/serialize-and-deserialize-n-ary-tree/
+
+一开始所有人手上都是0元钱，[a,b,c]代表，a给b了c元钱。有很多这样的转账记录
+那么所有转账完成后，有的人剩余的钱是正数，有的人剩余的钱是负数
+现在想重新让所有人的钱都是0元，也就是回到初始状态，请问最少多少笔转账可以做到这一点
+例子1：
+输入：[[0,1,10],[2,0,5]]
+输出：2
+解释：0号转给1号10元，2号转给0号5元。上面所有转账完成后：0号-5，1号10，2号-5
+所以如果想所有人的钱都是0元，1号需要分别给0号和2号转账5元。所以最少2笔转账。
+例子2：
+输入：[[0,1,10],[1,0,1],[1,2,5],[2,0,5]]
+输出：1
+解释：如上的转账完成后，0号-4元，1号4元，2号0元，所以如果想所有人的钱都是0元，1号需要给0号转账4元。所以最少1比交易。
+leetcode题目：https://leetcode.com/problems/optimal-account-balancing/
+
+冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
+在加热器的加热半径范围内的每个房屋都可以获得供暖。
+现在，给出位于一条水平线上的房屋 houses 和供暖器 heaters 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。
+说明：所有供暖器都遵循你的半径标准，加热的半径也一样。
+示例 1:
+输入: houses = [1,2,3], heaters = [2]
+输出: 1
+解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1，那么所有房屋就都能得到供暖。
+示例 2:
+输入: houses = [1,2,3,4], heaters = [1,4]
+输出: 1
+解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1，这样所有房屋就都能得到供暖。
+示例 3：
+输入：houses = [1,5], heaters = [2]
+输出：3
+leetcode题目：https://leetcode.com/problems/heaters/
+
+
+
+48 大厂高频算法和数据结构面试题48
+
+来自学员问题
+比如{ 5, 3, 1, 4 }
+全部数字对是：(5,3)、(5,1)、(5,4)、(3,1)、(3,4)、(1,4)
+数字对的差值绝对值： 2、4、1、2、1、3
+差值绝对值排序后：1、1、2、2、3、4
+给定一个数组arr，和一个正数k
+返回arr中所有数字对差值的绝对值，第k小的是多少
+arr = { 5, 3, 1, 4 }, k = 4
+返回2
+
+给定一个 不含重复 单词的字符串数组 words ，编写一个程序，返回 words 中的所有 连接词 。
+连接词 的定义为：一个字符串完全是由至少两个给定数组中的单词组成的。
+示例 1：
+输入：words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
+输出：["catsdogcats","dogcatsdog","ratcatdogcat"]
+解释："catsdogcats"由"cats", "dog" 和 "cats"组成; 
+     "dogcatsdog"由"dog", "cats"和"dog"组成; 
+     "ratcatdogcat"由"rat", "cat", "dog"和"cat"组成。
+示例 2：
+输入：words = ["cat","dog","catdog"]
+输出：["catdog"]
+leetcode题目：https://leetcode.com/problems/concatenated-words/
+
+对于给定的整数 n, 如果n的k（k>=2）进制数的所有数位全为1，则称 k（k>=2）是 n 的一个好进制。
+以字符串的形式给出 n, 以字符串的形式返回 n 的最小好进制。
+示例 1：
+输入："13"
+输出："3"
+解释：13 的 3 进制是 111。
+示例 2：
+输入："4681"
+输出："8"
+解释：4681 的 8 进制是 11111。
+示例 3：
+输入："1000000000000000000"
+输出："999999999999999999"
+解释：1000000000000000000 的 999999999999999999 进制是 11。
+leetcode题目：https://leetcode.com/problems/smallest-good-base/
+
+给定一个二维数组代表迷宫，0代表路，1代表障碍
+给定一个球的位置，给定一个洞的位置
+你每次可以拨动球往上、下、左、右四个方向中的一个移动，但是球只有撞倒边界或者障碍才会停，只有球停了，你才能再次拨动球。
+你的目标是让球进洞，球在移动的过程中只要来到洞的位置，就认为球直接掉进洞里。你需要先保证球进洞的过程中，球移动的距离最短
+如果只有一种方案，直接返回这种方案的决定。
+如果有多个距离最短的方案，你需要返回其中字典序最小的决定。
+比如，假设如下两个方案，球的移动距离都是最小的:
+先往左拨动，球撞了墙之后，再往上拨，结果球进洞了，那么决定就是"lu" -> left up
+先往上拨动，球撞了墙之后，再往左拨，结果球进洞了，那么决定就是"ul" -> up left
+这两个方案如果都是移动距离最小的，那么应该返回lu，因为ul的字典序大
+leetcode题目：https://leetcode.com/problems/the-maze-iii/
+
+
+
+49 大厂高频算法和数据结构面试题49
+
+给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
+题目数据保证答案符合 32 位整数范围。
+leetcode题目：https://leetcode.com/problems/combination-sum-iv
+
+给定整数 n 和 k，找到 1 到 n 中字典序第 k 小的数字。
+注意：1 ≤ k ≤ n ≤ 10^9。
+示例 :
+输入:
+n: 13   k: 2
+输出:
+10
+解释:
+字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。
+leetcode题目：https://leetcode.com/problems/k-th-smallest-in-lexicographical-order/
+
+给你一个整数数组 nums ，返回 nums 中所有 等差子序列 的数目。
+如果一个序列中 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该序列为等差序列。
+例如，[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。
+再例如，[1, 1, 2, 5, 7] 不是等差序列。
+数组中的子序列是从数组中删除一些元素（也可能不删除）得到的一个序列。
+例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
+题目数据保证答案是一个 32-bit 整数。
+示例 1：
+输入：nums = [2,4,6,8,10]
+输出：7
+解释：所有的等差子序列为：
+[2,4,6]
+[4,6,8]
+[6,8,10]
+[2,4,6,8]
+[4,6,8,10]
+[2,4,6,8,10]
+[2,6,10]
+示例 2：
+输入：nums = [7,7,7,7,7]
+输出：16
+解释：数组中的任意子序列都是等差子序列。
+leetcode题目：https://leetcode.com/problems/arithmetic-slices-ii-subsequence/
+
+如下是机器人的类
+interface Robot {
+  // 如果机器人面朝的方向没有障碍，那么机器人将移动一步，并且返回true
+  // 如果机器人面朝的方向有障碍，那么机器人将停在原地，并且返回false
+  boolean move();
+  //机器人面朝的方向向左转动90度
+  void turnLeft();
+  //机器人面朝的方向向右转动90度
+  void turnRight();
+  // 机器人执行原地打扫的动作
+  void clean();
+}
+机器人将空降在房屋的某个地点，这一片局域会有障碍物，房屋的整片区域也一定有边界，边界等同于障碍
+房屋的整片区域假设是由1*1的格子拼成的，并且机器人自己占地也是1*1的格子
+但是你只能通过机器人的move方法，来让机器人移动并且探知障碍
+当然也可以让机器人通过turnLeft或者turnRight方法，来改变面朝的方向
+你如何只通过调用上面提到的方法，就控制机器人打扫房间的每个格子
+请实现如下的这个方法：
+public void cleanRoom(Robot robot) 
+leetcode题目：https://leetcode.com/problems/robot-room-cleaner/
+
+规定单词一定要遵循如下的缩写规则：
+1）一个单词保留若干长度的前缀，以及保留最后一个字符，中间用数字代表长度的方式来缩写
+2）如果缩写后的长度没有原始长度小，则该缩写依然保持原始串的样子
+比如:
+apple可以缩写成"a3e"，表示保留长度为1的前缀"a"，以及保留最后一个字符"e"，中间用3来代表"ppl"的长度。
+apple也可以缩写成"ap2e"，表示保留长度为2的前缀"ap"，以及保留最后一个字符"e"，中间用2来代表"pl"的长度。
+apple也可以缩写成"app1e"，但是因为"app1e"没有原始长度小，所以该缩写不能写成"app1e"，应该写成"apple"
+也就是说，你可以去选择保留前缀的长度，一旦前缀确定，那么缩写剩下的内容也就都决定了。因为一定要保留最后一个字符，以及中间部分用数字代表长度。
+理解了缩写规定之后，请理解对几个字符串都做缩写，但是不能混淆的规定。
+比如："abkkf"和"abcde"
+"abkkf"缩写为"a3f"，"abcde"缩写为"a3e"，两个字符串的缩写都能变得最短，且不会混淆。因为最后的字符不一样，所以可以区分开
+比如："abkkkkc"和"abkskkc"
+"abkkkkc"缩写为"a5c"，"abkskkc"缩写为"a5c"，此时发现会混淆，因为缩写之后完全一样
+"abkkkkc"缩写为"abkk2c"，"abkskkc"缩写为"abks2c"，这是两个字符串缩写都尽可能短，且不会混淆的缩写。
+给你一个字符串数组arr，请完成对每个字符串的缩写，要求任意两个字符串都不会混淆，且每个字符串的缩写都尽可能的短。
+例子一
+输入：["like","god","internal","me","internet","interval","intension","face","intrusion"]
+输出：["l2e","god","internal","me","i6t","interval","inte4n","f2e","intr4n"]
+例子二
+输入: words = ["aa","aaa"]
+输出: ["aa","aaa"]
+leetcode题目：https://leetcode.com/problems/word-abbreviation/
+
+给定一个数组nums，请将nums切三刀，切出四个部分，被切的数字不算，要求每个部分累加和都一样大，返回能不能做到
+比如
+输入：nums = [1,2,1,2,1,2,1]
+输出：true
+解释：
+三刀的位置分别为，i = 1, j = 3, k = 5，切完后这三个位置的数不算
+所以切出的四个部分为(1) (1) (1) (1)，所以能做到返回true
+leetcode题目：https://leetcode.com/problems/split-array-with-equal-sum/
+
+给定一个整数 n ，你需要找到与它最近的回文数（不包括自身）。
+“最近的”定义为两个整数差的绝对值最小。
+示例 1:
+输入: "123"
+输出: "121"注意:
+n 是由字符串表示的正整数，其长度不超过18。
+如果有多个结果，返回最小的那个。
+leetcode题目：https://leetcode.com/problems/find-the-closest-palindrome/
+
+
+
+50 大厂高频算法和数据结构面试题50
+
+力扣想让一个最优秀的员工在 N 个城市间旅行来收集算法问题。
+但只工作不玩耍，聪明的孩子也会变傻，所以您可以在某些特定的城市和星期休假。
+您的工作就是安排旅行使得最大化你可以休假的天数，但是您需要遵守一些规则和限制。
+规则和限制：
+您只能在 N 个城市之间旅行，用 0 到 N-1 的索引表示。一开始，您在索引为0的城市，并且那天是星期一。
+这些城市通过航班相连。这些航班用 N*N 矩阵 flights（不一定是对称的）表示，flights[i][j] 代表城市i到城市j的航空状态。如果没有城市i到城市j的航班，
+flights[i][j] = 0；否则，flights[i][j] = 1。同时，对于所有的 i，flights[i][i] = 0。
+您总共有 K 周（每周7天）的时间旅行。您每天最多只能乘坐一次航班，并且只能在每周的星期一上午乘坐航班。由于飞行时间很短，我们不考虑飞行时间的影响。
+对于每个城市，不同的星期您休假天数是不同的，给定一个 N*K 矩阵 days 代表这种限制，days[i][j] 代表您在第j个星期在城市i能休假的最长天数。
+给定 flights 矩阵和 days 矩阵，您需要输出 K 周内可以休假的最长天数。
+leetcode题目：https://leetcode.com/problems/maximum-vacation-days/
+
+凸包问题经典题
+在一个二维的花园中，有一些用 (x, y) 坐标表示的树。由于安装费用十分昂贵，你的任务是先用最短的绳子围起所有的树。只有当所有的树都被绳子包围时，花园才能围好栅栏。你需要找到正好位于栅栏边界上的树的坐标。
+leetcode题目：https://leetcode.com/problems/erect-the-fence/
+
+设计一个数据结构，和文件系统很像
+类中的方法如下：
+FileSystem()：初始化这个数据结构
+List<String> ls(String path)：如果根据路径path找到的是文件，列出这个文件的名字，如果path找到的是文件夹，列出这个文件夹里的所有文件夹和文件名。（就像ls命令一样）
+void mkdir(String path)：根据path路径建出文件夹，如果中间的文件夹缺失，一路都建立出来。
+void addContentToFile(String filePath, String content)：根据filePath路径找到文件，如果不存在就新建。然后把内容content加在这个文件的尾部。
+String readContentFromFile(String filePath)：根据filePath读出文件内容并返回。
+leetcode题目：https://leetcode.com/problems/design-in-memory-file-system/
+
+给定一个正整数 n，找出小于或等于 n 的非负整数中，其二进制表示不包含 连续的1 的个数。
+示例 1:
+输入: 5
+输出: 5
+解释: 
+下面是带有相应二进制表示的非负整数<= 5：
+0 : 0
+1 : 1
+2 : 10
+3 : 11
+4 : 100
+5 : 101
+其中，只有整数3违反规则（有两个连续的1），其他5个满足规则。
+说明：1 <= n <= 10^9
+leetcode题目：https://leetcode-cn.com/problems/non-negative-integers-without-consecutive-ones/
+
+
+
+51 大厂高频算法和数据结构面试题51
+
+力扣团队买了一个可编程机器人，机器人初始位置在原点(0, 0)。小伙伴事先给机器人输入一串指令command，机器人就会无限循环这条指令的步骤进行移动。指令有两种：
+U: 向y轴正方向移动一格
+R: 向x轴正方向移动一格。
+不幸的是，在 xy 平面上还有一些障碍物，他们的坐标用obstacles表示。机器人一旦碰到障碍物就会被损毁。
+给定终点坐标(x, y)，返回机器人能否完好地到达终点。如果能，返回true；否则返回false。
+示例 1：
+输入：command = "URR", obstacles = [], x = 3, y = 2
+输出：true
+解释：U(0, 1) -> R(1, 1) -> R(2, 1) -> U(2, 2) -> R(3, 2)。
+示例 2：
+输入：command = "URR", obstacles = [[2, 2]], x = 3, y = 2
+输出：false
+解释：机器人在到达终点前会碰到(2, 2)的障碍物。
+示例 3：
+输入：command = "URR", obstacles = [[4, 2]], x = 3, y = 2
+输出：true
+解释：到达终点后，再碰到障碍物也不影响返回结果。
+限制：
+2 <= command的长度 <= 1000
+command由U，R构成，且至少有一个U，至少有一个R
+0 <= x <= 1e9, 0 <= y <= 1e9
+0 <= obstacles的长度 <= 1000
+obstacles[i]不为原点或者终点
+链接：https://leetcode-cn.com/problems/programmable-robot/
+
+这里有 n 门不同的在线课程，他们按从 1 到 n 编号。每一门课程有一定的持续上课时间（课程时间）t 以及关闭时间第 d 天。一门课要持续学习 t 天直到第 d 天时要完成，你将会从第 1 天开始。
+给出 n 个在线课程用 (t, d) 对表示。你的任务是找出最多可以修几门课。
+示例：
+输入: [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]
+输出: 3
+解释: 
+这里一共有 4 门课程, 但是你最多可以修 3 门:
+首先, 修第一门课时, 它要耗费 100 天，你会在第 100 天完成, 在第 101 天准备下门课。
+第二, 修第三门课时, 它会耗费 1000 天，所以你将在第 1100 天的时候完成它, 以及在第 1101 天开始准备下门课程。
+第三, 修第二门课时, 它会耗时 200 天，所以你将会在第 1300 天时完成它。
+第四门课现在不能修，因为你将会在第 3300 天完成它，这已经超出了关闭日期。
+提示:
+整数 1 <= d, t, n <= 10,000 。
+你不能同时修两门课程。
+leetcode题目：https://leetcode.com/problems/course-schedule-iii/
+
+为搜索引擎设计一个搜索自动完成系统。用户可以输入一个句子(至少一个单词，并以一个特殊的字符'#'结尾)。
+对于除'#'之外的每个字符，您需要返回与已输入的句子部分前缀相同的前3个历史热门句子。具体规则如下:
+一个句子的热度定义为用户输入完全相同句子的次数。 返回的前3个热门句子应该按照热门程度排序(第一个是最热的)。
+如果几个句子的热度相同，则需要使用ascii代码顺序(先显示较小的一个)。 如果少于3个热门句子，那么就尽可能多地返回。 
+当输入是一个特殊字符时，它意味着句子结束，在这种情况下，您需要返回一个空列表。 您的工作是实现以下功能:
+构造函数:
+AutocompleteSystem(String[] sentence, int[] times):这是构造函数。输入是历史数据。
+句子是由之前输入的句子组成的字符串数组。Times是输入一个句子的相应次数。您的系统应该记录这些历史数据。
+现在，用户想要输入一个新句子。下面的函数将提供用户类型的下一个字符:
+List input(char c)：输入c是用户输入的下一个字符。字符只能是小写字母(“a”到“z”)、空格(“”)或特殊字符(“#”)。
+另外，前面输入的句子应该记录在系统中。输出将是前3个历史热门句子，它们的前缀与已经输入的句子部分相同。
+例子: 
+操作:AutocompleteSystem(["i love you"， "island"，"ironman"， "i love leetcode"]， [5,3,2,2]) 系统已经追踪到以下句子及其对应的时间:
+"i love you" : 5 times 
+"island" : 3 times 
+"ironman" : 2 times 
+"i love leetcode" : 2 times
+现在，用户开始另一个搜索:
+操作:输入(“i”) 输出:["i love you"， "island"，"i love leetcode"]
+解释: 有四个句子有前缀“i”。其中，《ironman》和《i love leetcode》有着相同的热度。既然“ ” ASCII码为32，“r”ASCII码为114，
+那么“i love leetcode”应该在“ironman”前面。此外，我们只需要输出前3个热门句子，所以“ironman”将被忽略。
+操作:输入(' ') 输出:[“i love you”，“i love leetcode”] 解释: 只有两个句子有前缀“i”。
+操作:输入(' a ') 输出:[] 解释: 没有以“i a”为前缀的句子。
+操作:输入(“#”) 输出:[] 解释: 用户完成输入后，在系统中将句子“i a”保存为历史句。下面的输入将被计算为新的搜索。
+注意:
+输入的句子总是以字母开头，以“#”结尾，两个单词之间只有一个空格。 
+要搜索的完整句子不会超过100个。包括历史数据在内的每句话的长度不会超过100句。
+设计一个搜索自动补全系统，它需要包含如下两个方法：
+构造方法：
+AutocompleteSystem(String[] sentences, int[] times): 输入句子sentences，及其出现次数times
+输入方法：
+List input(char c): 输入字符c可以是26个小写英文字母，也可以是空格，以'#'结尾。返回输入字符前缀对应频率最高的至多3个句子，频率相等时按字典序排列。
+leetcode题目：https://leetcode.com/problems/design-search-autocomplete-system/
+
+珂珂喜欢吃香蕉。这里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。
+珂珂可以决定她吃香蕉的速度 K （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 K 根。如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉。  
+珂珂喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。
+返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。
+示例 1：
+输入: piles = [3,6,7,11], H = 8
+输出: 4
+示例 2：
+输入: piles = [30,11,23,4,20], H = 5
+输出: 30
+示例 3：
+输入: piles = [30,11,23,4,20], H = 6
+输出: 23
+leetcode题目：https://leetcode.com/problems/koko-eating-bananas/
+
+在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
+现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：
+nums1[i] == nums2[j]
+且绘制的直线不与任何其他连线（非水平线）相交。
+请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。
+以这种方法绘制线条，并返回可以绘制的最大连线数。
+leetcode题目：https://leetcode.com/problems/uncrossed-lines/
+
+
+
+52 大厂高频算法和数据结构面试题52
+
+给定一个数组arr，arr[i] = j，表示来到i位置需要承受j的代价。给定一个正数jump，表示任何位置都可以随意往右跳<=jump步。
+要求你从1位置开始，跳到数组最后位置n，在保证最小代价的前提下，返回字典序最小的路径
+leetcode题目：https://leetcode.com/problems/coin-path/
+
+给定一个数组bulbs，bulds[i] = j，表示第i天亮起的灯是j。任何一天只会亮一盏灯，如果天数有1~i天，那么灯也一定只有1~i号。
+给定一个正数k，如果两盏亮起的灯之间有正好k个不亮的灯，那么说这个是达标情况。
+返回最早在哪一天，会出现达标情况，如果不存在达标情况，返回-1
+leetcode题目：https://leetcode.com/problems/k-empty-slots/
+
+你的国家有无数个湖泊，所有湖泊一开始都是空的。当第 n 个湖泊下雨的时候，如果第 n 个湖泊是空的，那么它就会装满水，否则这个湖泊会发生洪水。你的目标是避免任意一个湖泊发生洪水。
+给你一个整数数组 rains ，其中：
+rains[i] > 0 表示第 i 天时，第 rains[i] 个湖泊会下雨。
+rains[i] == 0 表示第 i 天没有湖泊会下雨，你可以选择 一个 湖泊并 抽干 这个湖泊的水。
+请返回一个数组 ans ，满足：
+ans.length == rains.length
+如果 rains[i] > 0 ，那么ans[i] == -1 。
+如果 rains[i] == 0 ，ans[i] 是你第 i 天选择抽干的湖泊。
+如果有多种可行解，请返回它们中的 任意一个 。如果没办法阻止洪水，请返回一个 空的数组 。
+leetcode题目：https://leetcode.com/problems/avoid-flood-in-the-city/
+
+
diff --git "a/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\346\257\217\345\221\250\346\234\211\350\220\245\345\205\273\347\232\204\345\244\247\345\216\202\347\256\227\346\263\225\351\235\242\350\257\225\351\242\230(\346\255\243\345\234\250\347\233\264\346\222\255)" "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\346\257\217\345\221\250\346\234\211\350\220\245\345\205\273\347\232\204\345\244\247\345\216\202\347\256\227\346\263\225\351\235\242\350\257\225\351\242\230(\346\255\243\345\234\250\347\233\264\346\222\255)"
new file mode 100644
index 0000000..43bbcaf
--- /dev/null
+++ "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\346\257\217\345\221\250\346\234\211\350\220\245\345\205\273\347\232\204\345\244\247\345\216\202\347\256\227\346\263\225\351\235\242\350\257\225\351\242\230(\346\255\243\345\234\250\347\233\264\346\222\255)"
@@ -0,0 +1,4249 @@
+每周有营养的大厂算法面试题
+
+第001节  2021年11月第4周流行算法题目解析
+
+给定一棵多叉树的头节点head，每个节点只有黑白两色
+所有黑节点都保留，所有从头节点到黑节点路径上的点都保留
+返回处理后树的头节点
+
+我们正在玩一个猜数游戏，游戏规则如下：
+我从 1 到 n 之间选择一个数字。
+你来猜我选了哪个数字。
+如果你猜到正确的数字，就会 赢得游戏 。
+如果你猜错了，那么我会告诉你，我选的数字比你的 更大或者更小 ，并且你需要继续猜数。
+每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。
+如果你花光了钱，就会 输掉游戏 。
+给你一个特定的数字 n ，返回能够 确保你获胜 的最小现金数，不管我选择那个数字 。
+Leetcode链接 : https://leetcode.com/problems/guess-number-higher-or-lower-ii/
+
+来自真实面试，同学给我的问题
+限制：0 <= start <= end，0 <= target <= 64
+[start,end]范围上的数字，有多少数字二进制中1的个数等于target
+
+
+
+第002节  2021年12月第1周流行算法题目解析
+
+int n, int[][] roads, int x, int y
+n表示城市数量，城市编号0~n-1
+roads[i][j] == distance，表示城市i到城市j距离为distance(无向图)
+求城市x到城市y的最短距离
+
+一开始屏幕上什么也没有，粘贴板里什么也没有，
+你只能在键盘上做如下4种操作中的1种：
+输入：在屏幕上已经显示内容的后面加一个A
+全选：把屏幕上已经显示的全部内容选中
+复制：被选中的内容复制进粘贴板
+粘贴：在屏幕上已经显示内容的后面添加粘贴板里的内容
+给定一个正数n，表示你能操作的步数，
+返回n步内你能让最多多少个A显示在屏幕上
+Leetcode链接 : https://leetcode.com/problems/4-keys-keyboard/
+
+给定一棵树的头节点head，原本是一棵正常的树
+现在，在树上多加了一条冗余的边
+请找到这条冗余的边并返回
+Leetcode链接 : https://leetcode.com/problems/redundant-connection-ii/
+
+
+
+第003节 2021年12月第2周流行算法题目解析
+
+给你一个整数 n ，表示有 n 个专家从 0 到 n - 1 编号。
+另外给一个下标从 0 开始的二维整数数组 meetings ，
+其中 meetings[i] = [xi, yi, timei] 表示专家 xi 和专家 yi 在时间 timei 要开一场会。
+一个专家可以同时参加 多场会议 。最后，给你一个整数 firstPerson 。
+专家 0 有一个 秘密 ，最初，他在时间 0 将这个秘密分享给了专家 firstPerson 。
+这个秘密会在每次有知晓这个秘密的专家参加会议时进行传播。更正式的表达是，每次会议，
+如果专家 xi 在时间 timei 时知晓这个秘密，那么他将会与专家 yi 分享这个秘密，反之亦然。
+秘密共享是 瞬时发生 的。也就是说，在同一时间，一个专家不光可以接收到秘密，还能在其他会议上与其他专家分享。
+在所有会议都结束之后，返回所有知晓这个秘密的专家列表。你可以按 任何顺序 返回答案。
+Leetcode链接 : https://leetcode.com/problems/find-all-people-with-secret/
+
+来自美团
+所有黑洞的中心点记录在holes数组里
+比如[[3,5] [6,9]]表示，第一个黑洞在(3,5)，第二个黑洞在(6,9)
+并且所有黑洞的中心点都在左下角(0,0)，右上角(x,y)的区域里
+飞船一旦开始进入黑洞，就会被吸进黑洞里
+返回如果统一所有黑洞的半径，最大半径是多少，
+依然能保证飞船从(0,0)能到达(x,y)
+
+arr数组长度为n, magic数组长度为m
+比如 arr = { 3, 1, 4, 5, 7 }，如果完全不改变arr中的值，
+那么收益就是累加和 = 3 + 1 + 4 + 5 + 7 = 20
+magics[i] = {a,b,c} 表示arr[a~b]中的任何一个值都能改成c
+并且每一种操作，都可以执行任意次，其中 0 <= a <= b < n
+那么经过若干次的魔法操作，你当然可能得到arr的更大的累加和
+返回arr尽可能大的累加和
+n <= 10^7     m <= 10^6    arr中的值和c的范围 <= 10^12
+
+已知一棵二叉树上所有的值都不一样，
+给定这棵二叉树的头节点head，
+给定一个整型数组arr，arr里放着不同的值，每个值一定在树上
+返回数组里所有值的最低公共祖先
+Leetcode链接 : https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree-iv/
+
+给定一棵多叉树的头节点head
+每个节点的颜色只会是0、1、2、3中的一种
+任何两个节点之间的都有路径
+如果节点a和节点b的路径上，包含全部的颜色，这条路径算达标路径
+(a -> ... -> b)和(b -> ... -> a)算两条路径
+求多叉树上达标的路径一共有多少？
+点的数量 <= 10^5
+
+
+
+第004节 2021年12月第3周流行算法题目解析
+
+来自TME2022校园招聘后台开发/运营开发/业务运维/应用开发笔试
+给定一棵二叉树的头节点head，和一个正数k。从最底层开始，每一层右移k位，然后往上走过每一层，进行树的调整
+返回调整之后树的头节点
+具体详情请参加如下的测试页面
+测试链接 : https://www.nowcoder.com/test/33701596/summary
+本题目为该试卷第1题
+
+来自TME2022校园招聘后台开发/运营开发/业务运维/应用开发笔试
+给定一个只由'0'和'1'组成的字符串，代表一个无符号整数
+你只能在连续的一个子串上，翻转子串，也就是子串上，0变1，1变0。返回最大的结果
+具体详情请参加如下的测试页面
+测试链接 : https://www.nowcoder.com/test/33701596/summary
+本题目为该试卷第2题
+
+来自TME2022校园招聘后台开发/运营开发/业务运维/应用开发笔试
+给定两个参数n和k，返回m
+含义：k进制的情况下，把1~m每一位的状态列出来，其中1状态出现的数量要>=n
+返回最小的、能做到这一点的m值
+具体详情请参加如下的测试页面
+测试链接 : https://www.nowcoder.com/test/33701596/summary
+本题目为该试卷第3题
+
+你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n 的矩阵表示， 在这个矩阵中：
+0 表示障碍，无法触碰
+1 表示地面，可以行走
+比1大的数 表示有树的单元格，也可以行走，数值表示树的高度
+每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。
+你需要按照树的高度从低向高砍掉所有的树，每砍过一颗树，该单元格的值变为 1（即变为地面）。
+你将从 (0, 0) 点开始工作，返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树，返回 -1 。
+可以保证的是，没有两棵树的高度是相同的，并且你至少需要砍倒一棵树
+Leetcode链接 : https://leetcode.com/problems/cut-off-trees-for-golf-event/
+
+来自CMU入学申请考试
+给定一个长度为 N 的字符串 S，由字符'a'和'b'组成，空隙由 '?' 表示
+你的任务是用a字符或b字符替换每个间隙，
+替换完成后想让连续出现同一种字符的最长子串尽可能短
+例如，S = "aa??bbb"，
+如果将"??"替换为"aa" ，即"aaaabbb"，则由相等字符组成的最长子串长度为4
+如果将"??"替换为"ba" ，即"aababbb"，则由相等字符组成的最长子串长度为3
+那么方案二是更好的结果，返回3
+S的长度 <= 10^6
+
+
+
+第005节 2021年12月第4周流行算法题目解析
+
+来自美团
+给定一个无向图
+从任何一个点x出发，比如有一条路径: x -> a -> b -> c -> y
+这条路径上有5个点并且5个点都不一样的话，我们说(x,a,b,c,y)是一条合法路径
+这条合法路径的代表，就是x,a,b,c,y所组成的集合，我们叫做代表集合
+如果从b到y，还有一条路径叫(b,a,c,x,y)，那么(x,a,b,c,y)和(b,a,c,x,y)是同一个代表集合
+返回这个无向图中所有合法路径的代表集合数量
+题目给定点的数量n <= 15，边的数量m <= 60
+所有的点编号都是从0~n-1的
+
+来自北京北明数科信息技术有限公司
+class AreaResource {
+String area; // area表示的是地区全路径,最多可能有6级，比如： 中国,四川,成都  或者  中国,浙江,杭州
+String spliter; // 比如：逗号 -> ,
+long count; // 表示地区的门店数量
+}
+现在需要把  List<AreaResource> 进行转换，需要做到同级的地域能合并
+比如：area为中国,四川,成都 ，有10个门店；area为中国,浙江,杭州，有25个门店；area为中国,浙江,义乌，有22个门店
+最终生成的JSON字符串为：  {"中国":{"四川":{"成都":10]},"浙江":{"义乌":22,"杭州":25}}}
+请实现下面的方法 public String mergeCount(List<AreaResource> areas) 
+
+来自hulu
+有一个以原点为圆心，半径为1的圆
+在这个圆的圆周上，有一些点
+因为所有的点都在圆周上，所以每个点可以有很简练的表达
+比如：用0来表示一个圆周上的点，这个点就在(1,0)位置
+比如：用6000来表示一个点，这个点是(1,0)点沿着圆周逆时针转60.00度之后所在的位置
+比如：用18034来表示一个点，这个点是(1,0)点沿着圆周逆时针转180.34度之后所在的位置
+这样一来，所有的点都可以用[0, 36000)范围上的数字来表示
+那么任意三个点都可以组成一个三角形，返回能组成钝角三角形的数量
+
+整个二维平面算是一张地图，给定[x,y]，表示你站在x行y列
+你可以选择面朝的任何方向
+给定一个正数值angle，表示你视野的角度为
+这个角度内你可以看无穷远，这个角度外你看不到任何东西
+给定一批点的二维坐标，
+返回你在朝向最好的情况下，最多能看到几个点
+
+有m个同样的苹果，认为苹果之间无差别
+有n个同样的盘子，认为盘子之间也无差别
+还有，比如5个苹果如果放进3个盘子，
+那么1、3、1和1、1、3和3、1、1的放置方法，也认为是一种方法
+如上的设定下，返回有多少种放置方法
+
+
+
+第006节 2021年12月第5周流行算法题目解析
+
+有一组 n 个人作为实验对象，从 0 到 n - 1 编号，其中每个人都有不同数目的钱，
+以及不同程度的安静值（quietness）
+为了方便起见，我们将编号为 x 的人简称为 "person x "。
+给你一个数组 richer ，其中 richer[i] = [ai, bi] 表示 person ai 比 person bi 更有钱
+另给你一个整数数组 quiet ，其中 quiet[i] 是 person i 的安静值
+richer 中所给出的数据 逻辑自洽
+也就是说，在 person x 比 person y 更有钱的同时，不会出现 person y 比 person x 更有钱的情况
+现在，返回一个整数数组 answer 作为答案，其中 answer[x] = y 的前提是：
+在所有拥有的钱肯定不少于 person x 的人中，person y 是最安静的人（也就是安静值 quiet[y] 最小的人）。
+leetcode链接 : https://leetcode.com/problems/loud-and-rich/
+
+来自hulu
+有n个人，m个任务，任务之间有依赖记录在int[][] depends里
+比如: depends[i] = [a, b]，表示a任务依赖b任务的完成
+其中 0 <= a < m，0 <= b < m
+1个人1天可以完成1个任务，每个人都会选当前能做任务里，标号最小的任务
+一个任务所依赖的任务都完成了，该任务才能开始做
+返回n个人做完m个任务，需要几天
+
+来自hulu
+你只有1*1、1*2、1*3、1*4，四种规格的砖块
+你想铺满n行m列的区域，规则如下：
+1）不管那种规格的砖，都只能横着摆
+      比如1*3这种规格的砖，3长度是水平方向，1长度是竖直方向
+2）会有很多方法铺满整个区域，整块区域哪怕有一点点不一样，就算不同的方法
+3）区域内部(不算区域整体的4条边界)，不能有任何砖块的边界线（从上一直贯穿到下）
+返回符合三条规则下，铺满n行m列的区域，有多少种不同的摆放方法
+
+
+
+第007节 2022年1月第1周流行算法题目解析
+
+来自阿里
+给定一个只由'a'和'b'组成的字符串str，
+str中"ab"和"ba"子串都可以消除，
+消除之后剩下字符会重新靠在一起，继续出现可以消除的子串...
+你的任务是决定一种消除的顺序，最后让str消除到尽可能的短
+返回尽可能的短的剩余字符串
+
+在一张 无向 图上，节点编号0~N-1。老鼠开始在1节点，猫在2节点，0号节点是洞，老鼠想进洞
+老鼠第先出发，猫后出发，轮流行动。
+在每个玩家的行动中，他们 必须 沿着图中与所在当前位置连通的一条边移动
+此外猫无法移动到洞中（节点 0）。
+然后，游戏在出现以下三种情形之一时结束：
+如果猫和老鼠出现在同一个节点，猫获胜。
+如果老鼠到达洞中，老鼠获胜。
+如果某一位置重复出现（即，玩家的位置和移动顺序都与上一次行动相同），游戏平局。
+给你一张图 graph ，并假设两位玩家都都以最佳状态参与游戏，返回谁获胜
+leetcode链接 : https://leetcode.com/problems/cat-and-mouse/
+
+给你两个长度分别 n 和 m 的整数数组 nums 和 multipliers ，其中 n >= m ，
+数组下标 从 1 开始 计数。
+初始时，你的分数为 0 。
+你需要执行恰好 m 步操作。在第 i 步操作（从 1 开始 计数）中，需要：
+选择数组 nums 开头处或者末尾处 的整数 x 。
+你获得 multipliers[i] * x 分，并累加到你的分数中。
+将 x 从数组 nums 中移除。
+在执行 m 步操作后，返回 最大 分数。
+leetcode链接 : https://leetcode.com/problems/maximum-score-from-performing-multiplication-operations/
+
+来自学员问题
+给定一个二维数组，其中全是非负数
+每一步都可以往上、下、左、右四个方向运动
+返回从左下角走到右下角的最短距离
+
+
+
+第008节 2022年1月第2周流行算法题目解析
+
+给定一个非常大的List<String> list
+每一个字符串类似 : "hello,world,have,hello,world"
+这一个字符串中，有2个hello，2个world，1个have
+请设计一种多线程处理方案，统计list中每一个字符串，切分出来的单词数量，并且汇总
+最终返回一个HashMap<String, Integer>表示每个字符串在list中一共出现几次
+多线程设计 + 算法
+本题没有代码实现，会在课上讲述思路
+
+给定一个正数数组arr，其中每个值代表砖块长度
+所有砖块等高等宽，只有长度有区别
+每一层可以用1块或者2块砖来摆
+要求每一层的长度一样
+要求必须使用所有的砖块
+请问最多摆几层
+
+来自兴业数金
+给定一个字符串形式的数，比如"3421"或者"-8731"
+如果这个数不在-32768~32767范围上，那么返回"NODATA"
+如果这个数在-32768~32767范围上，那么这个数就没有超过16个二进制位所能表达的范围
+返回这个数的2进制形式的字符串和16进制形式的字符串，用逗号分割
+
+给你一个下标从 0 开始包含 n 个正整数的数组 arr ，和一个正整数 k 。
+如果对于每个满足 k <= i <= n-1 的下标 i ，都有 arr[i-k] <= arr[i] ，那么我们称 arr 是 K 递增 的。
+比方说，arr = [4, 1, 5, 2, 6, 2] 对于 k = 2 是 K 递增的，因为：
+arr[0] <= arr[2] (4 <= 5)
+arr[1] <= arr[3] (1 <= 2)
+arr[2] <= arr[4] (5 <= 6)
+arr[3] <= arr[5] (2 <= 2)
+但是，相同的数组 arr 对于 k = 1 不是 K 递增的（因为 arr[0] > arr[1]），
+对于 k = 3 也不是 K 递增的（因为 arr[0] > arr[3] ）。
+每一次 操作 中，你可以选择一个下标 i 并将 arr[i] 改成任意 正整数。
+请你返回对于给定的 k ，使数组变成 K 递增的 最少操作次数 。
+leetcode链接 : https://leetcode.com/problems/minimum-operations-to-make-the-array-k-increasing/
+
+来自美团
+小美有一个长度为n的数组，
+为了使得这个数组的和尽量大，她向会魔法的小团进行求助
+小团可以选择数组中至多两个不相交的子数组，
+并将区间里的数全都变为原来的10倍
+小团想知道他的魔法最多可以帮助小美将数组的和变大到多少?
+
+给定一个非负数组arr，学生依次坐在0~N-1位置，每个值表示学生的安静值
+如果在i位置安置插班生，那么i位置的安静值变成0，同时任何同学都会被影响到而减少安静值
+同学安静值减少的量: N - 这个同学到插班生的距离
+但是减到0以下的话，当做0处理
+返回一个和arr等长的ans数组，ans[i]表示如果把插班生安排在i位置，所有学生的安静值的和
+比如 : arr = {3,4,2,1,5}，应该返回{4,3,2,3,4}
+比如 : arr = {10,1,10,10,10}，应该返回{24,27,20,20,22}
+arr长度 <= 10^5
+arr中值 <= 2 * 10^5
+注意：本题在直播课上讲错了，已经发了重新录制的视频，请一定要看更正后的视频
+
+
+
+第009节 2022年1月第3周流行算法题目解析
+
+A*算法
+过程和Dijskra高度相处
+有到终点的预估函数
+只要预估值<=客观上最优距离，就是对的
+预估函数是一种吸引力：
+1）合适的吸引力可以提升算法的速度
+2）吸引力“过强”会出现错误
+
+在一个10^6 * 10^6的网格中，
+source = [sx, sy]是出发位置，target = [tx, ty]是目标位置
+数组blocked是封锁的方格列表，被禁止的方格数量不超过200
+blocked[i] = [xi, yi] 表示(xi, yi)的方格是禁止通行的
+每次移动都可以走上、下、左、右四个方向
+但是来到的位置不能在封锁列表blocked上
+同时不允许走出网格
+如果从source能到达target返回 true。否则返回false。
+
+来自字节跳动
+给定一个数组arr，其中的值有可能正、负、0
+给定一个正数k
+返回累加和>=k的所有子数组中，最短的子数组长度
+
+
+
+第010节 2022年1月第4周流行算法题目解析
+
+things是一个N*3的二维数组，商品有N件，商品编号从1~N
+比如things[3] = [300, 2, 6]
+代表第3号商品：价格300，重要度2，它是6号商品的附属商品
+再比如things[6] = [500, 3, 0]
+代表第6号商品：价格500，重要度3，它不是任何附属，它是主商品
+每件商品的收益是价格*重要度，花费就是价格
+如果一个商品是附属品，那么只有它附属的主商品购买了，它才能被购买
+任何一个附属商品，只会有1个主商品
+任何一个主商品的附属商品数量，不会超过2件
+主商品和附属商品的层级最多有2层
+给定二维数组things、钱数money，返回整体花费不超过money的情况下，最大的收益总和
+
+来自美团
+小团去参加军训，军训快要结束了，长官想要把大家一排n个人分成m组，然后让每组分别去参加阅兵仪式
+只能选择相邻的人一组，不能随意改变队伍中人的位置
+阅兵仪式上会进行打分，其中有一个奇怪的扣分点是每组的最大差值，即每组最大值减去最小值
+长官想要让这分成的m组总扣分量最小，即这m组分别的极差之和最小
+长官正在思索如何安排中，就让小团来帮帮他吧
+
+给定一个包含 [0，n) 中不重复整数的黑名单 blacklist
+写一个函数从 [0, n) 中返回一个不在 blacklist 中的随机整数
+对它进行优化使其尽量少调用系统方法 Math.random()
+1 <= n <= 1000000000
+0 <= blacklist.length < min(100000, N)
+leetcode链接: https://leetcode.com/problems/random-pick-with-blacklist/
+
+来自米哈游
+给你一个大小为 m x n 的矩阵 board 表示甲板，其中，每个单元格可以是一艘战舰 'X' 或者是一个空位 '.'
+返回在甲板 board 上放置的 战舰 的数量
+战舰只能水平或者垂直放置在 board 上。换句话说，战舰只能按 1 x k（1 行，k 列）或 k x 1（k 行，1 列）的形状建造
+其中 k 可以是任意大小
+两艘战舰之间至少有一个水平或垂直的空位分隔 （即没有相邻的战舰）
+leetcode链接: https://leetcode.com/problems/battleships-in-a-board
+
+
+
+第011节 2022年2月第2周流行算法题目解析
+
+给定一个长度为4的整数数组 cards 。你有 4 张卡片，每张卡片上都包含一个范围在 [1,9] 的数字
+您应该使用运算符 ['+', '-', '*', '/'] 和括号 '(' 和 ')' 将这些卡片上的数字排列成数学表达式，以获得值24。
+你须遵守以下规则:
+除法运算符 '/' 表示实数除法，而不是整数除法。
+例如， 4 /(1 - 2 / 3)= 4 /(1 / 3)= 12 。
+每个运算都在两个数字之间。特别是，不能使用 “-” 作为一元运算符。
+例如，如果 cards =[1,1,1,1] ，则表达式 “-1 -1 -1 -1” 是 不允许 的。
+你不能把数字串在一起
+例如，如果 cards =[1,2,1,2] ，则表达式 “12 + 12” 无效。
+如果可以得到这样的表达式，其计算结果为 24 ，则返回 true ，否则返回 false 。
+leetcode链接: https://leetcode.com/problems/24-game/
+
+设计位图
+leetcode链接: https://leetcode-cn.com/problems/design-bitset/
+
+给定一个整数数组，返回所有数对之间的第 k 个最小距离
+一对 (A, B) 的距离被定义为 A 和 B 之间的绝对差值
+leetcode链接 : https://leetcode.com/problems/find-k-th-smallest-pair-distance/
+
+从点 (x, y) 可以转换到 (x, x+y)  或者 (x+y, y)。
+给定一个起点 (sx, sy) 和一个终点 (tx, ty)，
+如果通过一系列的转换可以从起点到达终点，
+则返回 True ，否则返回 False。
+leetcode链接 : https://leetcode.com/problems/reaching-points/
+
+Alice 有一个下标从 0 开始的数组 arr ，由 n 个正整数组成。
+她会选择一个任意的 正整数 k 并按下述方式创建两个下标从 0 开始的新整数数组 lower 和 higher ：
+对每个满足 0 <= i < n 的下标 i ，lower[i] = arr[i] - k
+对每个满足 0 <= i < n 的下标 i ，higher[i] = arr[i] + k
+不幸地是，Alice 丢失了全部三个数组。但是，她记住了在数组 lower 和 higher 中出现的整数
+但不知道每个整数属于哪个数组。请你帮助 Alice 还原原数组。
+给你一个由 2n 个整数组成的整数数组 nums ，其中 恰好 n 个整数出现在 lower ，剩下的出现在 higher ，
+还原并返回 原数组 arr 。如果出现答案不唯一的情况，返回 任一 有效数组。
+注意：生成的测试用例保证存在 至少一个 有效数组 arr 。
+leetcode链接 : https://leetcode.com/problems/recover-the-original-array/
+
+
+
+第012节 2022年2月第3周流行算法题目解析
+
+有 n 个城市通过一些航班连接。给你一个数组 flights ，
+其中 flights[i] = [fromi, toi, pricei] ，
+表示该航班都从城市 fromi 开始，以价格 pricei 抵达 toi。
+现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，
+你的任务是找到出一条最多经过 k 站中转的路线，
+使得从 src 到 dst 的 价格最便宜 ，并返回该价格。
+ 如果不存在这样的路线，则输出 -1。
+leetcode链接: https://leetcode.com/problems/cheapest-flights-within-k-stops/
+
+厨房里总共有 n 个橘子，你决定每一天选择如下方式之一吃这些橘子
+1）吃掉一个橘子。
+2）如果剩余橘子数 n 能被 2 整除，那么你可以吃掉 n/2 个橘子。
+3）如果剩余橘子数 n 能被 3 整除，那么你可以吃掉 2*(n/3) 个橘子。
+每天你只能从以上 3 种方案中选择一种方案。
+请你返回吃掉所有 n 个橘子的最少天数。
+leetcode链接: https://leetcode.com/problems/minimum-number-of-days-to-eat-n-oranges/
+
+在无限的平面上，机器人最初位于 (0, 0) 处，面朝北方
+机器人可以接受下列三条指令之一：
+"G"：直走 1 个单位
+"L"：左转 90 度
+"R"：右转 90 度
+机器人按顺序执行指令 instructions，并一直重复它们。
+只有在平面中存在环使得机器人永远无法离开时，返回 true
+否则，返回 false。
+leetcode链接 : https://leetcode.com/problems/robot-bounded-in-circle/
+
+来自微软
+给定一个数组arr，一个正数num，一个正数k
+可以把arr中的某些数字拿出来组成一组
+要求该组中的最大值减去最小值<=num
+且该组数字的个数一定要正好等于k
+每个数字只能选择进某一组，不能进多个组
+返回arr中最多有多少组
+
+Alice 和 Bob 设计了一款新的石子游戏
+现有一行 n 个石子，每个石子都有一个关联的数字表示它的价值
+给你一个整数数组 stones ，其中 stones[i] 是第 i 个石子的价值。
+Alice 和 Bob 轮流进行自己的回合，Alice 先手
+每一回合，玩家需要从 stones 中移除任一石子
+如果玩家移除石子后，导致 所有已移除石子 的价值 总和 可以被 3 整除，那么该玩家就 输掉游戏 。
+如果不满足上一条，且移除后没有任何剩余的石子，那么 Bob 将会直接获胜（即便是在 Alice 的回合）。
+假设两位玩家均采用 最佳 决策。如果 Alice 获胜，返回 true ；如果 Bob 获胜，返回 false 。
+leetcode链接 : https://leetcode.com/problems/stone-game-ix/
+
+
+
+第013节 2022年2月第4周流行算法题目解析
+
+来自微软
+比如，str = "ayxbx"
+有以下4种切法 : a | yxbx、ay | xbx、ayx | bx、ayxb | x
+其中第1、3、4种切法符合：x和y的个数，至少在左右两块中的一块里有相同的数量
+所以返回3
+给定一个字符串str，长度为N
+你有N-1种划分方法，把str切成左右两半，返回有几种切法满足：
+x和y的个数，至少在左右两块中的一块里有相同的数量
+
+来自微软
+给定一个正数num，要返回一个大于num的数，
+并且每一位和相邻位的数字不能相等
+返回达标的数字中，最小的那个
+
+给你一个整数数组 arr
+请你将该数组分隔为长度最多为 k 的一些（连续）子数组
+分隔完成后，每个子数组的中的所有值都会变为该子数组中的最大值。
+返回将数组分隔变换后能够得到的元素最大和
+注意：
+原数组和分隔后的数组对应顺序应当一致，
+也就是说，你只能选择分隔数组的位置而不能调整数组中的顺序。
+leetcode链接 : https://leetcode.com/problems/partition-array-for-maximum-sum/
+
+来自学员贡献
+返回一个数组中，所有降序三元组的数量
+比如 : {5, 3, 4, 2, 1}
+所有降序三元组为 : 
+{5, 3, 2}、{5, 3, 1}、{5, 4, 2}、{5, 4, 1}、{5, 2, 1}、{3, 2, 1}、{4, 2, 1}
+所以返回数量7
+
+给你一个下标从 0 开始的字符串数组 words 。每个字符串都只包含 小写英文字母 
+words 中任意一个子串中，每个字母都至多只出现一次。
+如果通过以下操作之一，我们可以从 s1 的字母集合得到 s2 的字母集合，那么我们称这两个字符串为 关联的 ：
+往 s1 的字母集合中添加一个字母。从 s1 的字母集合中删去一个字母
+将 s1 中的一个字母替换成另外任意一个字母（也可以替换为这个字母本身）。
+数组 words 可以分为一个或者多个无交集的 组 。如果一个字符串与另一个字符串关联，那么它们应当属于同一个组
+你需要确保分好组后，一个组内的任一字符串与其他组的字符串都不关联。可以证明在这个条件下，分组方案是唯一的
+请你返回一个长度为 2 的数组 ans ：
+ans[0] 是 words 分组后的 总组数 。
+ans[1] 是字符串数目最多的组所包含的字符串数目。
+leetcode链接 : https://leetcode.com/problems/groups-of-strings/
+
+
+
+第014节 2022年3月第1周流行算法题目解析
+
+强连通分量的原理
+1，理解什么是dfn序号
+2，理解什么是low序号
+3，理解算法流程中，节点的三种状态：未遍历、遍历了未结算、遍历了已结算
+4，理解什么是scc序号
+
+tarjan(cur)算法求强连通分量流程：
+1，遍历到一个“未遍历”状态的节点cur
+2，给cur节点dfn编号和low编号，初始时low(cur) = dfn(cur) 
+3，将cur标记为“遍历了未结算”状态，并放入栈中
+4，对于cur的每个孩子q，做如下两步操作：
+      1）如果q未遍历，执行tarjen(u)；否则，不执行tarjan(u)
+      2）步骤1)后，q就遍历过了，如果是“遍历未结算”，令low(cur) = min ( low(cur), low(q))；
+                            如果是“已结算”，什么也不做
+5，如果经历完步骤4，依然发现low(cur) = dfn(cur)，
+      说明cur是一个强连通分量的头节点，分配给cur一个scc号，
+      并去结算cur及其cur之下的点(利用栈)
+
+强连通分量代码解析
+
+N个学校之间有单向的网络，每个学校得到一套软件后，
+可以通过单向网络向周边的学校传输
+问题1：
+初始至少需要向多少个学校发放软件，使得网络内所有的学校最终都能得到软件
+问题2：
+至少需要添加几条传输线路(边)，使任意向一个学校发放软件后，
+经过若干次传送，网络内所有的学校最终都能得到软件
+2 <= N <= 1000
+
+A -> B，表示A认为B是红人
+A -> B -> C，表示A认为B是红人，B认为C是红人，
+规定“认为”关系有传递性，所以A也认为C是红人
+给定一张有向图，方式是给定M个有序对(A, B)
+ (A, B)表示A认为B是红人，该关系具有传递性
+给定的有序对中可能包含(A, B)和(B, C)，但不包含(A,C)
+求被其他所有人认为是红人的总数
+
+在一个地图上有若干个炸弹，每个炸弹会呈现十字型引爆
+每个炸弹都有其当量值，这个值决定了这个炸弹的爆炸半径
+如果一个炸弹被引爆时，有其它炸弹在其爆炸半径内，
+那么其它炸弹也会爆炸
+请问使地图上所有炸弹爆炸所需的最少人为引爆次数。
+
+
+
+第015节 2022年3月第2周流行算法题目解析
+
+来自字节飞书团队
+在字节跳动，大家都使用飞书的日历功能进行会议室的预订，遇到会议高峰时期，
+会议室就可能不够用，现在请你实现一个算法，判断预订会议时是否有空的会议室可用。
+为简化问题，这里忽略会议室的大小，认为所有的会议室都是等价的，
+只要空闲就可以容纳任意的会议，并且：
+1. 所有的会议预订都是当日预订当日的时段
+2. 会议时段是一个左闭右开的时间区间，精确到分钟
+3. 每个会议室刚开始都是空闲状态，同一时间一个会议室只能进行一场会议
+4. 会议一旦预订成功就会按时进行
+比如上午11点到中午12点的会议即[660, 720)
+给定一个会议室总数m
+一个预定事件由[a,b,c]代表 : 
+a代表预定动作的发生时间，早来早得; b代表会议的召开时间; c代表会议的结束时间
+给定一个n*3的二维数组，即可表示所有预定事件
+返回一个长度为n的boolean类型的数组，表示每一个预定时间是否成功
+
+来自字节飞书团队
+小歪每次会给你两个字符串：
+笔记s1和关键词s2，请你写一个函数
+判断s2的排列之一是否是s1的子串
+如果是，返回true
+否则，返回false
+
+来自字节飞书团队
+语法补全功能，比如"as soon as possible"
+当我们识别到"as soon as"时, 基本即可判定用户需要键入"possible"
+设计一个统计词频的模型，用于这个功能
+类似(prefix, next word)这样的二元组
+比如一个上面的句子"as soon as possible"
+有产生如下的二元组(as, soon, 1)、(as soon, as, 1)、(as soon as, possible, 1)
+意思是这一个句子产生了如下的统计：
+当前缀为"as"，接下来的单词是"soon"，有了1个期望点
+当前缀为"as soon"，接下来的单词是"as"，有了1个期望点
+当前缀为"as soon as"，接下来的单词是"possible"，有了1个期望点
+那么如果给你很多的句子，当然就可以产生很多的期望点，同一个前缀下，同一个next word的期望点可以累加
+现在给你n个句子，让你来建立统计
+然后给你m个句子，作为查询
+最后给你k，表示每个句子作为前缀的情况下，词频排在前k名的联想
+返回m个结果，每个结果最多k个单词
+
+来自字节飞书团队
+假设数组a和数组b为两组信号
+1) length(b) <= length(a)
+2) 对于任意0<=i<length(b), 有b[i+1] - b[i] == a[i+1] - a[i]
+那么就称信号b和信号a一致，记为b==a
+给你好多b数组，假设有m个: b0数组、b1数组...
+给你好多a数组，假设有n个: a0数组、a1数组...
+返回一个长度为m的结果数组ans，ans[i]表示 : bi数组和多少个a数组一致
+
+来自微软
+给定一个数组arr，给定一个正数M
+如果arr[i] + arr[j]可以被M整除，并且i < j，那么(i,j)叫做一个M整除对
+返回arr中M整除对的总数量
+
+来自微软
+给定一个正数数组arr，长度为N，依次代表N个任务的难度，给定一个正数k
+你只能从0任务开始，依次处理到N-1号任务结束，就是一定要从左往右处理任务
+只不过，难度差距绝对值不超过k的任务，可以在一天之内都完成
+返回完成所有任务的最少天数
+
+来自谷歌
+给定一个数组arr，长度为n
+表示n个服务员，每个人服务一个人的时间
+给定一个正数m，表示有m个人等位
+如果你是刚来的人，请问你需要等多久？
+假设：m远远大于n，比如n<=1000, m <= 10的9次方，该怎么做？
+
+如何时间复杂度O(N)，额外空间复杂度O(1)，解决最低公共祖先问题?
+测试链接 : https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
+
+
+
+第016节 2022年3月第3周流行算法题目解析
+
+来自美团
+给定一个数组arr，你可以随意挑选其中的数字
+但是你挑选的数中，任何两个数a和b，必须Math.abs(a - b) > 1
+返回你最多能挑选几个数
+
+来自美团
+有一块10000 * 10000 * 10000的立方体豆腐
+豆腐的前左下角放在(0,0,0)点，豆腐的后右上角放在(10000,10000,10000)点
+下面给出切法的数据结构
+[a,b]
+a = 1，表示x = b处，一把无穷大的刀平行于yz面贯穿豆腐切过去
+a = 2，表示y = b处，一把无穷大的刀平行于xz面贯穿豆腐切过去
+a = 3，表示z = b处，一把无穷大的刀平行于xy面贯穿豆腐切过去
+a = 1 or 2 or 3，0<=b<=10000
+给定一个n*2的二维数组，表示切了n刀
+返回豆腐中最大的一块体积是多少
+
+来自美团
+最大子段和是
+一个经典问题，即对于一个数组找出其和最大的子数组。
+现在允许你在求解该问题之前翻转这个数組的连续一段
+如翻转(1,2,3,4,5,6)的第三个到第五个元素組成的子数组得到的是(1,2,5,4,3,6)，
+则翻转后该数组的最大子段和最大能达到多少？
+
+来自字节
+和上一题一样的题，来自字节笔试第4题
+给定两个数組values和numbers，
+values[i]表示i号宝石的单品价值
+numbers[i]表示i号宝石的数量
+i号宝石的总价值 = values[i] * numbers[i]
+如果有一种魔法，可以翻转任何区间L...R的宝石，也就是改变L..R的宝石排列，变成逆序的
+求在允许用一次魔法的情况下，任取一段连续区间，能达到的最大价值
+这两个问法解法都几乎一样，区别无非是:
+上一题美团的问题: 可进行一次翻转情况下，子数组最大累加和
+这一题字节的问题: 可进行一次翻转情况下，子数组最大价值和
+
+来自美团
+void add(int L, int R, int C)代表在arr[L...R]上每个数加C
+int get(int L, int R)代表查询arr[L...R]上的累加和
+假设你可以在所有操作开始之前，重新排列arr
+请返回每一次get查询的结果都加在一起最大能是多少
+输入参数:
+int[] arr : 原始数组
+int[][] ops，二维数组每一行解释如下:
+[a,b,c]，如果数组有3个数，表示调用add(a,b,c)
+[a,b]，如果数组有2个数，表示调用get(a,b)
+a和b表示arr范围，范围假设从1开始，不从0开始
+输出：假设你可以在开始时重新排列arr，返回所有get操作返回值累计和最大是多少？
+
+来自bilibili
+现在有N条鱼，每条鱼的体积为Ai，从左到右排列，数组arr给出
+每一轮，左边的大鱼一定会吃掉右边比自己小的第一条鱼，
+并且每条鱼吃比自己小的鱼的事件是同时发生的。
+返回多少轮之后，鱼的数量会稳定
+注意：6 6 3 3
+第一轮过后 : 
+对于两个6来说，右边比自己小的第一条鱼都是第1个3，所以只有这个3被吃掉，
+数组变成 : 6 6 3（第2个3）
+第二轮过后 : 6 6
+返回2
+
+来自银联编程比赛
+某公司计划推出一批投资项目。 product[i] = price 表示第 i 个理财项目的投资金额 price 。
+客户在按需投资时，需要遵循以下规则：
+客户在首次对项目 product[i] 投资时，需要投入金额 price
+对已完成首次投资的项目 product[i] 可继续追加投入，
+但追加投入的金额需小于上一次对该项目的投入(追加投入为大于 0 的整数)
+为控制市场稳定，每人交易次数不得大于 limit。(首次投资和追加投入均记作 1 次交易)
+若对所有理财项目中最多进行 limit 次交易，使得投入金额总和最大，请返回这个最大值的总和。
+测试链接 : https://leetcode-cn.com/contest/cnunionpay-2022spring/problems/I4mOGz/
+
+来自银联编程比赛
+为了不断提高用户使用的体验，开发团队正在对产品进行全方位的开发和优化。
+已知开发团队共有若干名成员，skills[i] 表示第 i 名开发人员掌握技能列表。
+如果两名成员各自拥有至少一门对方未拥有的技能，则这两名成员可以「合作开发」。
+请返回当前有多少对开发成员满足「合作开发」的条件。
+由于答案可能很大，请你返回答案对 10^9 + 7 取余的结果。
+测试链接 : https://leetcode-cn.com/contest/cnunionpay-2022spring/problems/lCh58I/
+
+
+
+第017节 2022年3月第4周流行算法题目解析
+
+来自学员的考试
+来自华为
+给定一个n*2的二维数组，表示有n个任务
+一个信息是任务能够开始做的时间，另一个信息是任务的结束期限，后者一定大于前者，且数值上都是正数
+你作为单线程的人，不能并行处理任务，但是每个任务都只需要一个单位时间完成
+你需要将所有任务的执行时间，位于开始做的时间和最后期限之间
+返回你能否做到这一点
+
+来自字节内部训练营
+某公司游戏平台的夏季特惠开始了，你决定入手一些游戏。现在你一共有X元的预算。
+该平台上所有的 n 个游戏均有折扣，标号为 i 的游戏的原价a_i元，现价只要b_i元
+也就是说该游戏可以优惠 a_i - b_i，并且你购买该游戏能获得快乐值为 w_i
+由于优惠的存在，你可能做出一些冲动消费导致最终买游戏的总费用超过预算，
+只要满足 : 获得的总优惠金额不低于超过预算的总金额
+那在心理上就不会觉得吃亏。
+现在你希望在心理上不觉得吃亏的前提下，获得尽可能多的快乐值。
+测试链接 : https://leetcode-cn.com/problems/tJau2o/
+
+来自学员问题
+给定一个数组arr，可能有正、有负、有0，无序
+只能挑选两个数字，想尽量让两个数字加起来的绝对值尽量小
+返回可能的最小的值
+
+来自字节
+一开始在0位置，每一次都可以向左或者向右跳
+第i次能向左或者向右跳严格的i步
+请问从0到x位置，至少跳几次可以到达
+字节考的问题其实就是这个问题
+leetcode测试链接 : https://leetcode.com/problems/reach-a-number/
+
+来自理想汽车
+a -> b，代表a在食物链中被b捕食
+给定一个有向无环图，返回
+这个图中从最初级动物到最顶级捕食者的食物链有几条
+线上测试链接 : https://www.luogu.com.cn/problem/P4017
+
+来自学员问题
+给定一个数字n，表示一开始有编号1~n的树木，列成一条直线
+给定一个有序数组arr，表示现在哪些树已经没了，arr[i]一定在[1,n]范围
+给定一个数字m，表示你可以补种多少棵树
+返回补种之后，最长的连续树木，有多少棵
+
+来自网易
+不规则数独问题
+3*3填数独
+每一行要填1~3
+每一列要填1~3
+3*3的区域会拆分成不规则的三个集团区域
+每个集团区域3个格子
+每个集团的区域都一定是一个连在一起的整体，可能不规则
+每个集团内要填1~3
+如果只有一个解返回"Unique"，如果有多个解返回"Multiple"，如果没有解返回"No"
+解析请看，大厂刷题班，28节，leetcode原题，数独那两个题
+本题就是改变一下桶的归属而已
+
+来自学员问题
+大妈一开始手上有x个鸡蛋，她想让手上的鸡蛋数量变成y
+操作1 : 从仓库里拿出1个鸡蛋到手上，x变成x+1个
+操作2 : 如果手上的鸡蛋数量是3的整数倍，大妈可以直接把三分之二的鸡蛋放回仓库，手里留下三分之一
+返回从x到y的最小操作次数
+1 <= x,y <= 10^18
+练一下，用平凡解做限制
+
+
+
+第018节 2022年3月第5周流行算法题目解析
+
+km算法流程详解、代码实现
+
+来自微软
+在N*N的正方形棋盘中，有N*N个棋子，那么每个格子正好可以拥有一个棋子
+但是现在有些棋子聚集到一个格子上了，比如：
+2 0 3
+0 1 0
+3 0 0
+如上的二维数组代表，一共3*3个格子
+但是有些格子有2个棋子、有些有3个、有些有1个、有些没有
+请你用棋子移动的方式，让每个格子都有一个棋子
+每个棋子可以上、下、左、右移动，每移动一步算1的代价
+返回最小的代价
+
+给你一个长度为 n 的整数数组 nums 和一个整数 numSlots ，满足2 * numSlots >= n
+总共有 numSlots 个篮子，编号为 1 到 numSlots
+你需要把所有 n 个整数分到这些篮子中，且每个篮子 至多 有 2 个整数
+一种分配方案的 与和 定义为每个数与它所在篮子编号的 按位与运算 结果之和。
+比方说，将数字 [1, 3] 放入篮子 1 中，[4, 6] 放入篮子 2 中，
+这个方案的与和为 (1 AND 1) + (3 AND 1) + (4 AND 2) + (6 AND 2) = 1 + 1 + 0 + 2 = 4 。
+请你返回将 nums 中所有数放入 numSlots 个篮子中的最大与和。
+Leetcode链接：https://leetcode.com/problems/maximum-and-sum-of-array
+
+来自网易
+我军一起干掉敌人的最少移动数
+km算法的又一个题
+给定一个矩阵int[][] matrix
+matrix[i][j] == -2，代表此处(i,j)有山脉，无法通行
+matrix[i][j] == -1，代表此处(i,j)是一个敌军
+matrix[i][j] == 0，代表此处(i,j)是空地，可以自由行动
+matrix[i][j] > 0，代表此处(i,j)是一个我军，行动能力就是matrix[i][j]
+我军只能上、下、左、右移动，只可以穿过同样是我军的地点和空地的地点，但是最多移动matrix[i][j]步
+任何一个我军都不能穿过山脉，任何一个我军可以来到敌军的位置，表示消灭了敌军，但是如果这么做了，这个我军就不能再移动了
+你可以任意决定所有我军的行动策略，每一步你都可以随意选择一个友军移动随意方向的，但是必须合法。
+如果你可以让所有我军在消耗完自身的行动能力之前，消灭所有的敌军，请返回总距离的最小值
+如果你就是无法消灭所有敌军，返回-1
+
+
+
+第019节 2022年4月第1周流行算法题目解析
+
+来自阿里笔试
+牛牛今年上幼儿园了，老师叫他学习减法
+老师给了他5个数字，他每次操作可以选择其中的4个数字减1
+减一之后的数字不能小于0，因为幼儿园的牛牛还没有接触过负数
+现在牛牛想知道，自己最多可以进行多少次这样的操作
+扩展问题来自leetcode 2141，掌握了这个题原始问题就非常简单了
+leetcode测试链接 : https://leetcode.com/problems/maximum-running-time-of-n-computers/
+
+来自学员问题
+找到非负数组中拥有"最大或的结果"的最短子数组
+
+来自通维数码
+每个会议给定开始和结束时间
+后面的会议如果跟前面的会议有任何冲突，完全取消冲突的、之前的会议，安排当前的
+给定一个会议数组，返回安排的会议列表
+
+来自小红书
+小红书第一题：
+薯队长从北向南穿过一片红薯地（南北长M，东西宽N），红薯地被划分为1x1的方格，
+他可以从北边的任何一个格子出发，到达南边的任何一个格子，
+但每一步只能走到东南、正南、西南方向的三个格子之一，
+而且不能跨出红薯地，他可以获得经过的格子上的所有红薯，请问他可以获得最多的红薯个数。
+
+来自小红书
+小红书第二题：
+薯队长最近在参加了一个活动，主办方提供了N个礼物以供挑选，
+每个礼物有一个价值，范围在0 ~ 10^9之间，
+薯队长可以从中挑选k个礼物
+返回：其中价值最接近的两件礼物之间相差值尽可能大的结果
+
+来自小红书
+小红书第三题：
+薯队长最近在玩一个游戏，这个游戏桌上会有一排不同颜色的方块，
+每次薯队长可以选择一个方块，便可以消除这个方块以及和他左右相临的
+若干的颜色相同的方块，而每次消除的方块越多，得分越高。
+具体来说，桌上有以个方块排成一排 (1 <= N <= 200），
+每个方块有一个颜色，用1~N之间的一个整数表示，相同的数宇代表相同的颜色，
+每次消除的时候，会把连续的K个相同颜色的方块消除，并得到K*K的分数，
+直到所有方块都消除。显然，不同的消除顺序得分不同，薯队长希望您能告诉他，这个游戏最多能得到多少分
+体系学习班，代码46节，视频在47节，消箱子原题，RemoveBoxes
+
+给定一个数组arr，含有n个数字，都是非负数
+给定一个正数k
+返回所有子序列中，累加和最小的前k个子序列累加和
+假设K不大，怎么算最快？
+
+来自Amazon
+给定一个数组arr，含有n个数字，可能有正、有负、有0
+给定一个正数k
+返回所有子序列中，累加和最大的前k个子序列累加和
+假设K不大，怎么算最快？
+
+
+
+第020节 2022年4月第2周流行算法题目解析
+
+来自携程
+给出n个数字，你可以任选其中一些数字相乘，相乘之后得到的新数字x
+x的价值是x的不同质因子的数量
+返回所有选择数字的方案中，得到的x的价值之和
+
+来自网易
+3.27笔试
+一个二维矩阵，上面只有 0 和 1，只能上下左右移动
+如果移动前后的元素值相同，则耗费 1 ，否则耗费 2。
+问从左上到右下的最小耗费
+
+来自美团
+3.26笔试
+给定一个非负数组，任意选择数字，使累加和最大且为7的倍数，返回最大累加和
+n比较大，10的5次方
+
+来自美团
+3.26笔试
+给定一个正数n, 表示有0~n-1号任务
+给定一个长度为n的数组time，time[i]表示i号任务做完的时间
+给定一个二维数组matrix
+matrix[j] = {a, b} 代表：a任务想要开始，依赖b任务的完成
+只要能并行的任务都可以并行，但是任何任务只有依赖的任务完成，才能开始
+返回一个长度为n的数组ans，表示每个任务完成的时间
+输入可以保证没有循环依赖
+
+来自百度
+给出一个长度为n的01串，现在请你找到两个区间，
+使得这两个区间中，1的个数相等，0的个数也相等
+这两个区间可以相交，但是不可以完全重叠，即两个区间的左右端点不可以完全一样
+现在请你找到两个最长的区间，满足以上要求。
+
+来自阿里
+x = { a, b, c, d }
+y = { e, f, g, h }
+x、y两个小数组长度都是4
+如果有: a + e = b + f = c + g = d + h
+那么说x和y是一个完美对
+题目给定N个小数组，每个小数组长度都是K
+返回这N个小数组中，有多少完美对
+
+来自快手
+某公司年会上，大家要玩一食发奖金游戏，一共有n个员工，
+每个员工都有建设积分和捣乱积分
+他们需要排成一队，在队伍最前面的一定是老板，老板也有建设积分和捣乱积分
+排好队后，所有员工都会获得各自的奖金，
+该员工奖金 = 排在他前面所有人的建设积分乘积 / 该员工自己的捣乱积分，向下取整
+为了公平(放屁)，老板希望 : 让获得奖金最高的员工，所获得的奖金尽可能少
+所以想请你帮他重新排一下队伍，返回奖金最高的员工获得的、尽可能少的奖金数额
+1 <= n <= 1000, 1<= 积分 <= 10000;
+
+
+
+第021节 2022年4月第3周流行算法题目解析
+
+来自小红书
+3.13 笔试
+数组里有0和1，一定要翻转一个区间，翻转：0变1，1变0
+请问翻转后可以使得1的个数最多是多少？
+
+来自小红书
+3.13 笔试
+给定一个数组，想随时查询任何范围上的最大值
+如果只是根据初始数组建立、并且以后没有修改，
+那么RMQ方法比线段树方法好实现，时间复杂度O(N*logN)，额外空间复杂度O(N*logN)
+
+来自腾讯音乐
+原本数组中都是大于0、小于等于k的数字，是一个单调不减的数组
+其中可能有相等的数字，总体趋势是递增的
+但是其中有些位置的数被替换成了0，我们需要求出所有的把0替换的方案数量：
+1) 填充的每一个数可以大于等于前一个数，小于等于后一个数
+2) 填充的每一个数不能大于k
+
+来自学员问题
+总长度为n的数组中，所有长度为k的子序列里，有多少子序列的和为偶数
+
+来自微众
+4.11笔试
+给定n位长的数字字符串和正数k，求该子符串能被k整除的子串个数
+(n<=1000，k<=100)
+
+
+
+第022节 2022年5月第1周流行算法题目解析
+
+来自蔚来汽车
+给你一个整数数组 arr ，你一开始在数组的第一个元素处（下标为 0）。
+每一步，你可以从下标 i 跳到下标 i + 1 、i - 1 或者 j ：
+i + 1 需满足：i + 1 < arr.length
+i - 1 需满足：i - 1 >= 0
+j 需满足：arr[i] == arr[j] 且 i != j
+请你返回到达数组最后一个元素的下标处所需的 最少操作次数 。
+注意：任何时候你都不能跳到数组外面。
+leetcode测试链接 : https://leetcode-cn.com/problems/jump-game-iv/
+
+来自微众
+人工智能岗
+一开始有21个球，甲和乙轮流拿球，甲先、乙后
+每个人在自己的回合，一定要拿不超过3个球，不能不拿
+最终谁的总球数为偶数，谁赢
+请问谁有必胜策略
+
+来自学员问题，真实大厂面试题
+1、2、3...n-1、n、n、n+1、n+2...
+在这个序列中，只有一个数字有重复(n)
+这个序列是无序的，找到重复数字n
+这个序列是有序的，找到重复数字n
+
+来自学员问题，蓝桥杯练习题
+f(i) : i的所有因子，每个因子都平方之后，累加起来
+比如f(10) = 1平方 + 2平方 + 5平方 + 10平方 = 1 + 4 + 25 + 100 = 130
+给定一个数n，求f(1) + f(2) + .. + f(n)
+n <= 10的9次方
+
+来自optiver
+给定一个字符串str，和一个正数k
+你可以随意的划分str成多个子串，
+目的是找到在某一种划分方案中，有尽可能多的回文子串，长度>=k，并且没有重合
+返回有几个回文子串
+
+
+
+第023节 2022年5月第2周流行算法题目解析
+
+来自字节
+5.6笔试
+给定N件物品，每个物品有重量(w[i])、有价值(v[i])
+只能最多选两件商品，重量不超过bag，返回价值最大能是多少？
+N <= 10^5, w[i] <= 10^5, v[i] <= 10^5, bag <= 10^5
+本题的关键点：什么数据范围都很大，唯独只需要最多选两件商品，这个可以利用一下
+
+来自网易
+小红拿到了一个长度为N的数组arr，她准备只进行一次修改
+可以将数组中任意一个数arr[i]，修改为不大于P的正数（修改后的数必须和原数不同)
+并使得所有数之和为X的倍数
+小红想知道，一共有多少种不同的修改方案
+1 <= N, X <= 10^5, 1 <= arr[i], P <= 10^9
+
+来自字节
+一共有n个人，从左到右排列，依次编号0~n-1
+h[i]是第i个人的身高
+v[i]是第i个人的分数
+要求从左到右选出一个子序列，在这个子序列中的人，从左到右身高是不下降的
+返回所有符合要求的子序列中，分数最大累加和是多大
+n <= 10的5次方, 1 <= h[i] <= 10的9次方, 1 <= v[i] <= 10的9次方
+
+来自网易
+给出一个有n个点，m条有向边的图
+你可以施展魔法，把有向边，变成无向边
+比如A到B的有向边，权重为7。施展魔法之后，A和B通过该边到达彼此的代价都是7。
+求，允许施展一次魔法的情况下，1到n的最短路，如果不能到达，输出-1。
+n为点数, 每条边用(a,b,v)表示，含义是a到b的这条边，权值为v
+点的数量 <= 10^5，边的数量 <= 2 * 10^5，1 <= 边的权值 <= 10^6
+
+来自网易
+小红拿到了一个大立方体，该大立方体由1*1*1的小方块拼成，初始每个小方块都是白色。
+小红可以每次选择一个小方块染成红色
+每次小红可能选择同一个小方块重复染色
+每次染色以后，你需要帮小红回答出当前的白色连通块数
+如果两个小方块共用同一个面，且颜色相同，则它们是连通的
+给定n、m、h，表示大立方体的长、宽、高
+给定k次操作，每一次操作用(a, b, c)表示在大立方体的该位置进行染色
+返回长度为k的数组，表示每一次操作后，白色方块的连通块数
+n * m * h <= 10 ^ 5，k <= 10 ^ 5
+
+
+
+第024节 2022年5月第3周流行算法题目解析
+
+来自字节
+输入:
+去重数组arr，里面的数只包含0~9
+limit，一个数字
+返回:
+要求比limit小的情况下，能够用arr拼出来的最大数字
+
+来自京东
+4.2笔试
+给定一个数组arr，长度为N，arr中所有的值都在1~K范围上
+你可以删除数字，目的是让arr的最长递增子序列长度小于K
+返回至少删除几个数字能达到目的
+N <= 10^4，K <= 10^2
+
+来自学员问题
+给定一个数组arr，表示从早到晚，依次会出现的导弹的高度
+大炮打导弹的时候，如果一旦大炮定了某个高度去打，那么这个大炮每次打的高度都必须下降一点
+1) 如果只有一个大炮，返回最多能拦截多少导弹
+2) 如果所有的导弹都必须拦截，返回最少的大炮数量
+
+来自学员问题
+为了给刷题的同学一些奖励，力扣团队引入了一个弹簧游戏机
+游戏机由 N 个特殊弹簧排成一排，编号为 0 到 N-1
+初始有一个小球在编号 0 的弹簧处。若小球在编号为 i 的弹簧处
+通过按动弹簧，可以选择把小球向右弹射 jump[i] 的距离，或者向左弹射到任意左侧弹簧的位置
+也就是说，在编号为 i 弹簧处按动弹簧，
+小球可以弹向 0 到 i-1 中任意弹簧或者 i+jump[i] 的弹簧（若 i+jump[i]>=N ，则表示小球弹出了机器）
+小球位于编号 0 处的弹簧时不能再向左弹。
+为了获得奖励，你需要将小球弹出机器。
+请求出最少需要按动多少次弹簧，可以将小球从编号 0 弹簧弹出整个机器，即向右越过编号 N-1 的弹簧。
+测试链接 : https://leetcode-cn.com/problems/zui-xiao-tiao-yue-ci-shu/
+
+
+
+第025节 2022年5月第4周流行算法题目解析
+
+每一个方案都有两个值(a,b)，a为娱乐值，b为进攻值
+给定很多的方案数组，给定娱乐值总目标(int)，给定进攻值总目标(int)
+要求选一些方案，这些方案的总娱乐值>=娱乐值总目标，总进攻值>=进攻值总目标
+返回至少需要选几个方案
+
+给定绳子总长度为M，每一个长度的绳子对应一个价格，比如(6, 10)表示剪成长度为6的绳子，对应价格10
+可以重复切出某个长度的绳子，返回总长度为M的情况下，能得到的最大价值
+
+每一个序列都是[a,b]的形式，a < b
+序列连接的方式为，前一个序列的b，要等于后一个序列的a
+比如 : [3, 7]、[7, 13]、[13, 26]这三个序列就可以依次连接
+给定若干个序列，求最大连接的数量
+
+给定区间的范围[xi,yi]，xi<=yi，且都是正整数
+找出一个坐标集合set，set中有若干个数字
+set要和每个给定的区间，有交集
+求set的最少需要几个数
+比如给定区间 : [5, 8] [1, 7] [2, 4] [1, 9]
+set最小可以是: {2, 6}或者{2, 5}或者{4, 5}
+
+来自字节
+5.6笔试
+给定一个数组arr，长度为n，最多可以删除一个连续子数组，
+求剩下的数组，严格连续递增的子数组最大长度
+n <= 10^6
+
+来自京东
+4.2笔试
+给定一个长度为3N的数组，其中最多含有0、1、2三种值
+你可以把任何一个连续区间上的数组，全变成0、1、2中的一种
+目的是让0、1、2三种数字的个数都是N
+返回最小的变化次数
+
+
+
+第026节 2022年6月第1周流行算法题目解析
+
+最好打开链接看图
+用一个大小为 m x n 的二维网格 grid 表示一个箱子
+你有 n 颗球。箱子的顶部和底部都是开着的。
+箱子中的每个单元格都有一个对角线挡板，跨过单元格的两个角，
+可以将球导向左侧或者右侧。
+将球导向右侧的挡板跨过左上角和右下角，在网格中用 1 表示。
+将球导向左侧的挡板跨过右上角和左下角，在网格中用 -1 表示。
+在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。
+如果球恰好卡在两块挡板之间的 "V" 形图案，或者被一块挡导向到箱子的任意一侧边上，就会卡住。
+返回一个大小为 n 的数组 answer ，
+其中 answer[i] 是球放在顶部的第 i 列后从底部掉出来的那一列对应的下标，
+如果球卡在盒子里，则返回 -1
+本题测试链接 : https://leetcode.com/problems/where-will-the-ball-fall/
+
+把字符串 s 看作 "abcdefghijklmnopqrstuvwxyz" 的无限环绕字符串，
+所以 s 看起来是这样的：
+...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd....
+现在给定另一个字符串 p 。返回 s 中 不同 的 p 的 非空子串 的数量
+测试链接 : https://leetcode.com/problems/unique-substrings-in-wraparound-string/
+
+给你一个字符串化学式 formula ，返回 每种原子的数量 。
+原子总是以一个大写字母开始，接着跟随 0 个或任意个小写字母，表示原子的名字。
+如果数量大于 1，原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。
+例如，"H2O" 和 "H2O2" 是可行的，但 "H1O2" 这个表达是不可行的。
+两个化学式连在一起可以构成新的化学式。
+例如 "H2O2He3Mg4" 也是化学式。
+由括号括起的化学式并佐以数字（可选择性添加）也是化学式。
+例如 "(H2O2)" 和 "(H2O2)3" 是化学式。
+返回所有原子的数量，格式为：第一个（按字典序）原子的名字，跟着它的数量（如果数量大于 1），
+然后是第二个原子的名字（按字典序），跟着它的数量（如果数量大于 1），以此类推。
+示例 1：
+输入：formula = "H2O"
+输出："H2O"
+解释：原子的数量是 {'H': 2, 'O': 1}。
+示例 2：
+输入：formula = "Mg(OH)2"
+输出："H2MgO2"
+解释：原子的数量是 {'H': 2, 'Mg': 1, 'O': 2}。
+示例 3：
+输入：formula = "K4(ON(SO3)2)2"
+输出："K4N2O14S4"
+解释：原子的数量是 {'K': 4, 'N': 2, 'O': 14, 'S': 4}。
+测试链接 : https://leetcode.com/problems/number-of-atoms/
+
+字符串的 波动 定义为子字符串中出现次数 最多 的字符次数与出现次数 最少 的字符次数之差。
+给你一个字符串 s ，它只包含小写英文字母。请你返回 s 里所有 子字符串的 最大波动 值。
+子字符串 是一个字符串的一段连续字符序列。
+注意：必须同时有，最多字符和最少字符的字符串才是有效的
+测试链接 : https://leetcode.cn/problems/substring-with-largest-variance/
+
+
+
+第027节 2022年6月第2周流行算法题目解析
+
+n块石头放置在二维平面中的一些整数坐标点上
+每个坐标点上最多只能有一块石头
+如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。
+给你一个长度为 n 的数组 stones ，
+其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，
+返回 可以移除的石子 的最大数量。
+测试链接 : https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/
+
+作为国王的统治者，你有一支巫师军队听你指挥。
+给你一个下标从 0 开始的整数数组 strength ，
+其中 strength[i] 表示第 i 位巫师的力量值。
+对于连续的一组巫师（也就是这些巫师的力量值是 strength 的 子数组），
+总力量 定义为以下两个值的 乘积 ：
+巫师中 最弱 的能力值 * 组中所有巫师的个人力量值 之和 。
+请你返回 所有 巫师组的 总 力量之和。由于答案可能很大，请将答案对 109 + 7 取余 后返回。
+子数组 是一个数组里 非空 连续子序列。
+测试链接 : https://leetcode.cn/problems/sum-of-total-strength-of-wizards/
+
+给你一个由正整数组成的数组 nums 。
+数字序列的 最大公约数 定义为序列中所有整数的共有约数中的最大整数。
+例如，序列 [4,6,16] 的最大公约数是 2 。
+数组的一个 子序列 本质是一个序列，可以通过删除数组中的某些元素（或者不删除）得到。
+例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
+计算并返回 nums 的所有 非空 子序列中 不同 最大公约数的 数目 。
+测试链接 : https://leetcode.com/problems/number-of-different-subsequences-gcds/
+
+给定一个正整数 n，返回 连续正整数满足所有数字之和为 n 的组数 。 
+示例 1: 输入: n = 5 输出: 2
+解释: 5 = 2 + 3，共有两组连续整数([5],[2,3])求和后为 5。
+示例 2: 输入: n = 9 输出: 3
+解释: 9 = 4 + 5 = 2 + 3 + 4
+示例 3: 输入: n = 15 输出: 4
+解释: 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
+测试链接 : https://leetcode.com/problems/consecutive-numbers-sum/
+
+
+
+第028节 2022年6月第3周流行算法题目解析
+
+arr是一个可能包含重复元素的整数数组，我们将这个数组分割成几个“块”，
+并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。
+我们最多能将数组分成多少块？
+示例 1: 输入: arr = [5,4,3,2,1] 输出: 1
+解释:
+将数组分成2块或者更多块，都无法得到所需的结果。
+例如，分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3]，这不是有序的数组。 
+示例 2: 输入: arr = [2,1,3,4,4] 输出: 4
+解释:
+我们可以把它分成两块，例如 [2, 1], [3, 4, 4]。
+然而分成 [2, 1], [3], [4], [4] 可以得到最多的块数。 
+测试链接 : https://leetcode.com/problems/max-chunks-to-make-sorted-ii/
+
+给你两个整数 m 和 n ，分别表示一块矩形木块的高和宽。
+同时给你一个二维整数数组 prices ，其中 prices[i] = [hi, wi, pricei] 
+表示你可以以 pricei 元的价格卖一块高为 hi 宽为 wi 的矩形木块。
+每一次操作中，你必须按下述方式之一执行切割操作，以得到两块更小的矩形木块：
+沿垂直方向按高度 完全 切割木块，或
+沿水平方向按宽度 完全 切割木块
+在将一块木块切成若干小木块后，你可以根据 prices 卖木块。
+你可以卖多块同样尺寸的木块。
+你不需要将所有小木块都卖出去。
+你 不能 旋转切好后木块的高和宽。
+请你返回切割一块大小为 m x n 的木块后，能得到的 最多 钱数。
+注意你可以切割木块任意次。
+测试链接 : https://leetcode.cn/problems/selling-pieces-of-wood/
+
+Range模块是跟踪数字范围的模块。
+设计一个数据结构来跟踪表示为 半开区间 的范围并查询它们。
+半开区间 [left, right) 表示所有 left <= x < right 的实数 x 。
+实现 RangeModule 类:
+RangeModule() 初始化数据结构的对象
+void addRange(int left, int right) : 
+添加 半开区间 [left, right)，跟踪该区间中的每个实数。
+添加与当前跟踪的数字部分重叠的区间时，
+应当添加在区间 [left, right) 中尚未跟踪的任何数字到该区间中。
+boolean queryRange(int left, int right) : 
+只有在当前正在跟踪区间 [left, right) 中的每一个实数时，才返回 true
+否则返回 false 。
+void removeRange(int left, int right) : 
+停止跟踪 半开区间 [left, right) 中当前正在跟踪的每个实数。
+测试连接 : https://leetcode.com/problems/range-module/
+
+一个字符串s，表示仓库的墙 与 货物，其中'|'表示墙,'*'表示货物。
+给定一个起始下标start和一个终止下标end，
+找出子串中 被墙包裹的货物 数量
+比如
+s = "|**|**|*"
+start = 1, end = 7
+start和end截出的子串是 "**|**|*"
+被 '|'包裹的 '*' 有两个，所以返回2
+现在给定一系列的start，startIndices[]，和对应一系列的end ,endIndices[]
+返回每一对[start,end]的截出来的货物数量
+数据规模：
+字符串s长度<=10^5
+startIndices长度 == endIndices长度 <=10^5
+
+
+
+第029节 2022年6月第4周流行算法题目解析
+
+给定字符串 S and T，找出 S 中最短的（连续）子串 W ，使得 T 是 W 的 子序列 。
+如果 S 中没有窗口可以包含 T 中的所有字符，返回空字符串 ""。
+如果有不止一个最短长度的窗口，返回开始位置最靠左的那个。
+示例 1：
+输入：
+S = "abcdebdde", T = "bde"
+输出："bcde"
+解释：
+"bcde" 是答案，因为它在相同长度的字符串 "bdde" 出现之前。
+"deb" 不是一个更短的答案，因为在窗口中必须按顺序出现 T 中的元素。
+测试链接 : https://leetcode.cn/problems/minimum-window-subsequence/
+
+来自微软
+请设计一种叫做“栈的管理器”的结构，实现如下6个功能
+1) void createNewStack() : 可以在该结构中生成一个栈结构，编号从0开始
+2) void push(int num, int stackIndex) : 将编号为stackIndex的栈里，压入num
+3) int pop(int stackIndex) : 从编号为stackIndex的栈里，弹出栈顶返回
+4) int peek(int stackIndex) ：从编号为stackIndex的栈里，返回栈顶但是不弹出
+5) boolean isEmpty(int statckIndex)：返回编号为stackIndex的栈是否为空
+6) int stackSize() : 返回一共生成了多少个栈
+要求：不管用户调用多少次上面的方法，只使用有限几个动态数组(常数个)，完成代码实现
+
+有n个动物重量分别是a1、a2、a3.....an，
+这群动物一起玩叠罗汉游戏，
+规定从左往右选择动物，每只动物左边动物的总重量不能超过自己的重量
+返回最多能选多少个动物，求一个高效的算法。
+比如有7个动物，从左往右重量依次为：1，3，5，7，9，11，21
+则最多能选5个动物：1，3，5，9，21
+注意本题给的例子是有序的，但是实际给定的动物数组，可能是无序的，
+要求从左往右选动物，且不能打乱原始数组
+
+整数数组 stations 表示 水平数轴 上各个加油站的位置。给你一个整数 k 。
+请你在数轴上增设 k 个加油站，
+新增加油站可以位于 水平数轴 上的任意位置，而不必放在整数位置上。
+设 penalty() 是：增设 k 个新加油站后，相邻 两个加油站间的最大距离。
+请你返回 penalty() 可能的最小值。与实际答案误差在 10-6 范围内的答案将被视作正确答案。
+测试链接 : https://leetcode.cn/problems/minimize-max-distance-to-gas-station/
+
+
+
+第030节 2022年7月第1周流行算法题目解析
+
+来自真实笔试
+给定一个二维数组matrix，数组中的每个元素代表一棵树的高度。
+你可以选定连续的若干行组成防风带，防风带每一列的防风高度为这一列的最大值
+防风带整体的防风高度为，所有列防风高度的最小值。
+比如，假设选定如下三行
+1 5 4
+7 2 6
+2 3 4
+1、7、2的列，防风高度为7
+5、2、3的列，防风高度为5
+4、6、4的列，防风高度为6
+防风带整体的防风高度为5，是7、5、6中的最小值
+给定一个正数k，k <= matrix的行数，表示可以取连续的k行，这k行一起防风。
+求防风带整体的防风高度最大值
+
+给定一个棵树
+树上每个节点都有自己的值，记录在数组nums里
+比如nums[4] = 10，表示4号点的值是10
+给定树上的每一条边，记录在二维数组edges里
+比如edges[8] = {4, 9}表示4和9之间有一条无向边
+可以保证输入一定是一棵树，只不过边是无向边
+那么我们知道，断掉任意两条边，都可以把整棵树分成3个部分。
+假设是三个部分为a、b、c
+a部分的值是：a部分所有点的值异或起来
+b部分的值是：b部分所有点的值异或起来
+c部分的值是：c部分所有点的值异或起来
+请问怎么分割，能让最终的：三个部分中最大的异或值 - 三个部分中最小的异或值，最小
+返回这个最小的差值
+测试链接 : https://leetcode.cn/problems/minimum-score-after-removals-on-a-tree/
+
+在第 1 天，有一个人发现了一个秘密。
+给你一个整数 delay ，表示每个人会在发现秘密后的 delay 天之后，
+每天 给一个新的人 分享 秘密。
+同时给你一个整数 forget ，表示每个人在发现秘密 forget 天之后会 忘记 这个秘密。
+一个人 不能 在忘记秘密那一天及之后的日子里分享秘密。
+给你一个整数 n ，请你返回在第 n 天结束时，知道秘密的人数。
+由于答案可能会很大，请你将结果对 10^9 + 7 取余 后返回。
+测试链接 : https://leetcode.cn/problems/number-of-people-aware-of-a-secret/
+
+
+
+第031节 2022年7月第2周流行算法题目解析
+
+给定一个字符串 s，计算 s 的 不同非空子序列 的个数
+因为结果可能很大，所以返回答案需要对 10^9 + 7 取余 。
+字符串的 子序列 是经由原字符串删除一些（也可能不删除）字符
+但不改变剩余字符相对位置的一个新字符串。
+本题来自大厂刷题班17节
+但是为了讲述一个最新题目，不得不重提这个题
+本题测试链接 : https://leetcode.com/problems/distinct-subsequences-ii/
+
+来自SnowFlake
+给定一个正数n，比如6
+表示数轴上有 0,1,2,3,4,5,6
+<0 或者 >6 的位置认为无法到达
+给定两个数字x和y，0<= x，y <= n
+表示小人一开始在x的位置，它的目的地是y的位置，比如x = 1, y = 3
+给定一个字符串s，比如 : rrlrlr
+任何一个s的子序列，对应着一种运动轨迹，r表示向右，l表示向左
+比如一开始小人在1位置，"rlr"是s的一个子序列
+那么运动轨迹是：1 -> 2 -> 1 -> 2
+求，s中有多少个字面值不同的子序列，能让小人从x走到y，
+走的过程中完全不走出0到n的区域。
+比如，s = "rrlrlr", n = 6, x = 1, y = 3
+有如下5个字面值不同的子序列
+rr : 1 -> 2 -> 3
+rrlr : 1 -> 2 -> 3 -> 2 -> 3
+rrrl : 1 -> 2 -> 3 -> 4 -> 3
+rlrr : 1 -> 2 -> 1 -> 2 -> 3
+rrlrlr : 1 -> 2 -> 3 -> 2 -> 3 -> 2 -> 3
+注意：一定要是字面值不同的子序列！相同字面值的子序列算一种
+比如s中，有很多个rr的子序列，但是算一个
+数据规模 : s串长度 <= 1000, x,y,n <= 2500
+
+在一个 n x n 的整数矩阵 grid 中，
+每一个方格的值 grid[i][j] 表示位置 (i, j) 的平台高度。
+当开始下雨时，在时间为 t 时，水池中的水位为 t 。
+你可以从一个平台游向四周相邻的任意一个平台，但是前提是此时水位必须同时淹没这两个平台。
+假定你可以瞬间移动无限距离，也就是默认在方格内部游动是不耗时的。
+当然，在你游泳的时候你必须待在坐标方格里面。
+你从坐标方格的左上平台 (0，0) 出发。
+返回 你到达坐标方格的右下平台 (n-1, n-1) 所需的最少时间 。
+测试链接 ：https://leetcode.cn/problems/swim-in-rising-water
+
+给定员工的 schedule 列表，表示每个员工的工作时间。
+每个员工都有一个非重叠的时间段  Intervals 列表，这些时间段已经排好序。
+返回表示 所有 员工的 共同，正数长度的空闲时间 的有限时间段的列表，同样需要排好序。
+测试链接 : https://leetcode.cn/problems/employee-free-time/
+
+我们给出了一个（轴对齐的）二维矩形列表 rectangles 。 
+对于 rectangle[i] = [x1, y1, x2, y2]，其中（x1，y1）是矩形 i 左下角的坐标
+(xi1, yi1) 是该矩形 左下角 的坐标， (xi2, yi2) 是该矩形 右上角 的坐标。
+计算平面中所有 rectangles 所覆盖的 总面积 。
+任何被两个或多个矩形覆盖的区域应只计算 一次 。
+返回 总面积 。因为答案可能太大，返回 10^9 + 7 的 模 。
+Leetcode测试链接 : https://leetcode.cn/problems/rectangle-area-ii/
+洛谷测试链接 : https://www.luogu.com.cn/problem/P5490
+
+
+
+第032节 2022年7月第3周流行算法题目解析
+
+一个整数区间 [a, b]  ( a < b ) 代表着从 a 到 b 的所有连续整数，包括 a 和 b。
+给你一组整数区间intervals，请找到一个最小的集合 S，
+使得 S 里的元素与区间intervals中的每一个整数区间都至少有2个元素相交。
+输出这个最小集合S的大小。
+测试链接 : https://leetcode.cn/problems/set-intersection-size-at-least-two/
+
+来自蔚来汽车
+给定一个只包含三种字符的字符串：( 、) 和 *，
+写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则：
+任何左括号 ( 必须有相应的右括号 )
+任何右括号 ) 必须有相应的左括号 (
+左括号 ( 必须在对应的右括号之前 )
+* 可以被视为单个右括号 ) ，或单个左括号 ( ，或一个空字符。
+一个空字符串也被视为有效字符串。
+测试链接 : https://leetcode.cn/problems/valid-parenthesis-string/
+
+给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。
+你可以按 任意顺序 返回答案。
+要求时间复杂度O(N)
+测试链接 : https://leetcode.cn/problems/top-k-frequent-elements/
+
+特殊的二进制序列是具有以下两个性质的二进制序列：
+0 的数量与 1 的数量相等。
+二进制序列的每一个前缀码中 1 的数量要大于等于 0 的数量。
+给定一个特殊的二进制序列 S，以字符串形式表示。
+定义一个操作 为首先选择 S 的两个连续且非空的特殊的子串，然后将它们交换。
+(两个子串为连续的当且仅当第一个子串的最后一个字符恰好为第二个子串的第一个字符的前一个字符)
+在任意次数的操作之后，交换后的字符串按照字典序排列的最大的结果是什么？
+测试链接 : https://leetcode.cn/problems/special-binary-string/
+
+
+
+第033节 2022年7月第4周流行算法题目解析
+
+一个数组如果满足 : 
+升降升降升降... 或者 降升降升...都是满足的
+给定一个数组， 
+1，看有几种方法能够剔除一个元素，达成上述的要求
+2，数组天然符合要求返回0
+3，剔除1个元素达成不了要求，返回-1，
+比如：
+给定[3, 4, 5, 3, 7]，返回3
+移除0元素，4 5 3 7 符合
+移除1元素，3 5 3 7 符合
+移除2元素，3 4 3 7 符合
+再比如：给定[1, 2, 3, 4] 返回-1
+因为达成不了要求
+
+你将得到一个整数数组 matchsticks ，其中 matchsticks[i] 是第 i 个火柴棒的长度。
+你要用 所有的火柴棍 拼成一个正方形。
+你 不能折断 任何一根火柴棒，但你可以把它们连在一起，而且每根火柴棒必须 使用一次 。
+如果你能拼出正方形，则返回 true ，否则返回 false 。
+测试链接 : https://leetcode.cn/problems/matchsticks-to-square/
+
+给你一个整数数组 nums 。如果 nums 的一个子集中，
+所有元素的乘积可以表示为一个或多个 互不相同的质数 的乘积，那么我们称它为 好子集 。
+比方说，如果 nums = [1, 2, 3, 4] ：
+[2, 3] ，[1, 2, 3] 和 [1, 3] 是 好 子集，乘积分别为 6 = 2*3 ，6 = 2*3 和 3 = 3 。
+[1, 4] 和 [4] 不是 好 子集，因为乘积分别为 4 = 2*2 和 4 = 2*2 。
+请你返回 nums 中不同的 好 子集的数目对 109 + 7 取余 的结果。
+nums 中的 子集 是通过删除 nums 中一些（可能一个都不删除，也可能全部都删除）
+元素后剩余元素组成的数组。
+如果两个子集删除的下标不同，那么它们被视为不同的子集。
+测试链接 : https://leetcode.cn/problems/the-number-of-good-subsets/
+
+
+
+第034节 2022年8月第1周流行算法题目解析
+
+在一个 2 * 3 的板上（board）有 5 块砖瓦，用数字 1~5 来表示, 
+以及一块空缺用 0 来表示。一次 移动 定义为选择 0 与一个相邻的数字（上下左右）进行交换.
+最终当板 board 的结果是 [[1,2,3],[4,5,0]] 谜板被解开。
+给出一个谜板的初始状态 board ，
+返回最少可以通过多少次移动解开谜板，如果不能解开谜板，则返回 -1 。
+测试链接 : https://leetcode.cn/problems/sliding-puzzle/
+
+找到数组中的水王数
+本题来自，大厂刷题班，23节
+为了讲述下一个题，才重新讲述这个题
+比较简单
+
+设计一个数据结构，有效地找到给定子数组的 多数元素 。
+子数组的 多数元素 是在子数组中出现 threshold 次数或次数以上的元素。
+实现 MajorityChecker 类:
+MajorityChecker(int[] arr) 
+会用给定的数组 arr 对 MajorityChecker 初始化。
+int query(int left, int right, int threshold) 
+返回子数组中的元素  arr[left...right] 至少出现 threshold 次数，
+如果不存在这样的元素则返回 -1。
+为了让同学们听懂这个题
+才安排的水王问题重讲
+测试链接 : https://leetcode.cn/problems/online-majority-element-in-subarray/
+
+给你一个长度为 n 的整数数组 rolls 和一个整数 k 。
+你扔一个 k 面的骰子 n 次，骰子的每个面分别是 1 到 k ，
+其中第 i 次扔得到的数字是 rolls[i] 。
+请你返回 无法 从 rolls 中得到的 最短 骰子子序列的长度。
+扔一个 k 面的骰子 len 次得到的是一个长度为 len 的 骰子子序列 。
+注意 ，子序列只需要保持在原数组中的顺序，不需要连续。
+测试链接 : https://leetcode.cn/problems/shortest-impossible-sequence-of-rolls/
+
+给定一个只由小写字母和数字字符组成的字符串str
+要求子串必须只含有一个小写字母，数字字符数量随意
+求这样的子串最大长度是多少
+
+栈只提供push、pop、isEmpty三个方法
+请完成无序栈的排序，要求排完序之后，从栈顶到栈底从小到大
+只能使用栈提供的push、pop、isEmpty三个方法、以及递归函数
+除此之外不能使用任何的容器，任何容器都不许，连数组也不行
+也不能自己定义任何结构体
+就是只用：
+1) 栈提供的push、pop、isEmpty三个方法
+2) 简单返回值的递归函数
+
+
+
+第035节 2022年8月第2周流行算法题目解析
+
+来自猿辅导
+2022.8.7笔试第三道
+给定一个数组arr，和一个正数k
+如果arr[i] == 0，表示i这里既可以是左括号也可以是右括号，
+而且可以涂上1~k每一种颜色
+如果arr[i] != 0，表示i这里已经确定是左括号，颜色就是arr[i]的值
+那么arr整体就可以变成某个括号字符串，并且每个括号字符都带有颜色
+返回在括号字符串合法的前提下，有多少种不同的染色方案
+不管是排列、还是颜色，括号字符串任何一点不一样，就算不同的染色方案
+最后的结果%10001，为了方便，我们不处理mod，就管核心思路
+2 <= arr长度 <= 5000
+1 <= k <= 1000
+0 <= arr[i] <= k
+
+来自米哈游
+给定一个正数n，表示有多少个节点
+给定一个二维数组edges，表示所有无向边
+edges[i] = {a, b} 表示a到b有一条无向边
+edges一定表示的是一个无环无向图，也就是树结构
+每个节点可以染1、2、3三种颜色
+要求 : 非叶节点的相邻点一定要至少有两种和自己不同颜色的点
+返回一种达标的染色方案，也就是一个数组，表示每个节点的染色状况
+1 <= 节点数量 <= 10的5次方
+
+给定一个逆波兰式
+转化成正确的中序表达式
+要求只有必要加括号的地方才加括号
+
+给定平面上n个点，x和y坐标都是整数
+找出其中的一对点的距离，使得在这n个点的所有点对中，该距离为所有点对中最小的
+返回最短距离，精确到小数点后面4位
+测试链接 : https://www.luogu.com.cn/problem/P1429
+
+
+
+第036节 2022年8月第3周流行算法题目解析
+
+给你一个 n 个节点的 有向图 ，节点编号为 0 到 n - 1 ，
+其中每个节点 至多 有一条出边。
+图用一个大小为 n 下标从 0 开始的数组 edges 表示，
+节点 i 到节点 edges[i] 之间有一条有向边。
+如果节点 i 没有出边，那么 edges[i] == -1 。
+请你返回图中的 最长 环，如果没有任何环，请返回 -1 。
+一个环指的是起点和终点是 同一个 节点的路径。
+测试链接 : https://leetcode.cn/problems/longest-cycle-in-a-graph/
+
+来自学员问题
+给定怪兽的血量为hp
+第i回合如果用刀砍，怪兽在这回合会直接掉血，没有后续效果
+第i回合如果用毒，怪兽在这回合不会掉血，
+但是之后每回合都会掉血，并且所有中毒的后续效果会叠加
+给定的两个数组cuts、poisons，两个数组等长，长度都是n
+表示你在n回合内的行动，
+每一回合的刀砍的效果由cuts[i]表示
+每一回合的中毒的效果由poisons[i]表示
+如果你在n个回合内没有直接杀死怪兽，意味着你已经无法有新的行动了
+但是怪兽如果有中毒效果的话，那么怪兽依然会在hp耗尽的那回合死掉
+返回你最快能在多少回合内将怪兽杀死
+数据范围 : 
+1 <= n <= 10的5次方
+1 <= hp <= 10的9次方
+1 <= cuts[i]、poisons[i] <= 10的9次方
+
+设计一个最大栈数据结构，既支持栈操作，又支持查找栈中最大元素。
+实现 MaxStack 类：
+MaxStack() 初始化栈对象
+void push(int x) 将元素 x 压入栈中。
+int pop() 移除栈顶元素并返回这个元素。
+int top() 返回栈顶元素，无需移除。
+int peekMax() 检索并返回栈中最大元素，无需移除。
+int popMax() 检索并返回栈中最大元素，并将其移除。
+如果有多个最大元素，只要移除 最靠近栈顶 的那个。
+测试链接 : https://leetcode.cn/problems/max-stack/
+
+这里有 n 个航班，它们分别从 1 到 n 进行编号。
+有一份航班预订表 bookings ，
+表中第 i 条预订记录 bookings[i] = [firsti, lasti, seatsi]
+意味着在从 firsti 到 lasti 
+（包含 firsti 和 lasti ）的 每个航班 上预订了 seatsi 个座位。
+请你返回一个长度为 n 的数组 answer，里面的元素是每个航班预定的座位总数。
+测试链接 : https://leetcode.cn/problems/corporate-flight-bookings/
+
+给你一个数组 nums，我们可以将它按一个非负整数 k 进行轮调，
+例如，数组为 nums = [2,4,1,3,0]，
+我们按 k = 2 进行轮调后，它将变成 [1,3,0,2,4]。
+这将记为 3 分，
+因为 1 > 0 [不计分]、3 > 1 [不计分]、0 <= 2 [计 1 分]、
+2 <= 3 [计 1 分]，4 <= 4 [计 1 分]。
+在所有可能的轮调中，返回我们所能得到的最高分数对应的轮调下标 k 。
+如果有多个答案，返回满足条件的最小的下标 k 。
+测试链接 : 
+https://leetcode.cn/problems/smallest-rotation-with-highest-score/
+
+
+
+第037节 2022年8月第4周流行算法题目解析
+
+来自神策
+给定一个数组arr，表示连续n天的股价，数组下标表示第几天
+指标X：任意两天的股价之和 - 此两天间隔的天数
+比如
+第3天，价格是10
+第9天，价格是30
+那么第3天和第9天的指标X = 10 + 30 - (9 - 3) = 34
+返回arr中最大的指标X
+
+来自美团
+8.20笔试
+小团生日收到妈妈送的两个一模一样的数列作为礼物！
+他很开心的把玩，不过不小心没拿稳将数列摔坏了！
+现在他手上的两个数列分别为A和B，长度分别为n和m。
+小团很想再次让这两个数列变得一样。他现在能做两种操作：
+操作一是将一个选定数列中的某一个数a改成数b，这会花费|b-a|的时间，
+操作二是选择一个数列中某个数a，将它从数列中丢掉，花费|a|的时间。
+小团想知道，他最少能以多少时间将这两个数列变得再次相同！
+输入描述：
+第一行两个空格隔开的正整数n和m，分别表示数列A和B的长度。
+接下来一行n个整数，分别为A1 A2…An
+接下来一行m个整数，分别为B1 B2…Bm
+对于所有数据，1 ≤ n,m ≤ 2000， |Ai|,|Bi| ≤ 10000
+输出一行一个整数，表示最少花费时间，来使得两个数列相同。
+
+来自美团
+题目1
+8.20笔试
+小美将要期中考试，有n道题，对于第i道题，
+小美有pi的几率做对，获得ai的分值，还有(1-pi)的概率做错，得0分。
+小美总分是每道题获得的分数。
+小美不甘于此，决定突击复习，因为时间有限，她最多复习m道题，复习后的试题正确率为100%。
+如果以最佳方式复习，能获得期望最大总分是多少？
+输入n、m
+接下来输入n个整数，代表pi%，为了简单期间，将概率扩大了100倍。
+接下来输入n个整数，代表ai，某道题的分值
+输出最大期望分值，精确到小数点后2位
+数据 1m<=n<=50000
+简单题, 课上提一下解法即可
+题目2
+小团在地图上放了3个定位装置，想依赖他们进行定位！
+地图是一个n*n的棋盘，
+有3个定位装置(x1,y1),(x2,y2),(x3,y3)，每个值均在[1,n]内。
+小团在(a,b)位置放了一个信标，
+每个定位装置会告诉小团它到信标的曼哈顿距离，也就是对于每个点，小团知道|xi-a|+|yi-b|
+求信标位置，信标不唯一，输出字典序最小的。
+输入n，然后是3个定位装置坐标，
+最后是3个定位装置到信标的曼哈顿记录。
+输出最小字典序的信标位置。
+1 <= 所有数据值 <= 50000
+
+来自微软
+给定一个字符串s，只含有0~9这些字符
+你可以使用来自s中的数字，目的是拼出一个最大的回文数
+使用数字的个数，不能超过s里含有的个数
+比如 : 
+39878，能拼出的最大回文数是 : 898
+00900，能拼出的最大回文数是 : 9
+54321，能拼出的最大回文数是 : 5
+最终的结果以字符串形式返回
+str的长度为N，1 <= N <= 100000
+测试链接 : https://leetcode.cn/problems/largest-palindromic-number/
+
+来自微软
+给定两个数组A和B，比如
+A = { 0, 1, 1 }
+B = { 1, 2, 3 }
+A[0] = 0, B[0] = 1，表示0到1有双向道路
+A[1] = 1, B[1] = 2，表示1到2有双向道路
+A[2] = 1, B[2] = 3，表示1到3有双向道路
+给定数字N，编号从0~N，所以一共N+1个节点
+题目输入一定保证所有节点都联通，并且一定没有环
+默认办公室是0节点，其他1~N节点上，每个节点上都有一个居民
+每天所有居民都去往0节点上班
+所有的居民都有一辆5座的车，也都乐意和别人一起坐车
+车不管负重是多少，只要走过一条路，就耗费1的汽油
+比如A、B、C的居民，开着自己的车来到D居民的位置，一共耗费3的汽油
+D居民和E居民之间，假设有一条路
+那么D居民可以接上A、B、C，4个人可以用一辆车，去往E的话，就再耗费1的汽油
+求所有居民去办公室的路上，最少耗费多少汽油
+测试链接 : https://leetcode.cn/problems/minimum-fuel-cost-to-report-to-the-capital/
+
+来自网易
+小红拿到了一个仅由r、e、d组成的字符串
+她定义一个字符e为"好e" : 当且仅当这个e字符和r、d相邻
+例如"reeder"只有一个"好e"，前两个e都不是"好e"，只有第三个e是"好e"
+小红每次可以将任意字符修改为任意字符，即三种字符可以相互修改
+她希望"好e"的数量尽可能多
+小红想知道，自己最少要修改多少次
+输入一个只有r、e、d三种字符的字符串
+长度 <= 2 * 10^5
+输出最小修改次数
+
+
+
+第038节 2022年8月第5周流行算法题目解析
+
+来自学员面试
+nim博弈
+有a块草莓蛋糕，有b块芝士蛋糕，两人轮流拿蛋糕
+每次不管是谁只能选择在草莓蛋糕和芝士蛋糕中拿一种
+拿的数量在1~m之间随意
+谁先拿完最后的蛋糕谁赢
+返回先手赢还是后手赢
+
+给定一个由 '[' ，']'，'('，‘)’ 组成的字符串
+请问最少插入多少个括号就能使这个字符串的所有括号左右配对
+例如当前串是 "([[])"，那么插入一个']'即可满足
+输出最少插入多少个括号
+测试链接 : https://www.nowcoder.com/practice/e391767d80d942d29e6095a935a5b96b
+
+来自Amazon
+定义一个概念叫"变序最大和"
+"变序最大和"是说一个数组中，每个值都可以减小或者不变，
+在必须把整体变成严格升序的情况下，得到的最大累加和
+比如，[1,100,7]变成[1,6,7]时，就有变序最大和为14
+比如，[5,4,9]变成[3,4,9]时，就有变序最大和为16
+比如，[1,4,2]变成[0,1,2]时，就有变序最大和为3
+给定一个数组arr，其中所有的数字都是>=0的
+求arr所有子数组的变序最大和中，最大的那个并返回
+1 <= arr长度 <= 10^6
+0 <= arr[i] <= 10^6
+
+给定n棵树，和两个长度为n的数组a和b
+i号棵树的初始重量为a[i]，i号树每天的增长重量为b[i]
+你每天最多能砍1棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总增重
+给定m，表示你有m天，返回m天内你获得的最大收益
+本题测试链接 : https://zoj.pintia.cn/problem-sets/91827364500/problems/91827367873
+
+增加的题目:
+小红定义"漂亮串"为：至少有两个"red"子串
+例如"redxred"为漂亮串，但"reedred"则不是漂亮串
+小红想知道长度为n，仅包含小写字母的所有字符串中，共有多少个不同的漂亮串？
+输入描述：
+一个正整数n，代表字符串长度
+n <= 10^6
+输出描述：
+长度为n，仅包含小写字母的所有字符串中，共有多少个不同的漂亮串，结果对10^9 + 7取模
+本题为课堂临时增加，只有当堂讲述，没有代码实现
+回答帖子 : https://www.mashibing.com/question/detail/34493
+
+
+
+第039节 2022年9月第1周流行算法题目解析
+
+给你一个由小写字母组成的字符串 s ，和一个整数 k
+如果满足下述条件，则可以将字符串 t 视作是 理想字符串 ：
+t 是字符串 s 的一个子序列。
+t 中每两个 相邻 字母在字母表中位次的绝对差值小于或等于 k 。
+返回 最长 理想字符串的长度。
+字符串的子序列同样是一个字符串，并且子序列还满足：
+可以经由其他字符串删除某些字符（也可以不删除）但不改变剩余字符的顺序得到。
+注意：字母表顺序不会循环
+例如，'a' 和 'z' 在字母表中位次的绝对差值是 25，而不是 1 。
+测试链接 : https://leetcode.cn/problems/longest-ideal-subsequence/
+
+来自美团
+有n个城市，城市从0到n-1进行编号。小美最初住在k号城市中
+在接下来的m天里，小美每天会收到一个任务
+她可以选择完成当天的任务或者放弃该任务
+第i天的任务需要在ci号城市完成，如果她选择完成这个任务
+若任务开始前她恰好在ci号城市，则会获得ai的收益
+若她不在ci号城市，她会前往ci号城市，获得bi的收益
+当天的任务她都会当天完成
+任务完成后，她会留在该任务所在的ci号城市直到接受下一个任务
+如果她选择放弃任务，她会停留原地，且不会获得收益
+小美想知道，如果她合理地完成任务，最大能获得多少收益
+输入描述: 第一行三个正整数n, m和k，表示城市数量，总天数，初始所在城市
+第二行为m个整数c1, c2,...... cm，其中ci表示第i天的任务所在地点为ci
+第三行为m个整数a1, a2,...... am，其中ai表示完成第i天任务且地点不变的收益
+第四行为m个整数b1, b2,...... bm，其中bi表示完成第i天的任务且地点改变的收益
+0 <= k, ci <= n <= 30000
+1 <= m <= 30000
+0 <= ai, bi <= 10^9
+输出描述 输出一个整数，表示小美合理完成任务能得到的最大收益
+
+来自美团
+给定一个正数n, 表示从0位置到n-1位置每个位置放着1件衣服
+从0位置到n-1位置不仅有衣服，每个位置还摆着1个机器人
+给定两个长度为n的数组，powers和rates
+powers[i]表示i位置的机器人的启动电量
+rates[i]表示i位置的机器人收起1件衣服的时间
+使用每个机器人只需要付出启动电量
+当i位置的机器人收起i位置的衣服，它会继续尝试往右收起i+1位置衣服
+如果i+1位置的衣服已经被其他机器人收了或者其他机器人正在收
+这个机器人就会停机, 不再收衣服。
+不过如果它不停机，它会同样以rates[i]的时间来收起这件i+1位置的衣服
+也就是收衣服的时间为每个机器人的固定属性，当它收起i+1位置的衣服，
+它会继续检查i+2位置...一直到它停机或者右边没有衣服可以收了
+形象的来说，机器人会一直尝试往右边收衣服，收k件的话就耗费k * rates[i]的时间
+但是当它遇见其他机器人工作的痕迹，就会认为后面的事情它不用管了，进入停机状态
+你手里总共有电量b，准备在0时刻将所有想启动的机器人全部一起启动
+过后不再启动新的机器人，并且启动机器人的电量之和不能大于b
+返回在最佳选择下，假快多久能收完所有衣服
+如果无论如何都收不完所有衣服，返回-1
+给定数据: int n, int b, int[] powers, int[] rates
+数据范围: 
+powers长度 == rates长度 == n <= 1000
+1 <= b <= 10^5
+1 <= powers[i]、rates[i] <= 10^5
+
+来自学员问题
+给你一个长度为n的数组，并询问q次
+每次询问区间[l,r]之间是否存在小于等于k个数的和大于等于x
+每条查询返回true或者false
+1 <= n, q <= 10^5
+k <= 10
+1 <= x <= 10^8
+
+来自微软面试
+给定一个长度为n的二维数组graph，代表一张图
+graph[i] = {a,b,c,d} 表示i讨厌(a,b,c,d)，讨厌关系为双向的
+一共有n个人，编号0~n-1
+讨厌的人不能一起开会
+返回所有人能不能分成两组开会
+测试链接 : https://leetcode.cn/problems/is-graph-bipartite/
+
+
+
+第040节 2022年9月第2周流行算法题目解析
+
+来自百度
+二狗买了一些小兵玩具，和大胖一起玩
+一共有n个小兵，这n个小兵拍成一列
+第i个小兵战斗力为hi，然后他们两个开始对小兵进行排列
+一共进行m次操作，二狗每次操作选择一个数k，将前k个小兵战斗力从小到大排列
+大胖每次操作选择一个数k，将前k个小兵战斗力从大到小排列
+问所有操作结束后，排列顺序什么样
+给定一个长度为n的数组arr，表示每个小兵的战斗力
+给定一个长度为m的数组op, 
+op[i] = { k , 0 }, 表示对前k个士兵执行从小到大的操作
+op[i] = { k , 1 }, 表示对前k个士兵执行从大到小的操作
+返回数组ans，表示最终的排列
+1 <= n, m <= 2 * 10^5
+- 10^9 <= arr[i] <= + 10^9
+
+来自微众银行
+给定一个数字n，代表数组的长度
+给定一个数字m，代表数组每个位置都可以在1~m之间选择数字
+所有长度为n的数组中，最长递增子序列长度为3的数组，叫做达标数组
+返回达标数组的数量
+1 <= n <= 500
+1 <= m <= 10
+
+来自微软
+给定一个字符串s，其中都是英文小写字母
+如果s中的子串含有的每种字符都是偶数个
+那么这样的子串就是达标子串，子串要求是连续串
+返回s中达标子串的最大长度
+1 <= s的长度 <= 10^5
+字符种类都是英文小写
+
+来自学员问题
+有一个数组包含0、1、2三种值，
+有m次修改机会，第一种将所有连通的1变为0，修改次数-1
+第二种将所有连通的2变为1或0，修改次数-2，
+返回m次修改机会的情况下，让最大的0连通区，最长能是多少？
+1 <= arr长度 <= 10^6
+0 <= 修改机会 <= 10^6
+
+
+
+第041节 2022年9月第3周流行算法题目解析
+
+来自360
+有n个黑白棋子，它们的一面是黑色，一面是白色
+它们被排成一行，位置0~n-1上。一开始所有的棋子都是黑色向上
+一共有q次操作，每次操作将位置标号在区间[L，R]内的所有棋子翻转
+那么这个范围上的每一颗棋子的颜色也就都改变了
+请在每次操作后，求这n个棋子中，黑色向上的棋子个数
+1 <= n <= 10^18
+1 <= q <= 300
+0 <= 每一条操作的L、R <= n - 1
+输出q行，每一行一个整数，表示操作后的所有黑色棋子的个数
+注意 : 其实q <= 10^5也可以通过，360考试时候降低了难度
+
+来自美团
+某天小美进入了一个迷宫探险，根据地图所示，这个迷宫里有无数个房间
+序号分别为1、2、3、...入口房间的序号为1
+任意序号为正整数x的房间，都与序号 2*x 和 2*x + 1 的房间之间各有一条路径
+但是这些路径是单向的，即只能从序号为x的房间去到序号为 2*x 或 2*x+1 的房间
+而不能从 2*x 或 2*x+1 的房间去到序号为x的房间
+在任何时刻小美都可以选择结束探险并离开迷宫，但是离开之后将无法再次进入迷宫
+小美还提前了解了迷宫中宝藏的信息
+已知宝藏共有n个，其中第i个宝藏在序号为pi的房间，价值为wi
+且一个房间中可能有多个宝藏
+小美为了得到更多的宝藏，需要精心规划路线，她找到你帮忙
+想请你帮她计算一下，能获得的宝藏价值和最大值为多少
+第一行一个正整数n，表示宝藏数量。
+第二行为n个正整数p1, p2,...... pn，其中pi表示第 i 个宝藏在序号为pi的房间。
+第三行为n个正整数w1, w2,...... wn，其中wi表示第i个宝藏的价值为wi。
+1 <= n <= 40000, 1 <= pi < 2^30, 1 <= wi <= 10^6。
+
+来自美团
+某天，小美在玩一款游戏，游戏开始时，有n台机器，
+每台机器都有一个能量水平，分别为a1、a2、…、an，
+小美每次操作可以选其中的一台机器，假设选的是第i台，
+那小美可以将其变成 ai+10^k（k为正整数且0<=k<=9），
+由于能量过高会有安全隐患，所以机器会在小美每次操作后会自动释放过高的能量
+即变成 (ai+10^k)%m
+其中%m表示对m取模，由于小美还有工作没有完成，所以她想请你帮她计算一下，
+对于每台机器，将其调节至能量水平为0至少需要多少次操作
+机器自动释放能量不计入小美的操作次数）。
+第一行两个正整数n和m，表示数字个数和取模数值。
+第二行为n个正整数a1, a2,...... an，其中ai表示第i台机器初始的能量水平。
+1 <= n <= 30000，2 <= m <= 30000, 0 <= ai <= 10^12。
+
+来自美团
+有三个题库A、B、C，每个题库均有n道题目，且题目都是从1到n进行编号
+每个题目都有一个难度值
+题库A中第i个题目的难度为ai
+题库B中第i个题目的难度为bi
+题库C中第i个题目的难度为ci
+小美准备组合出一套试题，试题共有三道题，
+第一题来自题库A，第二题来自题库B，第三题来自题库C
+试题要求题目难度递增，且梯度不能过大
+具体地说，第二题的难度必须大于第一题的难度，但不能大于第一题难度的两倍
+第三题的难度必须大于第二题的难度，但不能大于第二题难度的两倍
+小美想知道在满足上述要求下，有多少种不同的题目组合
+(三道题目中只要存在一道题目不同，则两个题目组合就视为不同
+输入描述 第一行一个正整数n, 表示每个题库的题目数量
+第二行为n个正整数a1, a2,...... an，其中ai表示题库A中第i个题目的难度值
+第三行为n个正整数b1, b2,...... bn，其中bi表示题库B中第i个题目的难度值
+第四行为n个正整数c1, c2,...... cn，其中ci表示题库C中第i个题目的难度值
+1 <= n <= 20000, 1 <= ai, bi, ci <= 10^9。
+
+来自字节
+给定一个只由小写字母组成的字符串str，长度为N
+给定一个只由0、1组成的数组arr，长度为N
+arr[i] == 0表示str中i位置的字符不许修改
+arr[i] == 1表示str中i位置的字符允许修改
+给定一个正数m，表示在任意允许修改的位置
+可以把该位置的字符变成a~z中的任何一个
+可以修改m次
+返回在最多修改m次的情况下，全是一种字符的最长子串是多长
+1 <= N, M <= 10^5
+所有字符都是小写
+
+来自阿里
+小红定义一个仅有r、e、d三种字符的字符串中
+如果仅有一个长度不小于2的回文子串，那么这个字符串定义为"好串"
+给定一个正整数n，输出长度为n的好串有多少个
+结果对10^9 + 7取模， 1 <= n <= 10^9
+示例：
+n = 1, 输出0
+n = 2, 输出3
+n = 3, 输出18
+https://www.mashibing.com/question/detail/37485
+
+
+
+第042节 2022年9月第4周流行算法题目解析
+
+来自学员问题
+智能机器人要坐专用电梯把货物送到指定地点
+整栋楼只有一部电梯，并且由于容量限制智能机器人只能放下一件货物
+给定K个货物，每个货物都有所在楼层(from)和目的楼层(to)
+假设电梯速度恒定为1，相邻两个楼层之间的距离为1
+例如电梯从10层去往19层的时间为9
+机器人装卸货物的时间极快不计入
+电梯初始地点为第1层，机器人初始地点也是第1层
+并且在运送完所有货物之后，机器人和电梯都要回到1层
+返回智能机器人用电梯将每个物品都送去目标楼层的最快时间
+注意：如果智能机器人选了一件物品，则必须把这个物品送完，不能中途丢下
+输入描述：
+正数k，表示货物数量，1 <= k <= 16
+from、to数组，长度都是k，1 <= from[i]、to[i] <= 10000
+from[i]表示i号货物所在的楼层
+to[i]表示i号货物要去往的楼层
+返回最快的时间
+
+来自华为
+一个n*n的二维数组中，只有0和1两种值
+当你决定在某个位置操作一次
+那么该位置的行和列整体都会变成1，不管之前是什么状态
+返回让所有值全变成1，最少的操作次数
+1 < n < 10，没错！原题就是说n < 10, 不会到10！最多到9！
+
+来自华为
+给定一个二维数组map，代表一个餐厅，其中只有0、1两种值
+map[i][j] == 0 表示(i,j)位置是空座
+map[i][j] == 1 表示(i,j)位置坐了人
+根据防疫要求，任何人的上、下、左、右，四个相邻的方向都不能再坐人
+但是为了餐厅利用的最大化，也许还能在不违反防疫要求的情况下，继续安排人吃饭
+请返回还能安排的最大人数
+如果一开始的状况已经不合法，直接返回-1
+比如:
+1 0 0 0
+0 0 0 1
+不违反防疫要求的情况下，这个餐厅最多还能安排2人，如下所示，X是新安排的人
+1 0 X 0
+0 X 0 1
+再比如:
+1 0 0 0 0 1
+0 0 0 0 0 0
+0 1 0 0 0 1
+0 0 0 0 0 0
+不违反防疫要求的情况下，这个餐厅最多还能安排7人，如下所示，X是新安排的人
+1 0 0 X 0 1
+0 0 X 0 X 0
+0 1 0 X 0 1
+X 0 X 0 X 0
+数据范围 : 1 <= 矩阵的行、列 <= 20
+
+给你两个整数 m 和 n 。构造一个 m x n 的网格，其中每个单元格最开始是白色
+请你用 红、绿、蓝 三种颜色为每个单元格涂色。所有单元格都需要被涂色
+涂色方案需要满足：不存在相邻两个单元格颜色相同的情况
+返回网格涂色的方法数。因为答案可能非常大
+返回 对 109 + 7 取余 的结果。
+1 <= n <= 1000
+1 <= m <= 5
+测试链接 : https://leetcode.cn/problems/painting-a-grid-with-three-different-colors/
+
+来自字节
+给定正数N，表示用户数量，用户编号从0~N-1
+给定正数M，表示实验数量，实验编号从0~M-1
+给定长度为N的二维数组A，
+A[i] = { a, b, c }表示，用户i报名参加了a号、b号、c号实验
+给定正数Q，表示查询的条数
+给定长度为Q的二维数组B，
+B[i] = { e, f }表示，第i条查询想知道e号、f号实验，一共有多少人(去重统计)
+返回每一条查询的结果数组
+数据描述 : 
+1 <= N <= 10^5
+1 <= M <= 10^2
+1 <= Q <= 10^4
+所有查询所列出的所有实验编号数量(也就是二维数组B，行*列的规模) <= 10^5
+
+
+
+第043节 2022年10月第1周流行算法题目解析
+
+力扣数据中心有 n 台服务器，分别按从 0 到 n-1 的方式进行了编号
+它们之间以「服务器到服务器」点对点的形式相互连接组成了一个内部集群
+其中连接 connections 是无向的
+从形式上讲，connections[i] = [a, b] 表示服务器 a 和 b 之间形成连接
+任何服务器都可以直接或者间接地通过网络到达任何其他服务器。
+"关键连接"是在该集群中的重要连接，也就是说，假如我们将它移除
+便会导致某些服务器无法访问其他服务器。
+请你以任意顺序返回该集群内的所有"关键连接"
+测试链接 : https://leetcode.cn/problems/critical-connections-in-a-network/
+
+来自Leetcode周赛
+魔物了占领若干据点，这些据点被若干条道路相连接，
+roads[i] = [x, y] 表示编号 x、y 的两个据点通过一条道路连接。
+现在勇者要将按照以下原则将这些据点逐一夺回：
+在开始的时候，勇者可以花费资源先夺回一些据点，
+初始夺回第 j 个据点所需消耗的资源数量为 cost[j]
+接下来，勇者在不消耗资源情况下，
+每次可以夺回一个和「已夺回据点」相连接的魔物据点，
+并对其进行夺回
+为了防止魔物暴动，勇者在每一次夺回据点后（包括花费资源夺回据点后），
+需要保证剩余的所有魔物据点之间是相连通的（不经过「已夺回据点」）。
+请返回勇者夺回所有据点需要消耗的最少资源数量。
+输入保证初始所有据点都是连通的，且不存在重边和自环
+测试链接 : https://leetcode.cn/problems/s5kipK/
+
+来自学员问题
+商场中有一展柜A，其大小固定，现已被不同的商品摆满
+商家提供了一些新商品B，需要对A中的部分商品进行更新替换
+B中的商品可以自由使用，也就是可以用B中的任何商品替换A中的任何商品
+A中的商品一旦被替换，就认为消失了！而不是回到了B中！
+要求更新过后的展柜中，商品严格按照价格由低到高进行排列
+不能有相邻商品价格相等的情况
+A[i]为展柜中第i个位置商品的价格，B[i]为各个新商品的价格
+求能够满足A中商品价格严格递增的最小操作次数，若无法满足则返回-1
+
+来自美团
+两种颜色的球，蓝色和红色，都按1～n编号，共计2n个
+为方便放在一个数组中，红球编号取负，篮球不变，并打乱顺序，
+要求同一种颜色的球按编号升序排列，可以进行如下操作：
+交换相邻两个球，求最少操作次数。
+[3,-3,1,-4,2,-2,-1,4]
+最终交换结果为
+[1,2,3,-1,-2,-3,-4,4]
+最少交换次数为10
+n <= 1000
+
+
+
+第044节 2022年10月第2周流行算法题目解析
+
+来自小红书
+小A认为如果在数组中有一个数出现了至少k次
+且这个数是该数组的众数，即出现次数最多的数之一
+那么这个数组被该数所支配
+显然当k比较大的时候，有些数组不被任何数所支配
+现在小A拥有一个长度为n的数组，她想知道内部有多少个区间是被某个数支配的
+2 <= k <= n <= 100000
+1 <= 数组的值 <= n
+
+来自京东
+实习岗位笔试题
+给定一个数组arr，长度为n
+任意相邻的两个数里面至少要有一个被选出来，组成子序列，才是合法的！
+求所有可能的合法子序列中，最大中位数是多少
+中位数的定义为上中位数
+[1, 2, 3, 4]的上中位数是2
+[1, 2, 3, 4, 5]的上中位数是3
+2 <=  n <= 10^5
+1 <= arr[i] <= 10^9
+我写的帖子解答 : https://www.mashibing.com/question/detail/34771
+
+定义一个二维数组N*M，比如5*5数组下所示：
+0, 1, 0, 0, 0,
+0, 1, 1, 1, 0,
+0, 0, 0, 0, 0,
+0, 1, 1, 1, 0,
+0, 0, 0, 1, 0,
+它表示一个迷宫，其中的1表示墙壁，0表示可以走的路
+只能横着走或竖着走，不能斜着走
+要求编程序找出从左上角到右下角距离最短的路线
+测试链接 : https://www.nowcoder.com/practice/cf24906056f4488c9ddb132f317e03bc
+
+来自Airbnb、Uber
+给定一个二维网格 grid ，其中：
+'.' 代表一个空房间
+'#' 代表一堵
+'@' 是起点
+小写字母代表钥匙
+大写字母代表锁
+我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间
+我们不能在网格外面行走，也无法穿过一堵墙
+如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。
+假设 k 为 钥匙/锁 的个数，且满足 1 <= k <= 6，
+字母表中的前 k 个字母在网格中都有自己对应的一个小写和一个大写字母
+换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁
+另外，代表钥匙和锁的字母互为大小写并按字母顺序排列
+返回获取所有钥匙所需要的移动的最少次数。如果无法获取所有钥匙，返回 -1 。
+测试链接：https://leetcode.cn/problems/shortest-path-to-get-all-keys
+
+来自华为
+给定一个N*M的二维矩阵，只由字符'O'、'X'、'S'、'E'组成
+'O'表示这个地方是可通行的平地
+'X'表示这个地方是不可通行的障碍
+'S'表示这个地方有一个士兵，全图保证只有一个士兵
+'E'表示这个地方有一个敌人，全图保证只有一个敌人
+士兵可以在上、下、左、右四个方向上移动
+走到相邻的可通行的平地上，走一步耗费a个时间单位
+士兵从初始地点行动时，不管去哪个方向，都不用耗费转向的代价
+但是士兵在行动途中，如果需要转向，需要额外再付出b个时间单位
+返回士兵找到敌人的最少时间
+如果因为障碍怎么都找不到敌人，返回-1
+1 <= N,M <= 1000
+1 <= a,b <= 100000
+只会有一个士兵、一个敌人
+
+
+
+第045节 2022年10月第3周流行算法题目解析
+
+给定一个整数数组 A，坡是元组 (i, j)，其中  i < j 且 A[i] <= A[j]
+这样的坡的宽度为 j - i
+找出 A 中的坡的最大宽度，如果不存在，返回 0
+示例 1：
+输入：[6,0,8,2,1,5]
+输出：4
+解释：
+最大宽度的坡为 (i, j) = (1, 5): A[1] = 0 且 A[5] = 5
+示例 2：
+输入：[9,8,1,0,1,9,4,0,4,1]
+输出：7
+解释：
+最大宽度的坡为 (i, j) = (2, 9): A[2] = 1 且 A[9] = 1
+测试链接 : https://leetcode.cn/problems/maximum-width-ramp/
+
+给定一个由 0 和 1 组成的数组 arr ，将数组分成  3 个非空的部分
+使得所有这些部分表示相同的二进制值。
+如果可以做到，请返回任何 [i, j]，其中 i+1 < j，这样一来
+arr[0], arr[1], ..., arr[i] 为第一部分
+arr[i + 1], arr[i + 2], ..., arr[j - 1] 为第二部分
+arr[j], arr[j + 1], ..., arr[arr.length - 1] 为第三部分
+这三个部分所表示的二进制值相等
+如果无法做到，就返回 [-1, -1]
+注意，在考虑每个部分所表示的二进制时，应当将其看作一个整体
+例如，[1,1,0] 表示十进制中的 6，而不会是 3。此外，前导零也是被允许的
+所以 [0,1,1] 和 [1,1] 表示相同的值。
+测试链接 : https://leetcode.cn/problems/three-equal-parts/
+
+来自阿里
+给定一个长度n的数组，每次可以选择一个数x
+让这个数组中所有的x都变成x+1，问你最少的操作次数
+使得这个数组变成一个非降数组
+n <= 3 * 10^5
+0 <= 数值 <= 10^9
+
+来自Lucid Air
+给定一个无向图，保证所有节点连成一棵树，没有环
+给定一个正数n为节点数，所以节点编号为0~n-1，那么就一定有n-1条边
+每条边形式为{a, b, w}，意思是a和b之间的无向边，权值为w
+要求：给定一个正数k，表示在挑选之后，每个点相连的边，数量都不能超过k
+注意：是每个点的连接数量，都不超过k！不是总连接数量不能超过k！
+你可以随意挑选边留下，剩下的边删掉，但是要满足上面的要求
+返回不违反要求的情况下，你挑选边所能达到的最大权值累加和
+
+给定一个字符串str
+如果删掉连续一段子串，剩下的字符串拼接起来是回文串
+那么该删除叫做有效的删除
+返回有多少种有效删除
+注意 : 不能全删除，删成空串不允许
+字符串长度 <= 3000
+
+
+
+第046节 2022年10月第4周流行算法题目解析
+
+来自华为
+若两个正整数的和为素数，则这两个正整数称之为"素数伴侣"
+给定N(偶数)个正整数中挑选出若干对，组成"素数伴侣"
+例如有4个正整数：2，5，6，13，
+如果将5和6分为一组的话，只能得到一组"素数伴侣"
+如果将2和5、6和13编组，将得到两组"素数伴侣"
+这是得到"素数伴侣"最多的划分方案
+输入:
+有一个正偶数 n ，表示待挑选的自然数的个数。后面给出 n 个具体的数字。
+输出:
+输出一个整数 K ，表示最多能找出几对"素数伴侣"
+数据范围： 1 <= n <= 100, 2 <= val <= 30000
+测试链接 : https://www.nowcoder.com/practice/b9eae162e02f4f928eac37d7699b352e
+
+来自学员问题
+给定一个二维数组matrix
+每个格子都是正数，每个格子都和上、下、左、右相邻
+你可以从任何一个格子出发，走向相邻的格子
+把沿途的数字乘起来，希望得到的最终数字中，结尾的0最多
+走的过程中，向左走或者向右走的拐点，最多只能有一次
+返回结尾最多的0，能是多少
+1 <= 行、列 <= 400
+
+有一根长度为 n 个单位的木棍，棍上从 0 到 n 标记了若干位置
+给你一个整数数组 cuts ，其中 cuts[i] 表示你需要将棍子切开的位置
+你可以按顺序完成切割，也可以根据需要更改切割的顺序
+每次切割的成本都是当前要切割的棍子的长度，切棍子的总成本是历次切割成本的总和
+对棍子进行切割将会把一根木棍分成两根较小的木棍
+这两根木棍的长度和就是切割前木棍的长度
+返回切棍子的最小总成本
+测试链接 : https://leetcode.cn/problems/minimum-cost-to-cut-a-stick/
+
+来自拼多多
+第一行有一个正整数n(3<=n<=100000)，代表小A拟定的路线数量
+第二行有n个正整数，第i个代表第i条路线的起始日期
+第三行有n个正整数，第i个代表第i条路线的终止日期
+输入保证起始日期小于终止日期
+日期最小是1，最大不超过1000000000
+小A打算选三个路线进行旅游，比如 A -> B -> C
+要求A的结束日期要小于B的开始日期，B的结束日期要小于C的开始日期
+输出一个非负整数，代表线路的方案数量
+例子
+输入
+6
+4 1 3 2 1 2 
+4 1 3 3 2 2
+输出
+6
+解释
+[1,1] -> [2,2] -> [3,3]
+[1,1] -> [2,2] -> [4,4]
+[1,1] -> [2,3] -> [4,4]
+[1,2] -> [3,3] -> [4,4]
+[1,1] -> [3,3] -> [4,4]
+[2,2] -> [3,3] -> [4,4]
+
+给定一个字符串 s，返回 s 中不同的非空 回文子序列 个数
+通过从 s 中删除 0 个或多个字符来获得子序列
+如果一个字符序列与它反转后的字符序列一致，那么它是 回文字符序列
+如果有某个 i , 满足 ai != bi ，则两个序列 a1, a2, ... 和 b1, b2, ... 不同
+注意：结果可能很大，你需要对 10^9 + 7 取模
+测试链接 : https://leetcode.cn/problems/count-different-palindromic-subsequences/
+
+来自学员问题
+设计一个仓库管理器，提供如下的方法：
+1) void supply(String item, int num, int price)
+名字叫item的商品，个数num，价格price
+2) int sell(String item, int num)
+卖出叫item的商品，个数num个，价格从低到高，返回卖出总价
+如果商品很多，每种商品的数量可能很多，该怎么设计这个结构
+
+来自亚马逊
+给定一个数组arr，和一个正数k
+你可以随意删除arr中的数字，最多删除k个
+目的是让连续出现一种数字的长度尽量长
+返回这个尽量长的长度
+比如数组arr = { 3, -2, 3, 3, 5, 6, 3, -2 }, k = 3
+你可以删掉-2、5、6(最多3个)，这样数组arr = { 3, 3, 3, 3, -2 }
+可以看到连续出现3的长度为4
+这是所有删除方法里的最长结果，所以返回4
+1 <= arr长度 <= 3 * 10^5
+-10^9 <= arr中的数值 <= 10^9
+0 <= k <= 3 * 10^5
+
+
+
+第047节 2022年11月第1周流行算法题目解析
+
+来自华为
+做甜点需要购买配料，目前共有n种基料和m种配料可供选购
+制作甜点需要遵循以下几条规则：
+必须选择1种基料；可以添加0种、1种或多种配料，每种类型的配料最多添加2份
+给定长度为n的数组base, base[i]表示第i种基料的价格
+给定长度为m的数组topping, topping[j]表示第j种配料的价格
+给定一个正数target，表示你做的甜点最终的价格要尽量接近这个数值
+返回最接近这个数值的价格是多少
+如果有多个方案，都最接近target，返回价格最小的那个答案
+1 <= n,m <= 10
+1 <= base[i], topping[j] <= 10 ^ 4
+1 <= target <= 10 ^ 4
+
+来自蚂蚁金服
+得分的定义 :
+含有大小2*2的矩阵，要么：
+1 0
+0 1 可以得1分
+要么
+0 1
+1 0 可以得1分
+那么一个任意大小的矩阵就有若干得分点，比如
+0 1 0
+1 0 1
+这个矩阵就有2个得分点
+给定正数N，正数M，求所有可能的情况里，所有的得分点总和
+1 <= N、M <= 10^9
+
+来自蚂蚁金服
+小红有n个朋友, 她准备开个宴会，邀请一些朋友
+i号朋友的愉悦值为a[i]，财富值为b[i]
+如果两个朋友同时参加宴会，这两个朋友之间的隔阂是其财富值差值的绝对值
+宴会的隔阂值，是财富差距最大的两人产生的财富值差值的绝对值
+宴会的愉悦值，是所有参加宴会朋友的愉悦值总和
+小红可以邀请任何人，
+希望宴会的愉悦值不能小于k的情况下， 宴会的隔阂值能最小是多少
+如果做不到，返回-1
+1 <= n <= 2 * 10^5
+1 <= 愉悦值、财富值 <= 10^9
+1 <= k <= 10^14
+
+来自CISCO
+给定两个正整数x、y，都是int整型(java里)
+返回0 ~ x以内，每位数字加起来是y的数字个数
+比如，x = 20、y = 5，返回2
+因为0 ~ x以内，每位数字加起来是5的数字有：5、14
+x、y范围是java里正整数的范围
+x <= 2 * 10^9
+y <= 90
+
+给你下标从 0 开始、长度为 n 的字符串 pattern ，
+它包含两种字符，'I' 表示 上升 ，'D' 表示 下降 。
+你需要构造一个下标从 0 开始长度为 n + 1 的字符串，且它要满足以下条件：
+num 包含数字 '1' 到 '9' ，其中每个数字 至多 使用一次。
+如果 pattern[i] == 'I' ，那么 num[i] < num[i + 1] 。
+如果 pattern[i] == 'D' ，那么 num[i] > num[i + 1] 。
+请你返回满足上述条件字典序 最小 的字符串 num。
+测试链接 : https://leetcode.cn/problems/construct-smallest-number-from-di-string/
+
+
+
+第048节 2022年11月第3周流行算法题目解析
+
+来自亚马逊
+给定一个字符串数组strs，其中每个字符串都是小写字母组成的
+如果i < j，并且strs[i]和strs[j]所有的字符随意去排列能组成回文串
+那么说(i,j)叫做一个互补对(complementary)
+求strs中有多少个互补对
+strs长度 <= 3 * 10^5
+单个字符串长度 <= 10^5
+strs里所有字符串总长度 <= 10^6
+
+n对情侣坐在连续排列的 2n 个座位上，想要牵到对方的手
+人和座位由一个整数数组 row 表示，其中 row[i] 是坐在第 i 个座位上的人的ID
+情侣们按顺序编号，第一对是 (0, 1)，第二对是 (2, 3)，以此类推，最后一对是 (2n-2, 2n-1)
+返回 最少交换座位的次数，以便每对情侣可以并肩坐在一起
+每次交换可选择任意两人，让他们站起来交换座位
+测试链接 : https://leetcode.cn/problems/couples-holding-hands/
+
+来自谷歌
+给定一个长度为N的数组，值一定在0~N-1范围，且每个值不重复
+比如，arr = [4, 2, 0, 3, 1]
+把0想象成洞，任何非0数字都可以来到这个洞里，然后在原本的位置留下洞
+比如4这个数字，来到0所代表的洞里，那么数组变成 : 
+arr = [0, 2, 4, 3, 1]
+也就是原来的洞被4填满，4走后留下了洞
+任何数字只能搬家到洞里，并且走后留下洞
+通过搬家的方式，想变成有序的，有序有两种形式
+比如arr = [4, 2, 0, 3, 1]，变成
+[0, 1, 2, 3, 4]或者[1, 2, 3, 4, 0]都叫有序
+返回变成任何一种有序的情况都可以，最少的数字搬动次数
+测试链接 : https://leetcode.cn/problems/sort-array-by-moving-items-to-empty-space/
+
+设计一个包含一些单词的特殊词典，并能够通过前缀和后缀来检索单词。
+实现 WordFilter 类：
+WordFilter(string[] words) 使用词典中的单词 words 初始化对象
+f(string pref, string suff) 
+返回词典中具有前缀 prefix 和后缀 suff 的单词的下标
+如果存在不止一个满足要求的下标，返回其中 最大的下标
+如果不存在这样的单词，返回 -1 。
+测试链接 : https://leetcode.cn/problems/prefix-and-suffix-search/
+
+设计一个叫Bank的类，并提供如下方法
+Bank(int n) 初始化的时候，准备好0、1、2 ... n-1个座位
+int hello() : 
+如果此时所有座位都无人，那么分配0号座位给当前用户
+如果此时座位上有人，那么分配一个座位，这个座位保证是所有座位中离最近的人距离最远的座位
+如果有多个座位都满足，分配座位编号最小的座位
+返回座位编号
+如果已经没有座位，返回-1表示无法分配
+void goodbye(int x) : 
+如果x号座位上无人，什么也不用做
+如果x号座位上有人，现在这个人离开了，该座位又能重新考虑分配
+举例 :
+Bank b = new Bank(10)  0~9号座位被初始化出来
+b.hello()，返回0，表示给当前用户分配了0座位
+b.hello()，返回9，因为此时9座位离0座位的人最远，此时
+0 1 2 3 4 5 6 7 8 9
+X                 X
+b.hello()，虽然座位4和座位5，离最近人的距离都是4(最远)
+这种情况，根据描述，分配座位编号最小的座位，返回4，此时
+0 1 2 3 4 5 6 7 8 9
+X       X         X
+b.hello()，座位2、座位6、座位7，都是离最近人的距离最远的(2)
+这种情况，根据描述，分配座位编号最小的座位，返回2，此时
+0 1 2 3 4 5 6 7 8 9
+X   X   X         X
+b.goodbye(4)，4座位的人离开了，此时
+0 1 2 3 4 5 6 7 8 9
+X   X             X
+b.hello()，座位5、座位6，都是离最近人的距离最远的(3)
+这种情况，根据描述，分配座位编号最小的座位，返回5
+测试连接 : https://leetcode.cn/problems/exam-room/
+
+
+
+第049节 2022年11月第4周流行算法题目解析
+
+来自国外题目论坛
+给定一个非负数组arr
+任何两个数差值的绝对值，如果arr中没有，都要加入到arr里
+然后新的arr继续，任何两个数差值的绝对值，如果arr中没有，都要加入到arr里
+一直到arr大小固定
+请问最终arr长度是多少
+1 <= arr的长度 <= 10^5
+0 <= arr的数值 <= 10^5
+
+来自字节
+11.02笔试
+leetcode原题
+有一堆石头，用整数数组 stones 表示
+其中 stones[i] 表示第 i 块石头的重量。
+每一回合，从中选出任意两块石头，然后将它们一起粉碎
+假设石头的重量分别为 x 和 y，且 x <= y
+那么粉碎的可能结果如下：
+如果 x == y，那么两块石头都会被完全粉碎；
+如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
+最后，最多只会剩下一块 石头
+返回此石头 最小的可能重量
+如果没有石头剩下，就返回 0
+测试链接 : https://leetcode.cn/problems/last-stone-weight-ii/
+
+给你两个正整数数组 nums 和 target ，两个数组长度相等。
+在一次操作中，你可以选择两个 不同 的下标 i 和 j ，
+其中 0 <= i, j < nums.length ，并且：
+令 nums[i] = nums[i] + 2 且
+令 nums[j] = nums[j] - 2 。
+如果两个数组中每个元素出现的频率相等，我们称两个数组是 相似 的。
+请你返回将 nums 变得与 target 相似的最少操作次数。
+测试数据保证 nums 一定能变得与 target 相似。
+测试链接 : https://leetcode.cn/problems/minimum-number-of-operations-to-make-arrays-similar/
+
+给定你一个整数数组 nums
+我们要将 nums 数组中的每个元素移动到 A 集合 或者 B 集合中
+使得 A 集合和 B 集合不为空，并且 average(A) == average(B)
+如果可以完成则返回true，否则返回false。
+注意：对于数组 arr,  average(arr) 是 arr 的所有元素的和除以 arr 长度。
+测试链接 : https://leetcode.cn/problems/split-array-with-same-average/
+
+来自第四届全国大学生算法设计与编程挑战赛（秋季赛）
+给定两个长度为N的数组，a[]和b[]
+也就是对于每个位置i来说，有a[i]和b[i]两个属性
+现在想为了i，选一个最好的j位置，搭配能得到最小的如下值: 
+(a[i] + a[j]) ^ 2 + b[i] + b[j]
+我们把这个最小的值，定义为i的最in值
+比如 : 
+a = {   2,  3,  6,  5,   1 }
+b = { 100, 70, 20, 40, 150 }
+        0   1   2   3    4
+0位置和2位置搭配，可以得到最in值 : 184
+1位置和2位置搭配，可以得到最in值 : 171
+2位置和1位置搭配，可以得到最in值 : 171
+3位置和1位置搭配，可以得到最in值 : 174
+4位置和2位置搭配，可以得到最in值 : 219
+注意 : i位置可以和i位置(自己)搭配，并不是说i和j一定要是不同的位置
+返回每个位置i的最in值
+比如上面的例子，最后返回[184, 171, 171, 174, 219]
+1 <= N <= 10^5
+1 <= a[i]、b[i] <= 10^9
+
+
+
+第050节 2022年11月第5周流行算法题目解析
+
+来自学员问题
+给定一个数组componets，长度为A，
+componets[i] = j，代表i类型的任务需要耗时j
+给定一个二维数组orders，长度为M，
+orders[i][0]代表i号订单下单时间
+orders[i][1]代表i号订单是哪种类型的任务，毫无疑问orders[i][1] < A
+一开始所有流水线都在0时刻待命，
+给定一个正数nums，表示流水线的数量，流水线编号为0 ~ nums-1
+每一个流水线可以承接任何类型的任务，耗时就是componets数组给定的
+所有订单的下单时间一定是有序的，也就是orders数组，是根据下单时间排序的
+每一个订单开始执行的时间不能早于下单时间，
+如果有多个流水线都可以执行当前订单，选择编号最小的流水线
+根据上面说的任务执行细节，去依次完成所有订单
+返回长度为M的数组ans，也就是和orders等长
+ans[i][0]代表i号订单是由哪条流水线执行的
+ans[i][1]代表i号订单的完成时间
+1 <= A <= 10^5
+1 <= M <= 10^5
+1 <= nums <= 10^5
+1 <= 时间数值 <= 10^5
+
+将一个给定字符串 s 根据给定的行数 numRows
+以从上往下、从左到右进行 Z 字形排列
+比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下
+P   A   H   N
+A P L S I I G
+Y   I   R
+之后，你的输出需要从左往右逐行读取，产生出一个新的字符串
+"PAHNAPLSIIGYIR"
+请你实现这个将字符串进行指定行数变换的函数
+string convert(string s, int numRows)
+测试链接 : https://leetcode.cn/problems/zigzag-conversion/
+
+一个序列的 宽度 定义为该序列中最大元素和最小元素的差值。
+给你一个整数数组 nums ，返回 nums 的所有非空 子序列 的 宽度之和
+由于答案可能非常大，请返回对 109 + 7 取余 后的结果。
+子序列 定义为从一个数组里删除一些（或者不删除）元素，
+但不改变剩下元素的顺序得到的数组
+例如，[3,6,2,7] 就是数组 [0,3,1,6,2,2,7] 的一个子序列。
+测试链接 : https://leetcode.cn/problems/sum-of-subsequence-widths/
+
+给你一个整数 n ，
+请你在无限的整数序列 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]
+中找出并返回第 n 位上的数字。
+测试链接 : https://leetcode.cn/problems/nth-digit/
+1 <= n <= 2^31 - 1
+
+
+
+第051节 2022年12月第1周流行算法题目解析
+
+如果一个正整数每一个数位都是 互不相同 的，我们称它是 特殊整数 。
+给你一个正整数 n ，请你返回区间 [1, n] 之间特殊整数的数目。
+测试链接 : https://leetcode.cn/problems/count-special-integers/
+
+给你一棵 二叉树 的根节点 root ，树中有 n 个节点
+每个节点都可以被分配一个从 1 到 n 且互不相同的值
+另给你一个长度为 m 的数组 queries
+你必须在树上执行 m 个 独立 的查询，其中第 i 个查询你需要执行以下操作：
+从树中 移除 以 queries[i] 的值作为根节点的子树
+题目所用测试用例保证 queries[i] 不 等于根节点的值。
+返回一个长度为 m 的数组 answer ，其中 answer[i] 是执行第 i 个查询后树的高度。
+注意：
+查询之间是独立的，所以在每个查询执行后，树会回到其 初始 状态。
+树的高度是从根到树中某个节点的 最长简单路径中的边数 。
+测试链接 : https://leetcode.cn/problems/height-of-binary-tree-after-subtree-removal-queries/
+
+给定一个无向、连通的树
+树中有 n 个标记为 0...n-1 的节点以及 n-1 条边 。
+给定整数 n 和数组 edges ，
+edges[i] = [ai, bi]表示树中的节点 ai 和 bi 之间有一条边。
+返回长度为 n 的数组 answer ，其中 answer[i] : 
+树中第 i 个节点与所有其他节点之间的距离之和。
+测试链接 : https://leetcode.cn/problems/sum-of-distances-in-tree/
+
+X轴上有一些机器人和工厂。给你一个整数数组robot，其中robot[i]是第i个机器人的位置
+再给你一个二维整数数组factory，其中 factory[j] = [positionj, limitj]
+表示第 j 个工厂的位置在 positionj ，且第 j 个工厂最多可以修理 limitj 个机器人
+每个机器人所在的位置 互不相同。每个工厂所在的位置也互不相同
+注意一个机器人可能一开始跟一个工厂在相同的位置
+所有机器人一开始都是坏的，他们会沿着设定的方向一直移动
+设定的方向要么是 X 轴的正方向，要么是 X 轴的负方向
+当一个机器人经过一个没达到上限的工厂时，这个工厂会维修这个机器人，且机器人停止移动
+任何时刻，你都可以设置 部分 机器人的移动方向
+你的目标是最小化所有机器人总的移动距离
+请你返回所有机器人移动的最小总距离
+注意：
+所有机器人移动速度相同
+如果两个机器人移动方向相同，它们永远不会碰撞
+如果两个机器人迎面相遇，它们也不会碰撞，它们彼此之间会擦肩而过
+如果一个机器人经过了一个已经达到上限的工厂，机器人会当作工厂不存在，继续移动
+机器人从位置 x 到位置 y 的移动距离为 |y - x|
+1 <= robot.length, factory.length <= 100
+factory[j].length == 2
+-10^9 <= robot[i], positionj <= 10^9
+0 <= limitj <= robot.length
+测试数据保证所有机器人都可以被维修
+测试链接 : https://leetcode.cn/problems/minimum-total-distance-traveled/
+
+不打算讲了，非常难
+蓝桥杯练习题
+洛谷原题
+等差数列的概念人人都知道
+给定一个原始数组arr，长度为N
+并且实现如下两个操作 : 
+void add(int l, int r, int a, int b) : 
+表示在arr[l...r]这个范围上，
+从左往右依次加 : a、a + b * 1、a + b*2、...、a + b*(r-l)
+int number(int l, int r) :
+表示arr[l...r]这一段，最少可以划分成几个等差数列
+这两个方法都要求实现的特别高效，因为调用次数很多
+N <= 100000
+add调用次数 <= 100000
+number调用次数 <= 100000
+测试链接 : https://www.luogu.com.cn/problem/P4243
+
+
+
+第052节 2022年12月第2周流行算法题目解析
+
+有100个犯人被关在监狱里，编号0~99
+监狱长构思了一个处决犯人的计划
+监狱长准备了100个盒子，每个盒子里面装有一个犯人的名字
+一开始每个犯人都知道自己的盒子在哪
+因为自己的编号，与盒子的编号一致，
+这100个盒子排成一排，放在一个房间里面，盒子编号0~99，从左到右排列
+监狱长彻底随机的打乱了盒子的排列，并且犯人并没有看到打乱的过程
+监狱长规定，每个犯人依次进入房间，每个犯人都可以开启50个盒子，然后关上
+每一个犯人全程无法进行任何交流，完全无法传递任何信息
+监狱长规定，每个犯人在尝试50次的过程中，都需要找到自己的名字
+如果有哪怕一个犯人没有做到这一点，100个罪犯全部处决
+但是监狱长允许这个游戏开始之前，所有犯人在一起商量策略
+请尽量制定一个让所有人存活概率最大的策略
+来自论文<The Cell Probe Complexity of Succinct Data Structures>
+作者Anna Gal和Peter Bro Miltersen写于2007年
+如今该题变成了流行科普视频，我们来玩一玩
+
+来自亚马逊、谷歌、微软、Facebook、Bloomberg
+给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。
+返回执行此操作后，grid 中最大的岛屿面积是多少？
+岛屿 由一组上、下、左、右四个方向相连的 1 形成。
+测试链接 : https://leetcode.cn/problems/making-a-large-island/
+
+我们定义了一个函数 countUniqueChars(s) 来统计字符串 s 中的唯一字符，
+并返回唯一字符的个数。
+例如：s = "LEETCODE" ，则其中 "L", "T","C","O","D" 都是唯一字符，
+因为它们只出现一次，所以 countUniqueChars(s) = 5 。
+本题将会给你一个字符串 s ，我们需要返回 countUniqueChars(t) 的总和，
+其中 t 是 s 的子字符串。输入用例保证返回值为 32 位整数。
+注意，某些子字符串可能是重复的，但你统计时也必须算上这些重复的子字符串
+（也就是说，你必须统计 s 的所有子字符串中的唯一字符）。
+测试链接 : https://leetcode.cn/problems/count-unique-characters-of-all-substrings-of-a-given-string/
+
+石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，爱丽丝先开始 。
+有 n 块石子排成一排。
+每个玩家的回合中，可以从行中 移除 最左边的石头或最右边的石头，
+并获得与该行中剩余石头值之 和 相等的得分。当没有石头可移除时，得分较高者获胜。
+鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），
+所以他决定尽力 减小得分的差值 。爱丽丝的目标是最大限度地 扩大得分的差值 。
+给你一个整数数组 stones ，其中 stones[i] 表示 从左边开始 的第 i 个石头的值，
+如果爱丽丝和鲍勃都 发挥出最佳水平 ，请返回他们 得分的差值 。
+测试链接 : https://leetcode.cn/problems/stone-game-vii/
+
+给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表
+如果在二叉树中，存在一条一直向下的路径
+且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True
+否则返回 False 。
+一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。
+测试链接 : https://leetcode.cn/problems/linked-list-in-binary-tree/
+最优解是KMP算法来解
+官方题解都没有写的最优解
+如果二叉树节点数是N，链表节点数M，时间复杂度为O(M+N)
+
+
+
+第053节 2022年12月第4周流行算法题目解析
+
+给你一个 m x n 的二进制矩阵 grid
+每个格子要么为 0 （空）要么为 1 （被占据）
+给你邮票的尺寸为 stampHeight x stampWidth
+我们想将邮票贴进二进制矩阵中，且满足以下 限制 和 要求 ：
+覆盖所有空格子，不覆盖任何被占据的格子
+可以放入任意数目的邮票，邮票可以相互有重叠部分
+邮票不允许旋转，邮票必须完全在矩阵内
+如果在满足上述要求的前提下，可以放入邮票，请返回 true ，否则返回 false
+测试链接 : https://leetcode.cn/problems/stamping-the-grid/
+
+Floyd算法解析
+本题测试链接 : https://www.luogu.com.cn/problem/P2910
+
+Floyd算法应用
+存在一个由 n 个节点组成的无向连通图，图中的节点按从 0 到 n - 1 编号
+给你一个数组 graph 表示这个图
+其中，graph[i] 是一个列表，由所有与节点 i 直接相连的节点组成
+返回能够访问所有节点的最短路径的长度
+你可以在任一节点开始和停止，也可以多次重访节点，并且可以重用边
+测试链接 : https://leetcode.cn/problems/shortest-path-visiting-all-nodes/
+
+你现在手里有一份大小为 n x n 的 网格 grid
+上面的每个 单元格 都用 0 和 1 标记好了其中 0 代表海洋，1 代表陆地。
+请你找出一个海洋单元格，这个海洋单元格到离它最近的陆地单元格的距离是最大的
+并返回该距离。如果网格上只有陆地或者海洋，请返回 -1。
+我们这里说的距离是「曼哈顿距离」（ Manhattan Distance）：
+(x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。
+测试链接 : https://leetcode.cn/problems/as-far-from-land-as-possible/
+
+你的赛车可以从位置 0 开始，并且速度为 +1 ，在一条无限长的数轴上行驶
+赛车也可以向负方向行驶
+赛车可以按照由加速指令 'A' 和倒车指令 'R' 组成的指令序列自动行驶。
+当收到指令 'A' 时，赛车这样行驶：
+position += speed
+speed *= 2
+当收到指令 'R' 时，赛车这样行驶：
+如果速度为正数，那么speed = -1
+否则 speed = 1
+当前所处位置不变。
+例如，在执行指令 "AAR" 后，赛车位置变化为 0 --> 1 --> 3 --> 3
+速度变化为 1 --> 2 --> 4 --> -1
+给你一个目标位置 target ，返回能到达目标位置的最短指令序列的长度。
+测试链接 : https://leetcode.cn/problems/race-car/
+
+对于某些非负整数 k ，如果交换 s1 中两个字母的位置恰好 k 次
+能够使结果字符串等于 s2 ，则认为字符串 s1 和 s2 的 相似度为 k
+给你两个字母异位词 s1 和 s2 ，返回 s1 和 s2 的相似度 k 的最小值
+测试链接 : https://leetcode.cn/problems/k-similar-strings/
+
+
+
+第054节 2023年1月第1周流行算法题目解析
+
+给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。
+请你找到这个数组里第 k 个缺失的正整数。
+测试链接 : https://leetcode.cn/problems/kth-missing-positive-number/
+
+一个正整数如果能被 a 或 b 整除，那么它是神奇的。
+给定三个整数 n , a , b ，返回第 n 个神奇的数字。
+因为答案可能很大，所以返回答案 对 10^9 + 7 取模 后的值。
+测试链接 : https://leetcode.cn/problems/nth-magical-number/
+
+有 n 名工人。 给定两个数组 quality 和 wage ，
+其中，quality[i] 表示第 i 名工人的工作质量，其最低期望工资为 wage[i] 。
+现在我们想雇佣 k 名工人组成一个工资组。在雇佣 一组 k 名工人时，
+我们必须按照下述规则向他们支付工资：
+对工资组中的每名工人，应当按其工作质量与同组其他工人的工作质量的比例来支付工资。
+工资组中的每名工人至少应当得到他们的最低期望工资。
+给定整数 k ，返回 组成满足上述条件的付费群体所需的最小金额
+测试链接 : https://leetcode.cn/problems/minimum-cost-to-hire-k-workers/
+
+汽车从起点出发驶向目的地，该目的地位于出发位置东面 target 英里处。
+沿途有加油站，每个 station[i] 代表一个加油站，
+它位于出发位置东面 station[i][0] 英里处，并且有 station[i][1] 升汽油。
+假设汽车油箱的容量是无限的，其中最初有 startFuel 升燃料。
+它每行驶 1 英里就会用掉 1 升汽油。
+当汽车到达加油站时，它可能停下来加油，将所有汽油从加油站转移到汽车中。
+为了到达目的地，汽车所必要的最低加油次数是多少？如果无法到达目的地，则返回 -1 。
+注意：如果汽车到达加油站时剩余燃料为 0，它仍然可以在那里加油。
+如果汽车到达目的地时剩余燃料为 0，仍然认为它已经到达目的地。
+测试链接 : https://leetcode.cn/problems/minimum-number-of-refueling-stops/
+
+给定一个字符串 s 和一个整数 k 。你可以从 s 的前 k 个字母中选择一个
+并把它加到字符串的末尾
+返回 在应用上述步骤的任意数量的移动后，字典上最小的字符串
+测试链接 : https://leetcode.cn/problems/orderly-queue/
+
+给定一个长度为 n 的字符串 s ，其中 s[i] 是:
+D 意味着减少
+I 意味着增加
+有效排列 是对有 n + 1 个在 [0, n]  范围内的整数的一个排列 perm ，使得对所有的 i：
+如果 s[i] == 'D'，那么 perm[i] > perm[i+1]，以及；
+如果 s[i] == 'I'，那么 perm[i] < perm[i+1]。
+返回 有效排列  perm的数量 。因为答案可能很大，所以请返回你的答案对 10^9 + 7 取余。
+测试链接 : https://leetcode.cn/problems/valid-permutations-for-di-sequence/
+
+
+
+第055节 2023年1月第2周流行算法题目解析
+
+如果交换字符串 X 中的两个不同位置的字母，使得它和字符串 Y 相等，
+那么称 X 和 Y 两个字符串相似。如果这两个字符串本身是相等的，那它们也是相似的。
+例如，"tars" 和 "rats" 是相似的 (交换 0 与 2 的位置)；
+"rats" 和 "arts" 也是相似的，但是 "star" 不与 "tars"，"rats"，或 "arts" 相似。
+总之，它们通过相似性形成了两个关联组：{"tars", "rats", "arts"} 和 {"star"}。
+注意，"tars" 和 "arts" 是在同一组中，即使它们并不相似。
+形式上，对每个组而言，要确定一个单词在组中，只需要这个词和该组中至少一个单词相似。
+给你一个字符串列表 strs。列表中的每个字符串都是 strs 中其它所有字符串的一个字母异位词。
+请问 strs 中有多少个相似字符串组？
+测试链接 : https://leetcode.cn/problems/similar-string-groups/
+
+设计一个类似堆栈的数据结构，将元素推入堆栈，并从堆栈中弹出出现频率最高的元素。
+实现 FreqStack 类:
+FreqStack() 构造一个空的堆栈。
+void push(int val) 将一个整数 val 压入栈顶。
+int pop() 删除并返回堆栈中出现频率最高的元素。
+如果出现频率最高的元素不只一个，则移除并返回最接近栈顶的元素。
+测试链接 : https://leetcode.cn/problems/maximum-frequency-stack/
+
+给定一个正整数 x，我们将会写出一个形如 x (op1) x (op2) x (op3) x ... 的表达式
+其中每个运算符 op1，op2，… 可以是加、减、乘、除之一
+例如，对于 x = 3，我们可以写出表达式 3 * 3 / 3 + 3 - 3，该式的值为3
+在写这样的表达式时，我们需要遵守下面的惯例：
+除运算符（/）返回有理数
+任何地方都没有括号
+我们使用通常的操作顺序：乘法和除法发生在加法和减法之前
+不允许使用一元否定运算符（-）。例如，“x - x” 是一个有效的表达
+因为它只使用减法，但是 “-x + x” 不是，因为它使用了否定运算符
+我们希望编写一个能使表达式等于给定的目标值 target 且运算符最少的表达式
+返回所用运算符的最少数量
+测试链接 : https://leetcode.cn/problems/least-operators-to-express-number/
+
+给你一个只包含小写英文字母的字符串 s 。
+每一次 操作 ，你可以选择 s 中两个 相邻 的字符，并将它们交换。
+请你返回将 s 变成回文串的 最少操作次数 。
+注意 ，输入数据会确保 s 一定能变成一个回文串。
+测试链接 : https://leetcode.cn/problems/minimum-number-of-moves-to-make-palindrome/
+
+一条单向的铁路线上，火车站编号为1~n
+每个火车站都有一个级别，最低为 1 级。
+现有若干趟车次在这条线路上行驶，
+每一趟都满足如下要求：
+如果这趟车次停靠了火车站 x，则始发站、终点站之间所有级别大于等于火车站x的都必须停靠。
+(注意：起始站和终点站自然也算作事先已知需要停靠的站点）
+现有 m 趟车次的运行情况（全部满足要求），
+试推算这n个火车站至少分为几个不同的级别。
+测试链接 : https://www.luogu.com.cn/problem/P1983
+
+
+
+第056节 2023年2月第1周流行算法题目解析
+
+给你一个由 n 个正整数组成的数组 nums
+你可以对数组的任意元素执行任意次数的两类操作
+如果元素是 偶数 ，除以 2
+例如，如果数组是 [1,2,3,4]
+那么你可以对最后一个元素执行此操作使其变成 [1,2,3,2]
+如果元素是 奇数 ，乘上 2
+例如，如果数组是 [1,2,3,4] ，那么你可以对第一个元素执行此操作，使其变成 [2,2,3,4]
+数组的 偏移量 是数组中任意两个元素之间的 最大差值
+返回数组在执行某些操作之后可以拥有的 最小偏移量
+测试链接 : https://leetcode.cn/problems/minimize-deviation-in-array/
+
+给定一个整数数组 A，你可以从某一起始索引出发，跳跃一定次数
+在你跳跃的过程中，第 1、3、5... 次跳跃称为奇数跳跃
+而第 2、4、6... 次跳跃称为偶数跳跃
+你可以按以下方式从索引 i 向后跳转到索引 j（其中 i < j）：
+在进行奇数跳跃时（如，第 1，3，5... 次跳跃），你将会跳到索引 j
+使得 A[i] <= A[j]，A[j] 是可能的最小值。如果存在多个这样的索引 j
+你只能跳到满足要求的最小索引 j 上。
+在进行偶数跳跃时（如，第 2，4，6... 次跳跃）
+你将会跳到索引 j，使得 A[i] >= A[j]，A[j] 是可能的最大值
+如果存在多个这样的索引 j，你只能跳到满足要求的最小索引 j 上。
+对于某些索引 i，可能无法进行合乎要求的跳跃
+如果从某一索引开始跳跃一定次数（可能是 0 次或多次）
+就可以到达数组的末尾（索引 A.length - 1）
+那么该索引就会被认为是好的起始索引
+返回好的起始索引的数量
+测试链接 : https://leetcode.cn/problems/odd-even-jump/
+
+给定一个二进制数组 nums 和一个整数 k
+k位翻转 就是从 nums 中选择一个长度为 k 的 子数组
+同时把子数组中的每一个 0 都改成 1 ，把子数组中的每一个 1 都改成 0
+返回数组中不存在 0 所需的最小 k位翻转 次数。如果不可能，则返回 -1
+子数组 是数组的 连续 部分。
+测试链接 : https://leetcode.cn/problems/minimum-number-of-k-consecutive-bit-flips/
+
+一共有 4 种硬币。面值分别为c1、c2、c3、c4
+一开始就给定了，就是这些面值不再改变
+某人去商店买东西，去了 n 次，
+每次都是一次查询：
+这个人每次代的每种硬币的数量不一样，都记录在d数组中
+1) d[i]表示他带了的i种面值的数量
+2) 他要购买s价值的东西
+返回每次有多少种购买方法
+1 <= c1、c2、c3、c4、d[i]、s <= 10^5
+1 <= n <= 1000
+测试链接 : https://www.luogu.com.cn/problem/P1450
+
+
+
+第057节 2023年2月第2周流行算法题目解析
+
+你的音乐播放器里有 N 首不同的歌
+在旅途中，你的旅伴想要听 L 首歌（不一定不同，即，允许歌曲重复
+请你为她按如下规则创建一个播放列表
+每首歌至少播放一次
+一首歌只有在其他 K 首歌播放完之后才能再次播放
+返回可以满足要求的播放列表的数量
+由于答案可能非常大，请返回它模 10^9 + 7 的结果
+测试链接 : https://leetcode.cn/problems/number-of-music-playlists/
+
+给你二叉树的根结点 root ，请你设计算法计算二叉树的 垂序遍历 序列。
+对位于 (row, col) 的每个结点而言，
+其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1)
+树的根结点位于 (0, 0) 。
+二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，
+形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，
+则按结点的值从小到大进行排序。
+返回二叉树的 垂序遍历 序列。
+测试链接 : https://leetcode.cn/problems/vertical-order-traversal-of-a-binary-tree/
+
+给你一棵二叉树的根节点 root ，返回树的 最大宽度 。
+树的 最大宽度 是所有层中最大的 宽度 。
+每一层的 宽度 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。
+将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 null 节点，
+这些 null 节点也计入长度。
+题目数据保证答案将会在  32 位 带符号整数范围内。
+测试链接 : https://leetcode.cn/problems/maximum-width-of-binary-tree/
+
+给定一个由 n 个节点组成的网络，用 n x n 个邻接矩阵 graph 表示
+在节点网络中，只有当 graph[i][j] = 1 时，节点 i 能够直接连接到另一个节点 j。
+一些节点 initial 最初被恶意软件感染。只要两个节点直接连接，
+且其中至少一个节点受到恶意软件的感染，那么两个节点都将被恶意软件感染。
+这种恶意软件的传播将继续，直到没有更多的节点可以被这种方式感染。
+假设 M(initial) 是在恶意软件停止传播之后，整个网络中感染恶意软件的最终节点数。
+我们可以从 initial 中删除一个节点，
+并完全移除该节点以及从该节点到任何其他节点的任何连接。
+请返回移除后能够使 M(initial) 最小化的节点。
+如果有多个节点满足条件，返回索引 最小的节点 。
+initial 中每个整数都不同
+测试链接 : https://leetcode.cn/problems/minimize-malware-spread-ii/
+
+
+
+第058节 2023年2月第3周流行算法题目解析
+
+如果一个正整数自身是回文数，而且它也是一个回文数的平方，那么我们称这个数为超级回文数。
+现在，给定两个正整数 L 和 R （以字符串形式表示），
+返回包含在范围 [L, R] 中的超级回文数的数目。
+测试链接 : https://leetcode.cn/problems/super-palindromes/
+
+我们从二叉树的根节点 root 开始进行深度优先搜索。
+在遍历中的每个节点处，我们输出 D 条短划线（其中 D 是该节点的深度）
+然后输出该节点的值。（如果节点的深度为 D，则其直接子节点的深度为 D + 1
+根节点的深度为 0
+如果节点只有一个子节点，那么保证该子节点为左子节点
+给出遍历输出 S，还原树并返回其根节点 root。
+测试链接 : https://leetcode.cn/problems/recover-a-tree-from-preorder-traversal/
+
+给你一份工作时间表 hours，上面记录着某一位员工每天的工作小时数。
+我们认为当员工一天中的工作小时数大于 8 小时的时候，那么这一天就是「劳累的一天」。
+所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。
+请你返回「表现良好时间段」的最大长度。
+测试链接 : https://leetcode.cn/problems/longest-well-performing-interval/
+
+来自TikTok美国笔试
+给定一个长度为N的一维数组scores, 代表0~N-1号员工的初始得分
+scores[i] = a, 表示i号员工一开始得分是a
+给定一个长度为M的二维数组operations,
+operations[i] = {a, b, c}
+表示第i号操作为 : 
+如果a==1, 表示将目前分数<b的所有员工，分数改成b，c这个值无用
+如果a==2, 表示将编号为b的员工，分数改成c
+所有操作从0~M-1, 依次发生
+返回一个长度为N的一维数组ans，表示所有操作做完之后，每个员工的得分是多少
+1 <= N <= 10的6次方
+1 <= M <= 10的6次方
+0 <= 分数 <= 10的9次方
+
+来自TikTok美国笔试
+给定一个长度为N的数组arr，arr[i]表示宝石的价值
+你在某天遇到X价值的宝石，
+X价值如果是所有剩余宝石价值中的最小值，你会将该宝石送人
+X价值如果不是所有剩余宝石价值中的最小值，你会将该宝石放到所有宝石的最后
+返回把宝石都送人需要多少天
+比如arr = [3,1,4,3,1,2]
+在第1天，你遇到了价值3的宝石，但是3并不是所有剩余宝石的价值最小值
+所以你把3放在了所有宝石的最后，arr = [1,4,3,1,2,3]
+在第2天，你遇到了价值1的宝石，1是所有剩余宝石的价值最小值
+所以你把价值1的宝石送人，arr = [4,3,1,2,3]
+在第3天，你把价值4的宝石放到最后，arr = [3,1,2,3,4]
+在第4天，你把价值3的宝石放到最后，arr = [1,2,3,4,3]
+在第5天，你送出了价值1的宝石，arr = [2,3,4,3]
+在第6天，你送出了价值2的宝石，arr = [3,4,3]
+在第7天，你送出了价值3的宝石，arr = [4,3]
+在第8天，你把价值4的宝石放到最后，arr = [3,4]
+在第9天，你送出了价值3的宝石，arr = [4]
+在第10天，你送出了价值4的宝石，宝石已经没有了
+所以返回10
+1 <= N <= 10的5次方
+1 <= 宝石价值 <= 10的9次方
+
+
+
+第059节 2023年2月第4周流行算法题目解析
+
+一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试
+给你一个二维数组 classes ，其中 classes[i] = [passi, totali]
+表示你提前知道了第 i 个班级总共有 totali 个学生，其中只有 passi 个学生可以通过考试
+给你一个整数 extraStudents ，表示额外有 extraStudents 个聪明的学生
+他们 一定 能通过任何班级的期末考
+你需要给这 extraStudents 个学生每人都安排一个班级
+使得 所有 班级的 平均 通过率 最大 。
+一个班级的 通过率 等于这个班级通过考试的学生人数除以这个班级的总人数
+平均通过率 是所有班级的通过率之和除以班级数目。
+请你返回在安排这 extraStudents 个学生去对应班级后的 最大 平均通过率
+与标准答案误差范围在 10^-5 以内的结果都会视为正确结果。
+测试链接 : https://leetcode.cn/problems/maximum-average-pass-ratio/
+
+来自学员问题
+给你一根长度为 n 的绳子
+请把绳子剪成整数长度的 m 段
+m、n都是整数，n > 1并且m > 1
+每段绳子的长度记为 k[0],k[1]...k[m - 1]
+请问 k[0]*k[1]*...*k[m - 1] 可能的最大乘积是多少
+例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18
+答案需要取模1000000007
+测试链接 : https://leetcode.cn/problems/jian-sheng-zi-ii-lcof/
+
+在大小为 n x n 的网格 grid 上，每个单元格都有一盏灯，最初灯都处于 关闭 状态
+给你一个由灯的位置组成的二维数组 lamps
+其中 lamps[i] = [rowi, coli] 表示 打开 位于 grid[rowi][coli] 的灯
+即便同一盏灯可能在 lamps 中多次列出，不会影响这盏灯处于 打开 状态
+当一盏灯处于打开状态，它将会照亮 自身所在单元格
+以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格
+另给你一个二维数组 queries ，其中 queries[j] = [rowj, colj]
+对于第 j 个查询，如果单元格 [rowj, colj] 是被照亮的
+则查询结果为 1 ，否则为 0 。在第 j 次查询之后 [按照查询的顺序]
+关闭 位于单元格 grid[rowj][colj] 上
+及相邻 8 个方向上（与单元格 grid[rowi][coli] 共享角或边）的任何灯
+返回一个整数数组 ans 作为答案， ans[j] 应等于第 j 次查询 queries[j] 的结果
+1 表示照亮，0 表示未照亮
+测试链接 : https://leetcode.cn/problems/grid-illumination/
+
+你想要用小写字母组成一个目标字符串 target。 
+开始的时候，序列由 target.length 个 '?' 记号组成
+而你有一个小写字母印章 stamp。
+在每个回合，你可以将印章放在序列上，并将序列中的每个字母替换为印章上的相应字母
+你最多可以进行 10 * target.length  个回合
+举个例子，如果初始序列为 "?????"，而你的印章 stamp 是 "abc"
+那么在第一回合，你可以得到 "abc??"、"?abc?"、"??abc"
+（请注意，印章必须完全包含在序列的边界内才能盖下去。）
+如果可以印出序列，那么返回一个数组，该数组由每个回合中被印下的最左边字母的索引组成
+如果不能印出序列，就返回一个空数组。
+例如，如果序列是 "ababc"，印章是 "abc"
+那么我们就可以返回与操作 "?????" -> "abc??" -> "ababc" 相对应的答案 [0, 2]
+另外，如果可以印出序列，那么需要保证可以在 10 * target.length 个回合内完成
+任何超过此数字的答案将不被接受
+测试链接 : https://leetcode.cn/problems/stamping-the-sequence/
+
+给你一个 rows * cols 大小的矩形披萨和一个整数 k
+矩形包含两种字符： 'A' （表示苹果）和 '.' （表示空白格子）
+你需要切披萨 k-1 次，得到 k 块披萨并送给别人
+切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置
+将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人
+如果水平地切，那么需要把上面的部分送给一个人
+在切完最后一刀后，需要把剩下来的一块送给最后一个人
+请你返回确保每一块披萨包含 至少 一个苹果的切披萨方案数
+由于答案可能是个很大的数字，请你返回它对 10^9 + 7 取余的结果
+测试链接 : https://leetcode.cn/problems/number-of-ways-of-cutting-a-pizza/
+
+
+
+第060节 2023年3月第1周流行算法题目解析
+
+来自学员问题
+给定一个1~N的排列，每次将相邻两数相加，可以得到新的序列，长度是N-1
+再对新的序列，每次将相邻两数相加，可以得到新的序列，长度是N-2
+这样下去可以最终只剩一个数字
+比如 : 
+3 1 2 4
+ 4 3 6
+  7 9
+   16
+现在如果知道N，和最后的数字sum，反推最原始的序列是什么
+如果有多个答案，返回字典序最小的那个
+字典序看做所有数字拼起来的字符串字典序
+比如
+1, 10, 2... 拼起来是 1102...
+1, 2, 3, 4... 拼起来是 1234...
+认为 1, 10, 2...的字典序更小
+如果给定的n和sum，有答案，返回一个N长度的答案数组
+如果给定的n和sum，无答案，返回一个1长度的数组{ -1 }
+输入 : N = 4, sum = 16
+输出 : 3 1 2 4
+输入 : N = 10, sum = 4116
+输出 : 1 3 5 7 10 9 8 6 4 2 
+0 < n <= 10, sum随意
+
+来自学员问题，国外算法面经帖子上的题
+给定一个数组A, 把它分成两个数组B和C
+对于数组A每个i位置的数来说，
+A[i] = B[i] + C[i]
+也就是一个数字分成两份，然后各自进入B和C
+要求B[i], C[i] >= 1
+最终B数组要求从左到右不能降序
+最终C数组要求从左到右不能升序
+比如
+A = { 5, 4, 5 }
+可以分成
+B = { 2, 2, 3 }
+C = { 3, 2, 2 }
+这是一种有效的划分
+返回有多少种有效的划分方式
+1 <= A的长度 <= 10^7
+1 <= A[i] <= 10^7
+最终结果可能很大，请返回对1000000007取余的结果
+
+HH有一串由各种漂亮的贝壳组成的项链
+HH相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，
+思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。
+有一天，他突然提出了一个问题：某一段贝壳中，包含了多少种不同的贝壳？
+这个问题很难回答... 因为项链实在是太长了
+于是，他只好求助睿智的你，来解决这个问题
+测试链接 : https://www.luogu.com.cn/problem/P1972
+请同学们务必参考如下代码中关于输入、输出的处理
+这是输入输出处理效率很高的写法
+提交以下所有代码，把主类名改成Main
+洛谷对java太不友好了，大量时间不是消耗在算法本身上，而是耗在了IO上
+多提交几次能全通过
+
+主席树详解
+测试链接 : https://www.luogu.com.cn/problem/P3834
+请同学们务必参考如下代码中关于输入、输出的处理
+这是输入输出处理效率很高的写法
+提交以下所有代码，把主类名改成Main，可以通过
+
+
+
+第061节 2023年3月第2周流行算法题目解析
+
+爱丽丝和鲍勃继续他们的石子游戏
+许多堆石子 排成一行，每堆都有正整数颗石子 piles[i]
+游戏以谁手中的石子最多来决出胜负。
+爱丽丝和鲍勃轮流进行，爱丽丝先开始。最初，M = 1。
+在每个玩家的回合中，该玩家可以拿走剩下的 前 X 堆的所有石子，其中 1 <= X <= 2M
+然后，令 M = max(M, X)。
+游戏一直持续到所有石子都被拿走。
+假设爱丽丝和鲍勃都发挥出最佳水平
+返回爱丽丝可以得到的最大数量的石头。
+测试链接 : https://leetcode.cn/problems/stone-game-ii/
+
+给出两个字符串 str1 和 str2
+返回同时以 str1 和 str2 作为子序列的最短字符串
+如果答案不止一个，则可以返回满足条件的任意一个答案。
+测试链接 : https://leetcode.cn/problems/shortest-common-supersequence/
+体系学习班，最长公共子序列问题
+大厂刷题班，章节11，根据动态规划表，生成路径
+
+来自学员问题
+给定N、M两个参数
+一共有N个格子，每个格子可以涂上一种颜色，颜色在M种里选
+当涂满N个格子，并且M种颜色都使用了，叫一种有效方法
+求一共有多少种有效方法
+1 <= N, M <= 5000
+返回结果比较大，请把结果 % 1000000007 之后返回
+
+给定正整数 n
+返回在 [1, n] 范围内具有 至少 1 位 重复数字的正整数的个数。
+测试链接 : https://leetcode.cn/problems/numbers-with-repeated-digits/
+
+如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。
+花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串
+定义下面几条语法规则：
+如果只给出单一的元素 x，那么表达式表示的字符串就只有 "x"。R(x) = {x}
+例如，表达式 "a" 表示字符串 "a"。
+而表达式 "w" 就表示字符串 "w"。
+当两个或多个表达式并列，以逗号分隔，我们取这些表达式中元素的并集
+R({e_1,e_2,...}) = R(e_1) ∪ R(e_2) ∪ ...
+例如，表达式 "{a,b,c}" 表示字符串 "a","b","c"。
+而表达式 "{{a,b},{b,c}}" 也可以表示字符串 "a","b","c"。
+要是两个或多个表达式相接，中间没有隔开时，
+我们从这些表达式中各取一个元素依次连接形成字符串
+R(e_1 + e_2) = {a + b for (a, b) in R(e_1) × R(e_2)}
+例如，表达式 "{a,b}{c,d}" 表示字符串 "ac","ad","bc","bd"。
+表达式之间允许嵌套，单一元素与表达式的连接也是允许的。
+例如，表达式 "a{b,c,d}" 表示字符串 "ab","ac","ad"​​​​​​。
+例如，表达式 "a{b,c}{d,e}f{g,h}" 
+可以表示字符串 : 
+"abdfg", "abdfh", "abefg", "abefh",
+"acdfg", "acdfh", "acefg", "acefh"。
+给出表示基于给定语法规则的表达式 expression
+返回它所表示的所有字符串组成的有序列表。
+测试链接 : https://leetcode.cn/problems/brace-expansion-ii/
+
+
+
+第062节 2023年3月第3周流行算法题目解析
+
+给你一个 非递减 的正整数数组 nums 和整数 K
+判断该数组是否可以被分成一个或几个 长度至少 为 K 的 不相交的递增子序列
+测试链接 : https://leetcode.cn/problems/divide-array-into-increasing-sequences/
+
+来自学员问题
+真实大厂笔试题
+给定一个数组arr，长度为n
+再给定一个数字k，表示一定要将arr划分成k个集合
+每个数字只能进一个集合
+返回每个集合内部的平均值都累加起来最小的值
+平均值向下取整
+1 <= n <= 10^5
+0 <= arr[i] <= 10^5
+1 <= k <= n
+
+给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空）
+使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。
+请你返回你需要移除的最短子数组的长度，如果无法满足题目要求，返回 -1 。
+子数组 定义为原数组中连续的一组元素。
+测试链接 : https://leetcode.cn/problems/make-sum-divisible-by-p/
+
+布尔表达式 是计算结果不是 true 就是 false 的表达式
+有效的表达式需遵循以下约定：
+'t'，运算结果为 true
+'f'，运算结果为 false
+'!(subExpr)'，运算过程为对内部表达式 subExpr 进行 逻辑非（NOT）运算
+'&(subExpr1, subExpr2, ..., subExprn)'
+运算过程为对 2 个或以上内部表达式 
+subExpr1, subExpr2, ..., subExprn 进行 逻辑与（AND）运算
+'|(subExpr1, subExpr2, ..., subExprn)'
+运算过程为对 2 个或以上内部表达式
+subExpr1, subExpr2, ..., subExprn 进行 逻辑或（OR）运算
+给你一个以字符串形式表述的 布尔表达式 expression，返回该式的运算结果。
+题目测试用例所给出的表达式均为有效的布尔表达式，遵循上述约定。
+测试链接 : https://leetcode.cn/problems/parsing-a-boolean-expression/
+
+来自学员问题，大厂笔试面经帖子
+假设一共有M个车库，编号1~M，时间点从早到晚是从1~T
+一共有N个记录，每一条记录如下{a, b, c}
+表示一辆车在b时间点进入a车库，在c时间点从a车库出去
+一共有K个查询，每个查询只有一个数字X，表示请问在X时刻，
+有多少个车库包含车的数量>=3，请返回K个查询的答案
+1 <= M, N, K <= 10^5
+1 <= T <= 10^9
+
+
+
+第063节 2023年3月第4周流行算法题目解析
+
+来自学员问题
+一共有n个项目，每个项目都有两个信息
+projects[i] = {a, b}
+表示i号项目做完要a天，但是当你投入b个资源，它就会缩短1天的时间
+你一共有k个资源，你的目标是完成所有的项目，但是希望总天数尽可能缩短
+在所有项目同时开工的情况下，返回尽可能少的天数
+1 <= n <= 10^5
+1 <= k <= 10^7
+
+来自华为
+给你 n 个任务和 m 个工人
+每个任务需要一定的力量值才能完成
+需要的力量值保存在下标从 0 开始的整数数组 tasks 中
+第 i 个任务需要 tasks[i] 的力量才能完成
+每个工人的力量值保存在下标从 0 开始的整数数组 workers 中
+第 j 个工人的力量值为 workers[j]
+每个工人只能完成 一个 任务
+且力量值需要 大于等于 该任务的力量要求值, 即 workers[j] >= tasks[i]
+除此以外，你还有 pills 个神奇药丸
+可以给 一个工人的力量值 增加 strength
+你可以决定给哪些工人使用药丸
+但每个工人 最多 只能使用 一片 药丸
+给你下标从 0 开始的整数数组tasks 和 workers 以及
+两个整数 pills 和 strength ，请你返回 最多 有多少个任务可以被完成。
+测试链接 : https://leetcode.cn/problems/maximum-number-of-tasks-you-can-assign/
+
+你驾驶出租车行驶在一条有 n 个地点的路上
+这 n 个地点从近到远编号为 1 到 n ，你想要从 1 开到 n
+通过接乘客订单盈利。你只能沿着编号递增的方向前进，不能改变方向
+乘客信息用一个下标从 0 开始的二维数组 rides 表示
+其中 rides[i] = [starti, endi, tipi]
+表示第 i 位乘客需要从地点 starti 前往 endi
+愿意支付 tipi 元的小费
+每一位 你选择接单的乘客 i ，你可以 盈利 endi - starti + tipi 元
+你同时 最多 只能接一个订单。
+给你 n 和 rides ，请你返回在最优接单方案下，你能盈利 最多 多少元。
+注意：你可以在一个地点放下一位乘客，并在同一个地点接上另一位乘客。
+测试链接 : https://leetcode.cn/problems/maximum-earnings-from-taxi/
+
+最长可整合子数组的长度
+数组中的数字排序之后，相邻两数的差值是1
+这种数组就叫可整合数组
+给定一个数组，求最长可整合子数组的长度
+
+给你一个由数字组成的字符串 s，返回 s 中独特子字符串数量
+其中的每一个数字出现的频率都相同。
+测试链接 : https://leetcode.cn/problems/unique-substrings-with-equal-digit-frequency/
+
+
+
+第064节 2023年3月第5周流行算法题目解析
+
+来自百度
+用r、e、d三种字符，拼出一个回文子串数量等于x的字符串
+1 <= x <= 10^5
+
+来自腾讯音乐
+给定一棵树，一共有n个点
+每个点上没有值，请把1~n这些数字，不重复的分配到二叉树上
+做到 : 奇数层节点的值总和 与 偶数层节点的值总和 相差不超过1
+返回奇数层节点分配值的一个方案
+2 <= n <= 10^5
+
+来自小红书、字节跳动
+村里面一共有 n 栋房子
+我们希望通过建造水井和铺设管道来为所有房子供水。
+对于每个房子 i，我们有两种可选的供水方案：
+一种是直接在房子内建造水井
+成本为 wells[i - 1] （注意 -1 ，因为 索引从0开始 ）
+另一种是从另一口井铺设管道引水
+数组 pipes 给出了在房子间铺设管道的成本
+其中每个 pipes[j] = [house1j, house2j, costj]
+代表用管道将 house1j 和 house2j连接在一起的成本。连接是双向的。
+请返回 为所有房子都供水的最低总成本 。
+这道题很高频，引起注意
+本身也不难，转化一下变成最小生成树的问题即可
+测试链接 : https://leetcode.cn/problems/optimize-water-distribution-in-a-village/
+
+来自学员问题，蓝桥杯练习题
+小青蛙住在一条河边, 它想到河对岸的学校去学习
+小青蛙打算经过河里 的石头跳到对岸
+河里的石头排成了一条直线, 小青蛙每次跳跃必须落在一块石头或者岸上
+给定一个长度为n的数组arr，表示每块儿石头的高度数值
+每块石头有一个高度, 每次小青蛙从一块石头起跳
+这块石头的高度就会下降1, 当石头的高度下降到0时
+小青蛙不能再跳到这块石头上(跳跃后使石头高度下降到0是允许的)
+小青蛙一共需要去学校上x天课, 所以它需要往返x次(去x次，回x次)
+当小青蛙具有 一个跳跃能力y时, 它能跳不超过y的距离
+请问小青蛙的跳跃能力至少是多少才能用这些石头上完x次课
+1 <= n <= 10^5
+1 <= arr[i] <= 10^4
+1 <= x <= 10^9
+测试链接 : https://www.luogu.com.cn/problem/P8775
+
+来自谷歌
+给你一棵 n 个节点的树（连通无向无环的图）
+节点编号从 0 到 n - 1 且恰好有 n - 1 条边
+给你一个长度为 n 下标从 0 开始的整数数组 vals
+分别表示每个节点的值
+同时给你一个二维整数数组 edges
+其中 edges[i] = [ai, bi] 表示节点 ai 和 bi 之间有一条 无向 边
+一条 好路径 需要满足以下条件：
+开始节点和结束节点的值 相同 。
+开始节点和结束节点中间的所有节点值都 小于等于 开始节点的值
+也就是说开始节点的值应该是路径上所有节点的最大值
+请你返回不同好路径的数目
+注意，一条路径和它反向的路径算作 同一 路径
+比方说， 0 -> 1 与 1 -> 0 视为同一条路径。单个节点也视为一条合法路径
+测试链接 : https://leetcode.cn/problems/number-of-good-paths/
+
+
+
+第065节 2023年4月第2周流行算法题目解析
+
+来自学员问题，来自真实笔试
+景区里有m个项目，也就是项目数组为int[][] game，这是一个m*2的二维数组
+景区的第i个项目有如下两个参数：
+game[i] = { Ki, Bi } Ki一定是负数，Bi一定是正数
+举个例子 : 
+Ki = -2, Bi = 10
+如果只有1个人买票，单张门票的价格为 : Ki * 1 + Bi = 8
+所以这1个人游玩该项目要花8元
+如果有2个人买票，单张门票的价格为 : Ki * 2 + Bi = 6
+所以这2个人游玩该项目要花6 * 2 = 12元
+如果有5个人买票，单张门票的价格为 : Ki * 2 + Bi = 0
+所以这5个人游玩该项目要花0 * 5 = 0元
+如果有更多人买票，都认为花0元(因为你让项目倒贴钱实在是太操蛋了)
+于是可以认为，如果有x个人买票，单张门票的价格为 : Ki * x + Bi
+x个人游玩这个项目的总花费是 : max { (Ki * x + Bi) * x , 0 }
+你作为领导，单位一共有n个人，每个人最多可以选1个项目来游玩，也可以不选任何项目
+所有员工将在明晚提交选择，然后由你去按照上面的规则，统一花钱，统一购票
+但是现在，你想知道自己需要准备多少钱，就可以应付可能的各种情况，
+支持各种可能下的开销，返回这个最保险的钱数
+数据量描述 : 
+1 <= N、M、Bi <= 10^5
+-(10^5) <= Ki < 0
+
+来自小红书
+实验室需要配制一种溶液，现在研究员面前有n种该物质的溶液，
+每一种有无限多瓶，第i种的溶液体积为v[i]，里面含有w[i]单位的该物质
+研究员每次可以选择一瓶溶液，
+将其倒入另外一瓶（假设瓶子的容量无限），即可以看作将两个瓶子内的溶液合并
+此时合并的溶液体积和物质含量都等于之前两个瓶子内的之和。
+特别地，如果瓶子A与B的溶液体积相同，那么A与B合并之后
+该物质的含量会产生化学反应，使得该物质含量增加x单位
+研究员的任务是配制溶液体积恰好等于c的，且尽量浓的溶液(即物质含量尽量多）
+研究员想要知道物质含量最多是多少
+对于所有数据，1 <= n, v[i], w[i], x, c <= 1000
+
+来自谷歌、亚马逊、微软、蔚来、腾讯、字节跳动、Uber
+给出两个长度相同的字符串 str1 和 str2
+请你帮忙判断字符串 str1 能不能在 零次 或 多次 转化 后变成字符串 str2
+每一次转化时，你可以将 str1 中出现的 所有 相同字母变成其他 任何 小写英文字母
+只有在字符串 str1 能够通过上述方式顺利转化为字符串 str2 时才能返回 true 。​​
+测试链接 : https://leetcode.cn/problems/string-transforms-into-another-string/
+
+来自Indeed、谷歌、亚马逊、领英、英伟达
+一个坐标可以从 -infinity 延伸到 +infinity 的 无限大的 棋盘上
+你的 骑士 驻扎在坐标为 [0, 0] 的方格里。
+骑士的走法和中国象棋中的马相似，走 “日” 字：
+即先向左（或右）走 1 格，再向上（或下）走 2 格
+或先向左（或右）走 2 格，再向上（或下）走 1 格
+每次移动，他都可以像中国象棋中的马一样，选八个方向中的一个前进
+返回 骑士前去征服坐标为 [x, y] 的部落所需的最小移动次数
+本题确保答案是一定存在的。
+测试链接 : https://leetcode.cn/problems/minimum-knight-moves/
+
+来自小红书、谷歌、Bloomberg、微软、亚马逊、字节跳动、摩根大通、Uber
+你会得到一个字符串 text
+你应该把它分成 k 个子字符串 (subtext1, subtext2，…， subtextk)
+要求满足:
+subtexti 是 非空 字符串
+所有子字符串的连接等于 text 
+( 即subtext1 + subtext2 + ... + subtextk == text )
+subtexti == subtextk - i + 1 表示所有 i 的有效值( 即 1 <= i <= k )
+返回k可能最大值。
+测试链接 : https://leetcode.cn/problems/longest-chunked-palindrome-decomposition/
+
+
+
+第066节 2023年4月第3周流行算法题目解析
+
+来自华为OD
+完美走位问题
+给定一个由'W'、'A'、'S'、'D'四种字符组成的字符串，长度一定是4的倍数
+你可以把任意连续的一段子串，变成'W'、'A'、'S'、'D'组成的随意状态
+目的是让4种字符词频一样
+返回需要修改的最短子串长度
+找到了出处，是leetcode原题
+测试链接 : https://leetcode.cn/problems/replace-the-substring-for-balanced-string/
+
+来自腾讯笔试
+给定一个长度为N的正数数组，还有一个正数K
+返回有多少子序列的最大公约数为K
+结果可能很大，对1000000007取模
+原题目简单转化就是如下的题目
+测试链接 : https://www.luogu.com.cn/problem/CF803F
+所以课上会讲怎么转化，然后就是讲测试链接里的题目
+1 <= N <= 10^5
+1 <= arr[i] <= 10^5
+
+(上课时网络卡顿，将在下节课安排重讲)
+来自学员问题，蓝桥杯练习题
+给定一个长度为n的数组arr
+现在你有一次机会, 将其中连续的K个数全修改成任意一个值
+请你计算如何修改可以使修改后的数 列的最长不下降子序列最长
+请输出这个最长的长度。
+最长不下降子序列:子序列中的每个数不小于在它之前的数
+1 <= k, n <= 10^5
+1 <= arr[i] <= 10^6
+测试链接 : https://www.luogu.com.cn/problem/P8776
+
+
+
+第067节 2023年4月第4周流行算法题目解析
+
+(因为上节课网络卡顿，所以这节课安排重讲)
+来自学员问题，蓝桥杯练习题
+给定一个长度为n的数组arr
+现在你有一次机会, 将其中连续的K个数全修改成任意一个值
+请你计算如何修改可以使修改后的数 列的最长不下降子序列最长
+请输出这个最长的长度。
+最长不下降子序列:子序列中的每个数不小于在它之前的数
+1 <= k, n <= 10^5
+1 <= arr[i] <= 10^6
+测试链接 : https://www.luogu.com.cn/problem/P8776
+
+开心一下的智力题 :
+有一个村庄，一共250人
+每一个村民要么一定说谎，要么只说真话
+村里有A、B、C、D四个球队，且每个村民只会喜欢其中的一支球队
+但是说谎者会不告知真实喜好，而且会说是另外三支球队的支持者（全支持另外三支球队）
+访问所有的村民之后，得到的访谈结果如下 :
+A的支持者有90
+B的支持者有100
+C的支持者有80
+D的支持者有80
+问村里有多少个说谎者
+下面是正式题 : 
+你有一个凸的 n 边形，其每个顶点都有一个整数值。给定一个整数数组 values ，
+其中 values[i] 是第 i 个顶点的值（即 顺时针顺序 ）。
+假设将多边形 剖分 为 n - 2 个三角形。
+对于每个三角形，该三角形的值是顶点标记的乘积，
+三角剖分的分数是进行三角剖分后所有 n - 2 个三角形的值之和。
+返回 多边形进行三角剖分后可以得到的最低分 。
+测试链接 : https://leetcode.cn/problems/minimum-score-triangulation-of-polygon/
+
+给你一个正整数数组nums, 同时给你一个长度为 m 的整数数组 queries
+第 i 个查询中，你需要将 nums 中所有元素变成 queries[i] 。你可以执行以下操作 任意 次：
+将数组里一个元素 增大 或者 减小 1 。请你返回一个长度为 m 的数组 answer ，
+其中 answer[i]是将 nums 中所有元素变成 queries[i] 的 最少 操作次数。
+注意，每次查询后，数组变回最开始的值。
+测试链接 : https://leetcode.cn/problems/minimum-operations-to-make-all-array-elements-equal/
+
+来自微众银行
+两个魔法卷轴问题
+给定一个数组arr，其中可能有正、负、0，
+一个魔法卷轴可以把arr中连续的一段全变成0，你希望数组整体的累加和尽可能大
+你有两个魔法卷轴，请返回数组尽可能大的累加和
+1 <= arr长度 <= 100000
+-100000 <= arr里的值 <= 100000
+
+来自微众银行
+给出两个长度均为n的数组
+A = { a1, a2, ... ,an }
+B = { b1, b2, ... ,bn }。
+你需要求出其有多少个区间[L,R]满足:
+数组A中下标在[L,R]中的元素之和在[La,Ra]之中
+数组B中下标在[L,R]中的元素之和在[Lb,Rb]之中
+输入
+第一行有一个正整数N(1<=N<=100000)，代表两个数组的长度。
+第二行有N个非负整数，范围在0到1000000000之间，代表数组中的元素。
+第三行有N个非负整数，范围在0到1000000000之间，代表数组中的元素。
+第四行有4个整数La,Ra,Lb,Rb，范围在0到10^18之间，代表题目描述中的参数。
+输出
+输出一个整数，代表所求的答案
+
+给你一个 n 个节点的无向无根树，节点编号从 0 到 n - 1
+给你整数 n 和一个长度为 n - 1 的二维整数数组 edges ，
+其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间有一条边。
+再给你一个长度为 n 的数组 coins ，其中 coins[i] 可能为 0 也可能为 1 ，
+1 表示节点 i 处有一个金币。
+一开始，你需要选择树中任意一个节点出发。你可以执行下述操作任意次：
+收集距离当前节点距离为 2 以内的所有金币，或者 移动到树中一个相邻节点。
+你需要收集树中所有的金币，并且回到出发节点，请你返回最少经过的边数。
+如果你多次经过一条边，每一次经过都会给答案加一。
+测试链接 : https://leetcode.cn/problems/collect-coins-in-a-tree/
+
+
+
+第068节 2023年5月第2周流行算法题目解析
+
+来自华为OD，学员问题
+一个图像有n个像素点，存储在一个长度为n的数组arr里，
+每个像素点的取值范围[0,s]的整数
+请你给图像每个像素点值加上一个整数k（可以是负数）
+像素值会自动截取到[0,s]范围，
+当像素值<0，会更改为0，当新像素值>s，会更改为s
+这样就可以得到新的arr，想让所有像素点的平均值最接近中位值s/2, 向下取整
+请输出这个整数k, 如有多个整数k都满足, 输出小的那个
+1 <= n <= 10^6
+1 <= s <= 10^18
+
+来自学员问题，来自真实笔试
+塔子哥最近在处理一些字符串相关的任务
+他喜欢 R 字符，因为在某些任务中，这个字符通常表示“正确”的结果
+另一方面，他不喜欢 B 字符，因为在某些任务中，这个字符通常表示“错误”的结果
+为了解决他的任务，塔子哥定义了字符串的权值为字符串中 R 字符的出现次数
+例如，对于字符串 BBRBRB，它的权值为 2，因为其中有 2 个 R 字符
+现在，塔子哥面临一个问题，他有一个长度为 n 的字符串 s，它仅由 R 和 B 组成
+他想知道，长度为 n 的仅由 R 和 B组成的字符串中，
+字典序不小于 s 的字符串的权值之和是多少？
+因此，他需要编写一个程序来解决这个问题
+输入第一行为一个整数 n ，表示字符串的长度
+输入第二行为一个长度为 n 的字符串 s ，字符串中元素组成仅为 R 和 B
+输出一个整数，代表长度为 n 的、字典序不小于 s 的字符串权值之和
+输入样例：
+3
+RBR
+输出：
+7
+解释：共有 3 个字符串字典序大于等于"RBR"，RBR权值为2，RRB为2，RRR为3
+1 <= n <= 100000
+结果可能很大，对1000000007取模
+帖子链接 : https://www.mashibing.com/question/detail/67223
+
+作为项目经理，你规划了一份需求的技能清单 req_skills，
+并打算从备选人员名单 people 中选出些人组成一个「必要团队」
+编号为 i 的备选人员 people[i] 含有一份该备选人员掌握的技能列表
+所谓「必要团队」，就是在这个团队中，
+对于所需求的技能列表 req_skills 中列出的每项技能，
+团队中至少有一名成员已经掌握。可以用每个人的编号来表示团队中的成员：
+例如，团队 team = [0, 1, 3] 表示掌握技能分别为
+people[0]，people[1]，和 people[3] 的备选人员。
+请你返回 任一 规模最小的必要团队，团队成员用人员编号表示。
+你可以按 任意顺序 返回答案，题目数据保证答案存在。
+测试链接 : https://leetcode.cn/problems/smallest-sufficient-team/
+
+给定一个整数数组  nums 和一个正整数 k，
+找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
+测试链接 : https://leetcode.cn/problems/partition-to-k-equal-sum-subsets/
+
+给你一个整数 n 和一个在范围 [0, n - 1] 以内的整数 p ，
+它们表示一个长度为 n 且下标从 0 开始的数组 arr ，
+数组中除了下标为 p 处是 1 以外，其他所有数都是 0 。
+同时给你一个整数数组 banned ，它包含数组中的一些位置。
+banned 中第 i 个位置表示 arr[banned[i]] = 0 ，题目保证 banned[i] != p 。
+你可以对 arr 进行 若干次 操作。一次操作中，你选择大小为 k 的一个 子数组 
+并将它 翻转 。在任何一次翻转操作后，
+你都需要确保 arr 中唯一的 1 不会到达任何 banned 中的位置。
+换句话说，arr[banned[i]] 始终 保持 0 。
+请你返回一个数组 ans ，对于 [0, n - 1] 之间的任意下标 i ，
+ans[i] 是将 1 放到位置 i 处的 最少 翻转操作次数，
+如果无法放到位置 i 处，此数为 -1 。
+子数组 指的是一个数组里一段连续 非空 的元素序列。
+对于所有的 i ，ans[i] 相互之间独立计算。
+将一个数组中的元素 翻转 指的是将数组中的值变成 相反顺序 。
+测试链接 : https://leetcode.cn/problems/minimum-reverse-operations/
+
+
+
+第069节 2023年5月第3周流行算法题目解析
+
+保证一定是n*n的正方形，实现从里到外转圈打印的功能
+如果n是奇数，中心点唯一，比如
+a b c
+d e f
+g h i
+e是中心点，依次打印 : e f i h g d a b c
+如果n是偶数，中心点为最里层2*2的右下点
+比如
+a b c d e f
+g h i j k l
+m n o p q r
+s t u v w x
+y z 0 1 2 3
+4 5 6 7 8 9
+最里层是
+o p
+u v
+v是中心点，依次打印 : v u o p q w ....
+
+来自学员问题
+假设每一次获得随机数的时候，这个数字大于100的概率是P
+尝试N次，其中大于100的次数在A次~B次之间的概率是多少?
+0 < P < 1, P是double类型
+1 <= A <= B <= N <= 100
+
+在一个 n x n 的国际象棋棋盘上，一个骑士从单元格 (row, column) 开始
+并尝试进行 k 次移动。行和列是 从 0 开始 的，所以左上单元格是 (0,0)
+右下单元格是 (n - 1, n - 1)，象棋骑士有8种可能的走法
+每次移动在基本方向上是两个单元格，然后在正交方向上是一个单元格，类似马走日
+每次骑士要移动时，它都会随机从8种可能的移动中选择一种(即使棋子会离开棋盘)，然后移动到那里。
+骑士继续移动，直到它走了 k 步或离开了棋盘
+返回 骑士在棋盘停止移动后仍留在棋盘上的概率
+测试链接 : https://leetcode.cn/problems/knight-probability-in-chessboard/
+
+来自小红书
+给你一个整数数组 nums 和一个整数 k 。 nums 仅包含 0 和 1
+每一次移动，你可以选择 相邻 两个数字并将它们交换
+请你返回使 nums 中包含 k 个 连续 1 的 最少 交换次数
+测试链接 : https://leetcode.cn/problems/minimum-adjacent-swaps-for-k-consecutive-ones/
+
+现有一棵无向、无根的树，树中有 n 个节点，按从 0 到 n - 1 编号
+给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，
+其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条边。
+每个节点都关联一个价格。给你一个整数数组 price ，其中 price[i] 是第 i 个节点的价格。
+给定路径的 价格总和 是该路径上所有节点的价格之和。
+另给你一个二维整数数组 trips ，其中 trips[i] = [starti, endi] 表示
+从节点 starti 开始第 i 次旅行，并通过任何你喜欢的路径前往节点 endi 。
+在执行第一次旅行之前，你可以选择一些 非相邻节点 并将价格减半。
+返回执行所有旅行的最小价格总和。
+测试链接 : https://leetcode.cn/problems/minimize-the-total-price-of-the-trips/
+
+
+
+第070节 2023年5月第4周流行算法题目解析
+
+先来一个智力题，来自美团面试题
+给定n个二维坐标，表示在二维平面的n个点，
+坐标为double类型，精度最多小数点后两位
+希望在二维平面上画一个圆，圈住其中的k个点，其他的n-k个点都要在圆外
+返回一个圆心和半径，表示哪个圆可以圈住其中的k个点
+坐标和半径都是double类型，最多保留小数点后两位
+下面是正式题目
+给你一个整数数组 arr 和一个整数 k
+现需要从数组中恰好移除 k 个元素
+请找出移除后数组中不同整数的最少数目
+测试链接 : https://leetcode.cn/problems/least-number-of-unique-integers-after-k-removals/
+
+来自华为
+一个数字n，一定要分成k份
+得到的乘积尽量大是多少
+数字n和k，可能非常大，到达10^12规模
+结果可能更大，所以返回结果对1000000007取模
+
+来自美团
+给定 pushed 和 popped 两个序列，每个序列中的 值都不重复，
+只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，
+返回 true；否则，返回 false 。
+测试链接 : https://leetcode.cn/problems/validate-stack-sequences/
+
+来自招商银行
+给定一个数组arr，长度为n，表示有0~n-1号设备
+arr[i]表示i号设备的型号，型号的种类从0~k-1，一共k种型号
+给定一个k*k的矩阵map，来表示型号之间的兼容情况
+map[a][b] == 1，表示a型号兼容b型号
+map[a][b] == 0，表示a型号不兼容b型号
+兼容关系是有向图，也就是a型号兼容b型号，不代表b型号同时兼容a型号
+如果i设备的型号兼容j设备的型号，那么可以从i设备修建一条去往j设备的线路
+修建线路的代价是i设备到j设备的距离：|i-j|
+你的目标是从0号设备到达n-1号设备，并不一定每个设备都联通，只需要到达即可
+返回最小的修建代价，如果就是无法到达返回-1
+1 <= n <= 1000
+1 <= k <= 50
+
+来自招商银行
+这个题是个破题，但这可能是经常遇到的一种题，
+讲一下思路即可，没有必要投入大多时间给这种题目
+一共有三个服务A、B、C，网络延时分别为a、b、c
+并且一定有：1 <= a <= b <= c <= 10^9
+但是具体的延时数字丢失了，只有单次调用的时间
+一次调用不可能重复使用相同的服务，
+一次调用可能使用了三个服务中的某1个、某2个或者全部3个服务
+比如一个调用的时间，T = 100
+100的延时可能来自以下7种情况：
+a = 100，这次调用可能单独使用了A
+b = 100，这次调用可能单独使用了B
+c = 100，这次调用可能单独使用了C
+a + b = 100，这次调用可能组合使用了A、B
+a + c = 100，这次调用可能组合使用了A、C
+b + c = 100，这次调用可能组合使用了B、C
+a + b + c = 100，这次调用可能组合使用了A、B、C全部服务
+那么可想而知，如果给的调用时间足够多，是可以猜测出a、b、c的
+给定一个数组times，长度为n，并且一定有4 <= n <= 7
+times[i] = s，表示i号调用用时s，而且times中一定都是正数且没有重复值
+请根据n次调用，猜测出a、b、c三元组可能的情况数
+如果任何a、b、c都无法匹配上给定的调用耗时，返回0
+测试的次数T <= 100
+也就是说，一共最多给定100个数组，每一次让你返回a、b、c三元组可能的情况数
+
+来自招商银行
+原始题目描述
+假如某公司目前推出了N个在售的金融产品(1<=N<=100)
+对于张三，用ai表示他购买了ai(0<=ai<=10^4)份额的第i个产品(1<=i<=N)
+现给出K(1<=K<=N)个方案，通过这些方案，能够支持将多个不同的产品进行整合
+(也可以对单个产品进行优化)形成新的产品。
+新的产品形成后，若用户持有了组成新产品所需的全部的原产品份额，
+则能够将用户持有的原产品份额转换为新产品的份额，各原产品份额与新产品份额比例均为1:1
+我们保证对于每个产品最多存在一个方案使用旧产品整合成该产品
+并且根据方案产出的新产品的产品编号均大于各旧产品的产品编号
+现计划根据这些方案，帮助部分愿意升级到最新产品的用户对产品进行升级
+请协助工作人员计算当前用户能够转换出的最新产品份额的最大值
+输入描述
+第一行包含整数N，第二行包含N个整数ai，第三行包含整数K
+接下来的K行，每一行代表一个方案，每一行包含整数1和M(M>=1)
+L为该方案产生的新产品的编号，M代表方案所需原产品个数
+接下来的M个整数代表了该方案所需的每个原产品的个数
+输出描述
+根据日前的份额和给出的方案，经过若干次转换，输出当前用户能够得到产品N的份额最大值
+举例
+输入:
+5
+2 0 0 1 0
+3
+5 2 3 4
+2 1 1
+3 1 2
+输出:
+1
+解释:
+第一步将1份1产品转化为1份2产品
+第二步将1份2产品转化为1份3产品
+第三步将1份3产品和1份4产品，转成为1份5产品
+然后不能得到更多的5产品了，所以返回1
+实在是太困惑了，上文说的意思可谓不做人，那么我们改写一下意思，变得好理解
+如下是改写后的题目描述
+给定一个数组arr，长度为n，产品编号从0~n-1
+arr[i]代表初始时i号产品有多少份
+存在一系列的产品转化方案的数组convert，长度为k，代表k个方案
+比如具体某一个方案，convert[j] = {a, b, c, d, ...}
+表示当前的j号方案转化出来的产品是a，转化1份a需要：1份b、1份c、1份d...
+其中a、b、c、d...一定都在0~n-1范围内
+并且题目保证a > Math.max(b, c, d, ....)
+而且题目保证所有方案转化出来的产品编号一定是不重复的
+请返回最终能得到的第n-1号商品的最大值
+1 <= n <= 100
+0 <= arr[i] <= 10^4
+k < n
+
+
+
+第071节 2023年5月第5周流行算法题目解析
+
+来自字节
+给定一个n*m的二维矩阵，每个位置都是字符
+U、D、L、R表示传送带的位置，会被传送到 : 上、下、左、右
+. 、O分别表示空地、目标，一定只有一个目标点
+可以在空地上选择上、下、左、右四个方向的一个
+到达传送带的点会被强制移动到其指向的下一个位置
+如果越界直接结束，返回有几个点可以到达O点
+
+来自学员问题
+沿街有一排连续的房屋。每间房屋内都藏有一定的现金
+现在有一位小偷计划从这些房屋中窃取现金
+由于相邻的房屋装有相互连通的防盗系统，所以小偷 不会窃取相邻的房屋
+小偷的 窃取能力 定义为他在窃取过程中能从单间房屋中窃取的 最大金额
+给你一个整数数组 nums 表示每间房屋存放的现金金额
+形式上，从左起第 i 间房屋中放有 nums[i] 美元
+另给你一个整数 k ，表示窃贼将会窃取的最少房屋数
+小偷一定要要窃取至少 k 间房屋，返回小偷的 最小 窃取能力
+测试链接 : https://leetcode.cn/problems/house-robber-iv/
+
+来自华为OD
+如果n = 1，打印
+1***
+如果n = 2，打印
+        1***
+3***    2***
+如果n = 3，打印
+                1***
+        3***    2***
+4***    5***    6***
+如果n = 4，打印
+                        1***
+                3***    2***
+        4***    5***    6***
+10**    9***    8***    7***
+输入一个数n，表示有多少行，从1开始输出，
+奇数行输出奇数个数，奇数行正序，偶数行输出偶数个数，偶数行逆序
+每个数后面加*补满四位，中间空4个，第n行顶格输出
+
+字符串哈希原理和实现
+
+字符串哈希+二分的例题
+给定长为 n 的源串 s，以及长度为 m 的模式串 p，
+要求查找源串中有多少子串与模式串匹配
+s' 与 s 匹配，当且仅当 s' 与 s 长度相同，且最多有 k 个位置字符不同
+其中 1 <= n, m <= 10^6，0 <= k <= 5
+
+正方形矩阵哈希实现
+二维哈希只适用于正方形的情况
+如果想支持普通矩阵，需要更复杂度的过程，这里不做展开
+
+如果一个正方形矩阵上下对称并且左右对称，对称的意思是互为镜像
+那么称这个正方形矩阵叫做神奇矩阵
+比如 :
+1 5 5 1
+6 3 3 6
+6 3 3 6
+1 5 5 1
+这个正方形矩阵就是神奇矩阵
+给定一个大矩阵n*m，返回其中神奇矩阵的数目
+1 <= n,m <= 1000
+测试链接 : https://www.luogu.com.cn/problem/P2601
+
+
+
+第072节 2023年6月第2周流行算法题目解析
+
+给你一个长度为 n 下标从 0 开始的整数数组 nums
+它包含 1 到 n 的所有数字，请你返回上升四元组的数目。
+如果一个四元组 (i, j, k, l) 满足以下条件，我们称它是上升的：
+0 <= i < j < k < l < n 且
+nums[i] < nums[k] < nums[j] < nums[l] 。
+测试链接 : https://leetcode.cn/problems/count-increasing-quadruplets/
+
+来自华为od
+给定一个数组arr，长度为n，表示n个格子的分数，并且这些格子首尾相连
+孩子不能选相邻的格子，不能回头选，不能选超过一圈
+但是孩子可以决定从任何位置开始选，也可以什么都不选
+返回孩子能获得的最大分值
+1 <= n <= 10^6
+0 <= arr[i] <= 10^6
+
+给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次
+需保证 返回结果的字典序最小
+要求不能打乱其他字符的相对位置)
+测试链接 : https://leetcode.cn/problems/remove-duplicate-letters/
+大厂刷题班讲过，不过那时没有讲出最优解，安排一下重讲
+
+给你一个由 n 个数对组成的数对数组 pairs
+其中 pairs[i] = [lefti, righti] 且 lefti < righti 。
+现在，我们定义一种 跟随 关系，当且仅当 b < c 时
+数对 p2 = [c, d] 才可以跟在 p1 = [a, b] 后面
+我们用这种形式来构造 数对链
+找出并返回能够形成的 最长数对链的长度
+你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。
+测试链接 : https://leetcode.cn/problems/maximum-length-of-pair-chain/
+
+给你两个整数数组 arr1 和 arr2
+返回使 arr1 严格递增所需要的最小「操作」数（可能为 0）。
+每一步「操作」中，你可以分别从 arr1 和 arr2 中各选出一个索引，
+分别为 i 和 j，0 <= i < arr1.length 和 0 <= j < arr2.length，
+然后进行赋值运算 arr1[i] = arr2[j]。如果无法让 arr1 严格递增，请返回 -1。
+之前讲过这个题，能通过但不是最优解，所以我们直接补一个最优解
+测试链接 : https://leetcode.cn/problems/make-array-strictly-increasing/
+
+
+
+第073节 2023年6月3周流行算法题目解析
+
+课前放松一下
+做一个令人不开心的实验
+一开始有100个人，每个人都有100元
+在每一轮都做如下的事情 : 
+每个人都必须拿出1元钱给除自己以外的其他人，给谁完全随机
+如果某个人在这一轮的钱数为0，那么他可以不给，但是可以接收
+发生很多很多轮之后，这100人的社会财富分布很均匀吗？
+
+来自字节
+密码是一串长度为n的小写字母，一则关于密码的线索纸条
+首先将字母a到z编号为0到25编号
+纸条上共有n个整数ai，其中a1表示密码里第一个字母的编号
+若i>1的话就表示第i个字母和第i-1个字母编号的差值
+例如，a2就代表密码中第1个字母和第2个字母编号的差值
+若密码是acb，那么纸条上的数字就是[0, 2, 1]
+返回可能的密码的个数，由于结果可能很大，
+输出对1000000007取模的结果
+1 <= n <= 10^5
+0 <= ai <= 25
+
+来自字节
+给定整数数组arr，求删除任一元素后，
+新数组中长度为k的子数组累加和的最大值
+
+来自字节
+给定一个数组arr，长度为n，在其中要选两个不相交的子数组
+两个子数组的累加和都要是T，返回所有满足情况中，两个子数组长度之和最小是多少
+如果没有有效方法，返回-1
+正式 :
+2 <= n <= 10^6
+0 <= arr[i] <= 10000
+1 <= T <= 10^8
+扩展 : 
+2 <= n <= 10^6
+-10000 <= arr[i] <= 10000
+1 <= T <= 10^8
+都能时间复杂度做到O(N)
+
+来自华为OD
+一支n个士兵的军队正在趁夜色逃亡，途中遇到一条湍急的大河
+敌军在T的时长后到达河面，没到过对岸的士兵都会被消灭
+现在军队只找到了1只小船，这船最多能同时坐上2个士兵。
+1) 当1个士兵划船过河，用时为a[i]
+2) 当2个士兵坐船同时划船过河时, 用时为max(a[j],a[i])两士兵中用时最长的
+3) 当2个士兵坐船只有1个士兵划船时, 用时为a[i] * 10, a[i]为划船士兵用时
+请帮忙给出一种解决方案，保证存活的士兵最多，且过河用时最短
+我们先看一下如下的题，再讲一下华为OD的扩展
+测试链接 : https://www.luogu.com.cn/problem/P1809
+有一个大晴天, Oliver与同学们一共N人出游, 他们走到一条河的东岸边，想要过河到西岸
+而东岸边有一条小船。船太小了，一次只能乘坐两人，每个人都有一个渡河时间T
+船划到对岸的时间等于船上渡河时间较长的人所用时间
+现在已知N个人的渡河时间Ti
+Oliver 想要你告诉他，他们最少要花费多少时间，才能使所有人都过河
+注意，只有船在东岸（西岸）的人才能坐上船划到对岸。
+
+来自华为OD
+1号店铺贿赂问题
+店铺数量n，编号1~n
+人的数量m，编号1~m
+每个人有自己投票的店铺p，和改投1号店的报价x
+返回想让1号店铺成为人气最高的店，至少花多少钱
+1 <= p,n,m <= 3000
+1 <= x <= 10^9
+
+
+
+第074节 2023年6月4周流行算法题目解析
+
+给你一个下标从 0 开始的整数数组 nums ，它包含 n 个 互不相同 的正整数
+如果 nums 的一个排列满足以下条件，我们称它是一个特别的排列
+对于 0 <= i < n - 1 的下标 i
+要么 nums[i] % nums[i+1] == 0
+要么 nums[i+1] % nums[i] == 0
+请你返回特别排列的总数目，由于答案可能很大，请将它对 1000000007 取余 后返回
+测试链接 : https://leetcode.cn/problems/special-permutations/
+
+给你两个长度为 n 下标从 0 开始的整数数组 cost 和 time
+分别表示给 n 堵不同的墙刷油漆需要的开销和时间。你有两名油漆匠
+一位需要 付费 的油漆匠，刷第 i 堵墙需要花费 time[i] 单位的时间
+开销为 cost[i] 单位的钱。
+一位 免费 的油漆匠，刷 任意 一堵墙的时间为 1 单位，开销为 0
+但是必须在付费油漆匠 工作 时，免费油漆匠才会工作
+请你返回刷完 n 堵墙最少开销为多少
+测试链接 : https://leetcode.cn/problems/painting-the-walls/
+
+来自华为社招笔试
+在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧
+在桥上有一些石子，青蛙很讨厌踩在这些石子上
+由于桥的长度和青蛙一次跳过的距离都是正整数
+我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0...L
+其中L是桥的长度，坐标为 0 的点表示桥的起点，坐标为 L 的点表示桥的终点
+青蛙从桥的起点开始，不停的向终点方向跳跃
+一次跳跃的距离是 S 到 T 之间的任意正整数（包括S,T）
+当青蛙跳到或跳过坐标为 L 的点时，就算青蛙已经跳出了独木桥。
+题目给出独木桥的长度 L，青蛙跳跃的距离范围[S,T]
+以及桥上石子的位置
+你的任务是确定青蛙要想过河，最少需要踩到的石子数
+测试链接 : https://www.luogu.com.cn/problem/P1052
+
+欧拉路径问题
+给你一个下标从 0 开始的二维整数数组 pairs
+其中 pairs[i] = [starti, endi]
+如果 pairs 的一个重新排列
+满足对每一个下标 i （ 1 <= i < pairs.length ）
+都有 endi-1 == starti ，
+那么我们就认为这个重新排列是 pairs 的一个 合法重新排列
+请你返回 任意一个 pairs 的合法重新排列
+注意：数据保证至少存在一个 pairs 的合法重新排列
+测试链接 : https://leetcode.cn/problems/valid-arrangement-of-pairs/
+
+
+
+第075节 2023年7月1周流行算法题目解析
+
+先来一个最近国外同学考的题目
+已知一些供应点的位置，一共n个供应点
+其中有n-1个供应点一定都在x轴上，比如(15,0)位置，(2,0)位置等
+只有1个供应点不在x轴上，比如(23,17)位置
+给出每个供应点的位置，并且给定第k号供应点是出发点
+要求每个供应点最多走过2次，返回从k点出发，走完所有供应点的最少距离
+上面这个题没有代码实现
+因为这个题就是彻底的业务分析，只有一系列的贪心设计，代码也不难写
+同时这个题没有给出数据量，但是课上会讲O(n)的方法，所以也就无所谓了
+以下是这节课的正式题，来自学员问题
+现在有一个打怪类型的游戏，这个游戏是这样的，你有n个技能
+每一个技能会有一个伤害，
+同时若怪物小于等于一定的血量，则该技能可能造成双倍伤害
+每一个技能最多只能释放一次，已知怪物有m点血量
+现在想问你最少用几个技能能消灭掉他(血量小于等于0)
+技能的数量是n，怪物的血量是m
+i号技能的伤害是x[i]，i号技能触发双倍伤害的血量最小值是y[i]
+1 <= n <= 10
+1 <= m、x[i]、y[i] <= 10^6
+测试链接 : https://www.nowcoder.com/questionTerminal/d88ef50f8dab4850be8cd4b95514bbbd
+
+给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。
+s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。
+例如，如果 words = ["ab","cd","ef"]
+那么 "abcdef"， "abefcd"，"cdabef"
+"cdefab"，"efabcd"， 和 "efcdab" 都是串联子串
+"acdbef" 不是串联子串，因为他不是任何 words 排列的连接。
+返回所有串联字串在 s 中的开始索引
+你可以以 任意顺序 返回答案
+1 <= s.length <= 10^4
+1 <= words.length <= 5000
+1 <= words[i].length <= 30
+words[i] 和 s 由小写英文字母组成
+测试链接 : https://leetcode.cn/problems/substring-with-concatenation-of-all-words/
+
+小扣在探索丛林的过程中，无意间发现了传说中"落寞的黄金之都"
+而在这片建筑废墟的地带中，小扣使用探测仪监测到了存在某种带有「祝福」效果的力场
+经过不断的勘测记录，小扣将所有力场的分布都记录了下来
+forceField[i] = [x,y,side] 
+表示第 i 片力场将覆盖以坐标 (x,y) 为中心，边长为 side 的正方形区域。
+若任意一点的 力场强度 等于覆盖该点的力场数量
+请求出在这片地带中 力场强度 最强处的 力场强度
+注意：力场范围的边缘同样被力场覆盖。
+测试链接 : https://leetcode.cn/problems/xepqZ5/
+
+来自网易
+题目出处 : https://leetcode.cn/circle/discuss/uOnnUA/
+已知一个n*n的01矩阵，
+只能通过通过行交换、或者列交换的方式调整矩阵，
+判断这个矩阵的对角线是否能全为1，如果能返回true，不能返回false
+我们升级一下:
+已知一个n*n的01矩阵，
+只能通过通过行交换、或者列交换的方式调整矩阵，
+判断这个矩阵的对角线是否能全为1，如果不能打印-1
+如果能，打印需要交换的次数，并且打印怎么交换
+测试链接 : http://acm.hdu.edu.cn/showproblem.php?pid=2819
+
+
+
+第076节 2023年7月2周流行算法题目解析
+
+阿里巴巴走进了装满宝藏的藏宝洞。藏宝洞里面有N堆金币
+第i堆金币的总重量和总价值分别是m[i]、v[i]
+阿里巴巴有一个承重量为T的背包，但并不一定有办法将全部的金币都装进去
+他想装走尽可能多价值的金币
+所有金币都可以随意分割，分割完的金币重量价值比（也就是单位价格）不变
+请问阿里巴巴最多可以拿走多少价值的金币？
+测试链接 : https://www.luogu.com.cn/problem/P2240
+
+来自字节
+机器人正在玩一个古老的基于DOS的游戏
+游戏中有N+1座建筑，从0到N编号，从左到右排列
+编号为0的建筑高度为0个单位，编号为i的建筑的高度为H(i)个单位
+起初， 机器人在编号为0的建筑处
+每一步，它跳到下一个（右边）建筑。假设机器人在第k个建筑，且它现在的能量值是E
+下一步它将跳到第个k+1建筑
+它将会得到或者失去正比于与H(k+1)与E之差的能量
+如果 H(k+1) > E 那么机器人就失去H(k+1)-E的能量值，否则它将得到E-H(k+1)的能量值
+游戏目标是到达第个N建筑，在这个过程中，能量值不能为负数个单位
+现在的问题是机器人以多少能量值开始游戏，才可以保证成功完成游戏
+测试链接 : https://www.nowcoder.com/questionTerminal/7037a3d57bbd4336856b8e16a9cafd71
+
+你有 k 个背包。给你一个下标从 0 开始的整数数组 weights
+其中 weights[i] 是第 i 个珠子的重量。同时给你整数 k
+请你按照如下规则将所有的珠子放进 k 个背包。
+没有背包是空的。
+如果第 i 个珠子和第 j 个珠子在同一个背包里
+那么下标在 i 到 j 之间的所有珠子都必须在这同一个背包中
+如果一个背包有下标从 i 到 j 的所有珠子，那么这个背包的价格是 weights[i] + weights[j] 。
+一个珠子分配方案的 分数 是所有 k 个背包的价格之和。
+请你返回所有分配方案中，最大分数 与 最小分数 的 差值 为多少。
+测试链接 : https://leetcode.cn/problems/put-marbles-in-bags/
+
+一个公司准备组织一场会议，邀请名单上有 n 位员工
+公司准备了一张 圆形 的桌子，可以坐下 任意数目 的员工
+员工编号为 0 到 n - 1 。每位员工都有一位 喜欢 的员工
+每位员工 当且仅当 他被安排在喜欢员工的旁边，他才会参加会议
+每位员工喜欢的员工 不会 是他自己。
+给你一个下标从 0 开始的整数数组 favorite
+其中 favorite[i] 表示第 i 位员工喜欢的员工。请你返回参加会议的 最多员工数目
+测试链接 : https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/
+
+给你一个 n 个点的带权无向连通图，节点编号为 0 到 n-1
+同时还有一个数组 edges ，其中 edges[i] = [fromi, toi, weighti]
+表示在 fromi 和 toi 节点之间有一条带权无向边
+最小生成树 (MST) 是给定图中边的一个子集
+它连接了所有节点且没有环，而且这些边的权值和最小
+请你找到给定图中最小生成树的所有关键边和伪关键边
+如果从图中删去某条边，会导致最小生成树的权值和增加，那么我们就说它是一条关键边
+伪关键边则是可能会出现在某些最小生成树中但不会出现在所有最小生成树中的边
+请注意，你可以分别以任意顺序返回关键边的下标和伪关键边的下标
+测试链接 : https://leetcode.cn/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/
+
+
+
+第077节 2023年7月3周流行算法题目解析
+
+先来一个最近学员在国外面试的题
+有一个由x轴和y轴组成的坐标系
+"y下"和"y上"表示一条无限延伸的道路，"y下"表示这个道路的下限，"y上"表示这个道路的上限
+给定一批长方形，每一个长方形有(x1, x2, y1, y2)，4个坐标可以表示一个长方形
+判断这条道路整体是不是可以走通的
+以下为正式题目
+图片在计算机处理中往往是使用二维矩阵来表示的
+给你一个大小为 m x n 的二进制矩阵 image 表示一张黑白图片，0 代表白色像素，1 代表黑色像素
+黑色像素相互连接，也就是说，图片中只会有一片连在一块儿的黑色像素。像素点是水平或竖直方向连接的
+给你两个整数 x 和 y 表示某一个黑色像素的位置
+请你找出包含全部黑色像素的最小矩形（与坐标轴对齐），并返回该矩形的面积
+你必须设计并实现一个时间复杂度低于 O(m*n) 的算法来解决此问题。
+测试链接 : https://leetcode.cn/problems/smallest-rectangle-enclosing-black-pixels/
+
+一个句子是由一些单词与它们之间的单个空格组成
+且句子的开头和结尾没有多余空格
+比方说，"Hello World" ，"HELLO" ，"hello world hello world" 都是句子
+每个单词都 只 包含大写和小写英文字母
+如果两个句子 sentence1 和 sentence2
+可以通过往其中一个句子插入一个任意的句子（可以是空句子）而得到另一个句子
+那么我们称这两个句子是 相似的
+比方说，sentence1 = "Hello my name is Jane" 
+且 sentence2 = "Hello Jane"
+我们可以往 sentence2 中 "Hello" 和 "Jane" 之间插入 "my name is"
+得到 sentence1
+给你两个句子 sentence1 和 sentence2
+如果 sentence1 和 sentence2 是相似的，请你返回 true ，否则返回 false
+测试链接 : https://leetcode.cn/problems/sentence-similarity-iii/
+
+每一种货币都给定面值val[i]，和拥有的数量cnt[i]
+想知道目前拥有的货币，在钱数为1、2、3...m时，能找零成功的钱数有多少
+也就是说当钱数的范围是1~m，返回这个范围上有多少可以找零成功的钱数
+比如只有3元的货币，数量是5张
+m = 10
+那么在1~10范围上，只有钱数是3、6、9时，可以成功找零
+所以返回3，表示有3种钱数可以找零成功
+测试链接 : http://poj.org/problem?id=1742
+
+我们把无限数量的栈排成一行，按从左到右的次序从 0 开始编号
+每个栈的的最大容量 capacity 都相同。实现一个叫「餐盘」的类 DinnerPlates
+DinnerPlates(int capacity) - 给出栈的最大容量 capacity
+void push(int val) 将给出的正整数 val 推入 从左往右第一个 没有满的栈
+int pop() 返回 从右往左第一个 非空栈顶部的值，并将其从栈中删除
+          如果所有的栈都是空的，请返回 -1。
+int popAtStack(int index) - 返回编号 index 的栈顶部的值，并将其从栈中删除
+          如果编号 index 的栈是空的，请返回 -1。
+测试链接 : https://leetcode.cn/problems/dinner-plate-stacks/
+
+给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先
+测试链接 : https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/
+
+
+
+第078节 2023年7月4周流行算法题目解析
+
+给你一个正整数数组 nums
+每一次操作中，你可以从 nums 中选择 任意 一个数并将它减小到 恰好 一半
+注意，在后续操作中你可以对减半过的数继续执行操作
+请你返回将 nums 数组和 至少 减少一半的 最少 操作数
+测试链接 : https://leetcode.cn/problems/minimum-operations-to-halve-array-sum/
+
+自 01背包问世之后，小 A 对此深感兴趣
+一天，小 A 去远游，却发现他的背包不同于 01 背包，他的物品大致可分为 k 组
+每组中的物品只能选择1件，现在他想知道最大的利用价值是多少
+测试链接 : www.luogu.com.cn/problem/P1757
+
+一张桌子上总共有 n 个硬币 栈 。每个栈有 正整数 个带面值的硬币
+每一次操作中，你可以从任意一个栈的 顶部 取出 1 个硬币，从栈中移除它，并放入你的钱包里
+给你一个列表 piles ，其中 piles[i] 是一个整数数组
+分别表示第 i 个栈里 从顶到底 的硬币面值。同时给你一个正整数 k
+请你返回在 恰好 进行 k 次操作的前提下，你钱包里硬币面值之和 最大为多少
+测试链接 : https://leetcode.cn/problems/maximum-value-of-k-coins-from-piles/
+
+给你一个二进制字符串数组 strs 和两个整数 m 和 n
+请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1
+如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集
+测试链接 : https://leetcode.cn/problems/ones-and-zeroes/
+
+集团里有 n 名员工，他们可以完成各种各样的工作创造利润
+第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与
+如果成员参与了其中一项工作，就不能参与另一项工作
+工作的任何至少产生 minProfit 利润的子集称为 盈利计划
+并且工作的成员总数最多为 n
+有多少种计划可以选择？因为答案很大，所以 返回结果模 10^9 + 7 的值。
+测试链接 : https://leetcode.cn/problems/profitable-schemes/
+
+在一个小城市里，有 m 个房子排成一排
+你需要给每个房子涂上 n 种颜色之一（颜色编号为 1 到 n )
+有的房子去年夏天已经涂过颜色了，所以这些房子不可以被重新涂色
+我们将连续相同颜色尽可能多的房子称为一个街区
+比方说 houses = [1,2,2,3,3,2,1,1]
+它包含 5 个街区  [{1}, {2,2}, {3,3}, {2}, {1,1}]
+给你一个数组 houses ，一个 m * n 的矩阵 cost 和一个整数 target，其中：
+houses[i]：是第 i 个房子的颜色，0 表示这个房子还没有被涂色
+cost[i][j]：是将第 i 个房子涂成颜色 j+1 的花费
+请你返回房子涂色方案的最小总花费，使得每个房子都被涂色后，恰好组成 target 个街区
+如果没有可用的涂色方案，请返回 -1
+测试链接 : https://leetcode.cn/problems/paint-house-iii/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\344\275\223\347\263\273\345\255\246\344\271\240\347\217\255" "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\344\275\223\347\263\273\345\255\246\344\271\240\347\217\255"
new file mode 100644
index 0000000..2255ecf
--- /dev/null
+++ "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\344\275\223\347\263\273\345\255\246\344\271\240\347\217\255"
@@ -0,0 +1,1493 @@
+算法和数据结构体系学习班
+
+00 算法和数据结构学前必看
+
+内容：
+
+算法和数据结构课程体系介绍
+
+算法和数据结构学习路线
+
+算法和数据结构学习方式推荐
+
+算法和数据结构面试软技巧
+
+同学们的各种答疑问题
+
+
+
+01 时间复杂度、空间复杂度、对数器和二分法
+
+内容：
+
+评估算法优劣的核心指标
+
+时间复杂度、空间复杂度、估算方式、意义
+
+常数时间的操作
+
+选择排序、冒泡排序、插入排序
+
+最优解
+
+对数器
+
+二分法
+
+题目：
+
+选择排序及其对数器验证
+
+冒泡排序及其对数器验证
+
+插入排序及其对数器验证
+
+有序数组中找到num
+
+有序数组中找到>=num最左的位置
+
+有序数组中找到<=num最右的位置
+
+局部最小值问题
+定义何为局部最小值：
+arr[0] < arr[1]，0位置是局部最小；
+arr[N-1] < arr[N-2]，N-1位置是局部最小；
+arr[i-1] > arr[i] < arr[i+1]，i位置是局部最小；
+给定一个数组arr，已知任何两个相邻的数都不相等，找到随便一个局部最小位置返回
+
+
+
+02 异或运算、进一步认识对数器的重要性
+
+内容：
+
+异或运算的性质
+
+异或运算的题目
+
+题目：
+
+不用额外变量交换两个数的值
+
+不用额外变量交换数组中两个数的值
+
+一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这种数 
+
+怎么把一个int类型的数，提取出二进制中最右侧的1来
+
+一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数 
+
+一个数组中有一种数出现K次，其他数都出现了M次，
+已知M > 1，K < M，找到出现了K次的数
+要求额外空间复杂度O(1)，时间复杂度O(N)
+
+
+
+03 单双链表、栈和队列、递归和Master公式、哈希表和有序表的使用和性能
+
+内容：
+
+单链表、双链表
+
+栈、队列
+
+递归的物理实质
+
+评估递归复杂度的Master公式
+
+哈希表的使用和性能
+
+有序表的使用和性能
+
+题目：
+
+反转单链表、反转双链表
+
+在链表中删除指定值的所有节点
+
+用双链表实现栈和队列
+
+用环形数组实现栈和队列
+
+实现有getMin功能的栈
+
+两个栈实现队列
+
+两个队列实现栈
+
+用递归行为得到数组中的最大值，并用master公式来估计时间复杂度
+
+哈希表和有序表使用的code展示
+
+
+
+04 归并排序及其常见面试题
+
+内容：
+
+归并排序
+
+题目：
+
+归并排序的递归和非递归实现
+
+在一个数组中，一个数左边比它小的数的总和，叫该数的小和
+所有数的小和累加起来，叫数组小和
+例子： [1,3,4,2,5] 
+1左边比1小的数：没有
+3左边比3小的数：1
+4左边比4小的数：1、3
+2左边比2小的数：1
+5左边比5小的数：1、3、4、 2
+所以数组的小和为1+1+3+1+1+3+4+2=16 
+给定一个数组arr，求数组小和
+
+在一个数组中，任何一个前面的数a，和任何一个后面的数b，如果(a,b)是降序的，就称为降序对
+给定一个数组arr，求数组的降序对总数量
+
+在一个数组中，对于任何一个数num，求有多少个(后面的数*2)依然<num，返回总个数
+比如：[3,1,7,0,2]
+3的后面有：1，0
+1的后面有：0
+7的后面有：0，2
+0的后面没有
+2的后面没有
+所以总共有5个
+
+
+
+05 归并排序面试题(续)、快速排序
+
+内容：
+
+再来一个归并排序面试题
+
+荷兰国旗问题
+
+快速排序1.0
+
+快速排序2.0
+
+快速排序3.0
+
+题目：
+
+给定一个数组arr，两个整数lower和upper，
+返回arr中有多少个子数组的累加和在[lower,upper]范围上
+Leetcode题目：https://leetcode.com/problems/count-of-range-sum/
+
+荷兰国旗问题的实现
+
+快速排序从1.0到3.0的实现
+
+快速排序的递归实现和非递归实现
+
+code附加，双向链表进行快速排序的code实现
+
+
+
+06 比较器、堆结构、堆排序
+
+内容：
+
+比较器
+
+堆结构
+
+堆排序
+
+建立大根堆的两种方式，从上到下、从下到上，及其复杂度分析
+
+题目：
+
+比较器使用的code展示
+
+堆结构的实现
+
+堆排序的实现
+
+已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k
+k相对于数组长度来说是比较小的。请选择一个合适的排序策略，对这个数组进行排序。 
+
+
+
+07 和堆有关的面试题、加强堆结构
+
+内容：
+
+线段最大重合问题
+
+加强堆的实现
+
+题目：
+
+给定很多线段，每个线段都有两个数[start, end]，
+表示线段开始位置和结束位置，左右都是闭区间
+规定：
+1）线段的开始和结束位置一定都是整数值
+2）线段重合区域的长度必须>=1
+返回线段最多重合区域中，包含了几条线段
+
+加强堆的实现、注意点解析
+
+做一个加强堆的题目，给定一个整型数组，int[] arr；和一个布尔类型数组，boolean[] op
+两个数组一定等长，假设长度为N，arr[i]表示客户编号，op[i]表示客户操作
+arr= [3,3,1,2,1,2,5…
+op = [T,T,T,T,F,T,F…
+依次表示：
+3用户购买了一件商品
+3用户购买了一件商品
+1用户购买了一件商品
+2用户购买了一件商品
+1用户退货了一件商品
+2用户购买了一件商品
+5用户退货了一件商品…
+一对arr[i]和op[i]就代表一个事件：
+用户号为arr[i]，op[i] == T就代表这个用户购买了一件商品
+op[i] == F就代表这个用户退货了一件商品
+现在你作为电商平台负责人，你想在每一个事件到来的时候，
+都给购买次数最多的前K名用户颁奖。
+所以每个事件发生后，你都需要一个得奖名单（得奖区）。
+得奖系统的规则：
+1，如果某个用户购买商品数为0，但是又发生了退货事件，
+     则认为该事件无效，得奖名单和上一个事件发生后一致，例子中的5用户
+2，某用户发生购买商品事件，购买商品数+1，发生退货事件，购买商品数-1
+3，每次都是最多K个用户得奖，K也为传入的参数
+      如果根据全部规则，得奖人数确实不够K个，那就以不够的情况输出结果
+4，得奖系统分为得奖区和候选区，任何用户只要购买数>0，
+      一定在这两个区域中的一个
+5，购买数最大的前K名用户进入得奖区，
+      在最初时如果得奖区没有到达K个用户，那么新来的用户直接进入得奖区
+6，如果购买数不足以进入得奖区的用户，进入候选区
+7，如果候选区购买数最多的用户，已经足以进入得奖区，
+     该用户就会替换得奖区中购买数最少的用户（大于才能替换），
+     如果得奖区中购买数最少的用户有多个，就替换最早进入得奖区的用户
+     如果候选区中购买数最多的用户有多个，机会会给最早进入候选区的用户
+8，候选区和得奖区是两套时间，
+     因用户只会在其中一个区域，所以只会有一个区域的时间，另一个没有
+     从得奖区出来进入候选区的用户，得奖区时间删除，
+     进入候选区的时间就是当前事件的时间（可以理解为arr[i]和op[i]中的i）
+     从候选区出来进入得奖区的用户，候选区时间删除，
+     进入得奖区的时间就是当前事件的时间（可以理解为arr[i]和op[i]中的i）
+9，如果某用户购买数==0，不管在哪个区域都离开，区域时间删除，
+     离开是指彻底离开，哪个区域也不会找到该用户
+     如果下次该用户又发生购买行为，产生>0的购买数，
+     会再次根据之前规则回到某个区域中，进入区域的时间重记
+请遍历arr数组和op数组，遍历每一步输出一个得奖名单
+public List<List<Integer>>  topK (int[] arr, boolean[] op, int k)
+
+
+
+08 前缀树、不基于比较的排序（计数排序、基数排序）、排序算法的稳定性
+
+内容：
+
+前缀树
+
+计数排序
+
+基数排序
+
+排序算法的稳定性
+
+题目：
+
+前缀树实现
+
+计数排序
+
+基数排序
+
+
+
+09 排序算法大总结、链表及其相关面试题
+
+内容：
+
+排序算法总结
+
+排序算法常见的坑
+
+工程上对排序的常见改进
+
+链表面试题的常见技巧
+
+题目：
+
+输入链表头节点，奇数长度返回中点，偶数长度返回上中点
+输入链表头节点，奇数长度返回中点，偶数长度返回下中点
+输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个
+输入链表头节点，奇数长度返回中点前一个，偶数长度返回下中点前一个
+
+给定一个单链表的头节点head，请判断该链表是否为回文结构
+
+给定一个单链表的头节点head，给定一个整数n，将链表按n划分成左边<n、中间==n、右边>n
+
+一种特殊的单链表节点类描述如下 
+class Node {
+int value; 
+Node next; 
+Node rand; 
+Node(int val) { value = val; } 
+} 
+rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null
+给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表的复制
+返回复制的新链表的头节点，要求时间复杂度O(N)，额外空间复杂度O(1) 
+
+
+
+10 链表相关面试题（续）、二叉树的常见遍历
+
+内容：
+
+单链表的相交节点系列问题
+
+一种看似高效其实搞笑的节点删除方式
+
+二叉树的中序、先序、后序遍历
+
+题目：
+
+给定两个可能有环也可能无环的单链表，头节点head1和head2
+请实现一个函数，如果两个链表相交，请返回相交的第一个节点。如果不相交返回null 
+要求如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)
+
+能不能不给单链表的头节点，只给想要删除的节点，就能做到在链表上把这个点删掉？
+
+二叉树先序、中序、后序的递归遍历和递归序
+
+二叉树先序、中序、后序的非递归遍历
+
+
+
+11 二叉树常见面试题和二叉树的递归套路（上）
+
+内容：
+
+通过题目来熟悉二叉树的解题技巧
+
+题目：
+
+二叉树的按层遍历
+
+二叉树的序列化和反序列化
+
+N叉树如何通过二叉树来序列化、并完成反序列化
+Leetcode题目：https://leetcode.com/problems/encode-n-ary-tree-to-binary-tree/
+
+打印二叉树的函数设计
+
+求二叉树的最大宽度
+
+求二叉树某个节点的后继节点
+二叉树结构如下定义：
+Class Node {
+	V value;
+	Node left;
+	Node right;
+	Node parent;
+}
+给你二叉树中的某个节点，返回该节点的后继节点 
+
+折纸问题
+请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后展开
+此时折痕是凹下去的，即折痕突起的方向指向纸条的背面
+如果从纸条的下边向上方连续对折2次，压出折痕后展开
+此时有三条折痕，从上到下依次是下折痕、下折痕和上折痕。 
+给定一个输入参数N，代表纸条都从下边向上方连续对折N次
+请从上到下打印所有折痕的方向。 
+N=1时，打印: down 
+N=2时，打印: down down up 
+
+
+
+12 二叉树常见面试题和二叉树的递归套路（中）
+
+内容：
+
+通过题目来熟悉二叉树的解题技巧
+
+介绍二叉树的递归套路
+1）假设以X节点为头，假设可以向X左树和X右树要任何信息
+2）在上一步的假设下，讨论以X为头节点的树，得到答案的可能性（最重要）
+3）列出所有可能性后，确定到底需要向左树和右树要什么样的信息
+4）把左树信息和右树信息求全集，就是任何一棵子树都需要返回的信息S
+5）递归函数都返回S，每一棵子树都这么要求
+6）写代码，在代码中考虑如何把左树的信息和右树信息整合出整棵树的信息
+
+题目：
+
+判断二叉树是不是搜索二叉树
+
+判断二叉树是不是平衡二叉树
+
+判断二叉树是不是满二叉树
+
+给定一棵二叉树的头节点head，返回这颗二叉树中最大的二叉搜索子树的大小
+
+给定一棵二叉树的头节点head，任何两个节点之间都存在距离，返回整棵二叉树的最大距离
+
+
+
+13 二叉树常见面试题和二叉树的递归套路（下）、贪心算法
+
+内容：
+
+二叉树递归套路继续实践
+
+一道贪心算法从头到尾的完整做法
+
+解决贪心题目的重要技巧，即对数器来验证脑洞
+
+再次强调对数器的重要性
+
+题目：
+
+判断二叉树是不是完全二叉树（一般方法解决、递归套路解决）
+
+给定一棵二叉树的头节点head，返回这颗二叉树中最大的二叉搜索子树的头节点
+
+给定一棵二叉树的头节点head，和另外两个节点a和b，返回a和b的最低公共祖先
+
+派对的最大快乐值
+ 员工信息的定义如下:
+class Employee {
+    public int happy; // 这名员工可以带来的快乐值
+    List<Employee> subordinates; // 这名员工有哪些直接下级
+}
+公司的每个员工都符合 Employee 类的描述。整个公司的人员结构可以看作是一棵标准的、 没有环的多叉树
+树的头节点是公司唯一的老板，除老板之外的每个员工都有唯一的直接上级
+叶节点是没有任何下属的基层员工(subordinates列表为空)，除基层员工外每个员工都有一个或多个直接下级
+这个公司现在要办party，你可以决定哪些员工来，哪些员工不来，规则：
+1.如果某个员工来了，那么这个员工的所有直接下级都不能来
+2.派对的整体快乐值是所有到场员工快乐值的累加
+3.你的目标是让派对的整体快乐值尽量大
+给定一棵多叉树的头节点boss，请返回派对的最大快乐值。
+
+给定一个由字符串组成的数组strs，必须把所有的字符串拼接起来，返回所有可能的拼接结果中字典序最小的结果
+
+
+
+14 贪心算法（续）、并查集
+
+内容：
+
+贪心算法继续实战
+
+并查集详解
+
+题目：
+
+给定一个字符串str，只由'X'和'.'两种字符构成
+'X'表示墙，不能放灯，也不需要点亮；'.'表示居民点，可以放灯，需要点亮
+如果灯放在i位置，可以让i-1，i和i+1三个位置被点亮
+返回如果点亮str中所有需要点亮的位置，至少需要几盏灯
+
+一块金条切成两半，是需要花费和长度数值一样的铜板
+比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板? 
+例如，给定数组{10,20,30}，代表一共三个人，整块金条长度为60，金条要分成10，20，30三个部分。
+如果先把长度60的金条分成10和50，花费60；再把长度50的金条分成20和30，花费50；一共花费110铜板
+但如果先把长度60的金条分成30和30，花费60；再把长度30金条分成10和20，花费30；一共花费90铜板
+输入一个数组，返回分割的最小代价
+
+一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲，给你每一个项目开始的时间和结束的时间
+你来安排宣讲的日程，要求会议室进行的宣讲的场次最多，返回最多的宣讲场次
+
+输入正数数组costs、正数数组profits、正数K和正数M
+costs[i]表示i号项目的花费
+profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润)
+K表示你只能串行的最多做k个项目
+M表示你初始的资金
+说明：每做完一个项目，马上获得的收益，可以支持你去做下一个项目，不能并行的做项目。
+输出：最后获得的最大钱数
+
+并查集的实现
+
+
+
+15 并查集相关的常见面试题
+
+内容：
+
+通过解答实际出现的面试题来体会并查集的优势、熟悉并查集的使用
+
+题目：
+
+一群朋友中，有几个不相交的朋友圈
+Leetcode题目：https://leetcode.com/problems/friend-circles/
+
+岛问题（递归解法 + 并查集解法 + 并行解法）
+给定一个二维数组matrix，里面的值不是1就是0，上、下、左、右相邻的1认为是一片岛，返回matrix中岛的数量
+
+
+
+16 图及其与图相关的算法
+
+内容：
+
+图的表达方式
+
+图的常见描述
+
+图的宽度优先遍历
+
+图的深度优先遍历
+
+图的拓扑排序
+
+最小生成树算法Kruskal
+
+最小生成树算法Prim
+
+单元最短路径算法Dijkstra
+
+题目：
+
+图的数据结构抽象
+
+实现图的宽度优先遍历
+
+实现图的深度优先遍历
+
+三种方式实现图的拓扑排序
+
+用并查集实现Kruskal算法
+
+用堆实现Prim算法
+
+实现Dijkstra算法，用加强堆做更好的实现（16节+17节一开始）
+
+
+
+17 用加强堆更好的实现Dijkstra算法、常见的递归
+
+内容：
+
+加强堆实现Dijkstra算法
+
+递归的设计
+
+常见的递归
+
+题目：
+
+打印n层汉诺塔从最左边移动到最右边的全部过程（递归+非递归实现）
+
+打印一个字符串的全部子序列
+
+打印一个字符串的全部子序列，要求不要出现重复字面值的子序列
+
+打印一个字符串的全部排列
+
+打印一个字符串的全部排列，要求不要出现重复的排列
+
+给定一个栈，请逆序这个栈，不能申请额外的数据结构，只能使用递归函数
+
+
+
+18 暴力递归到动态规划（一）
+
+内容：
+
+讲述暴力递归和动态规划的关系
+
+记忆化搜索
+
+动态规划都可以由暴力递归改进过来，解决动态规划的套路
+
+常见的尝试模型
+
+设计尝试过程的原则
+
+本节是暴力递归到动态规划的总纲（很重要）
+
+后续的课都是在讲述这一系列的套路
+
+题目：
+
+假设有排成一行的N个位置记为1~N，N一定大于或等于2
+开始时机器人在其中的M位置上(M一定是1~N中的一个)
+如果机器人来到1位置，那么下一步只能往右来到2位置；
+如果机器人来到N位置，那么下一步只能往左来到N-1位置；
+如果机器人来到中间位置，那么下一步可以往左走或者往右走；
+规定机器人必须走K步，最终能来到P位置(P也是1~N中的一个)的方法有多少种
+给定四个参数 N、M、K、P，返回方法数
+
+给定一个整型数组arr，代表数值不同的纸牌排成一条线
+玩家A和玩家B依次拿走每张纸牌
+规定玩家A先拿，玩家B后拿
+但是每个玩家每次只能拿走最左或最右的纸牌
+玩家A和玩家B都绝顶聪明
+请返回最后获胜者的分数
+
+
+
+19 暴力递归到动态规划（二）
+
+内容：
+
+以18节为总纲
+
+背包问题
+
+记忆化搜索的一个很重要的注意点
+
+通过面试题进一步强化动态规划的解题套路
+
+题目：
+
+背包问题
+给定两个长度都为N的数组weights和values，weights[i]和values[i]分别代表 i号物品的重量和价值
+给定一个正数bag，表示一个载重bag的袋子，装的物品不能超过这个重量
+返回能装下的最大价值
+
+规定1和A对应、2和B对应、3和C对应...26和Z对应
+那么一个数字字符串比如"111”就可以转化为:
+"AAA"、"KA"和"AK"
+给定一个只有数字字符组成的字符串str，返回有多少种转化结果 
+
+给定一个字符串str，给定一个字符串类型的数组arr，出现的字符都是小写英文
+arr每一个字符串，代表一张贴纸，你可以把单个字符剪开使用，目的是拼出str来
+返回需要至少多少张贴纸可以完成这个任务
+例子：str= "babac"，arr = {"ba","c","abcd"}
+ba + ba + c  3  abcd + abcd 2  abcd+ba 2
+所以返回2
+
+给定两个字符串str1和str2，
+返回这两个字符串的最长公共子序列长度
+比如 ： str1 = “a12b3c456d”,str2 = “1ef23ghi4j56k”
+最长公共子序列是“123456”，所以返回长度6
+
+
+
+20 暴力递归到动态规划（三）
+
+内容：
+
+以18节为总纲
+
+通过面试题进一步强化动态规划的解题套路
+
+题目：
+
+给定一个字符串str，返回这个字符串的最长回文子序列长度
+比如 ： str = “a12b3c43def2ghi1kpm”
+最长回文子序列是“1234321”或者“123c321”，返回长度7
+
+请同学们自行搜索或者想象一个象棋的棋盘，
+然后把整个棋盘放入第一象限，棋盘的最左下角是(0,0)位置
+那么整个棋盘就是横坐标上9条线、纵坐标上10条线的区域
+给你三个 参数 x，y，k
+返回“马”从(0,0)位置出发，必须走k步
+最后落在(x,y)上的方法数有多少种? 
+
+给定一个数组arr，arr[i]代表第i号咖啡机泡一杯咖啡的时间
+给定一个正数N，表示N个人等着咖啡机泡咖啡，每台咖啡机只能轮流泡咖啡
+只有一台咖啡机，一次只能洗一个杯子，时间耗费a，洗完才能洗下一杯
+每个咖啡杯也可以自己挥发干净，时间耗费b，咖啡杯可以并行挥发
+假设所有人拿到咖啡之后立刻喝干净，
+返回从开始等到所有咖啡机变干净的最短时间
+三个参数：int[] arr、int N，int a、int b
+
+
+
+21 暴力递归到动态规划（四）
+
+内容：
+
+以18节为总纲
+
+通过面试题进一步强化动态规划的解题套路
+
+题目：
+
+给定一个二维数组matrix，一个人必须从左上角出发，最后到达右下角
+沿途只可以向下或者向右走，沿途的数字都累加就是距离累加和
+返回最小距离累加和
+
+arr是货币数组，其中的值都是正数。再给定一个正数aim。
+每个值都认为是一张货币，
+即便是值相同的货币也认为每一张都是不同的，
+返回组成aim的方法数
+例如：arr = {1,1,1}，aim = 2
+第0个和第1个能组成2，第1个和第2个能组成2，第0个和第2个能组成2
+一共就3种方法，所以返回3
+
+arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。
+每个值都认为是一种面值，且认为张数是无限的。
+返回组成aim的方法数
+例如：arr = {1,2}，aim = 4
+方法如下：1+1+1+1、1+1+2、2+2
+一共就3种方法，所以返回3
+
+arr是货币数组，其中的值都是正数。再给定一个正数aim。
+每个值都认为是一张货币，
+认为值相同的货币没有任何不同，
+返回组成aim的方法数
+例如：arr = {1,2,1,1,2,1,2}，aim = 4
+方法：1+1+1+1、1+1+2、2+2
+一共就3种方法，所以返回3
+
+给定5个参数，N，M，row，col，k
+表示在N*M的区域上，醉汉Bob初始在(row,col)位置
+Bob一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位
+任何时候Bob只要离开N*M的区域，就直接死亡
+返回k步之后，Bob还在N*M的区域的概率
+
+
+
+22 暴力递归到动态规划（五）
+
+内容：
+
+以18节为总纲
+
+通过面试题进一步强化动态规划的解题套路
+
+斜率优化技巧
+
+题目：
+
+给定3个参数，N，M，K
+怪兽有N滴血，等着英雄来砍自己
+英雄每一次打击，都会让怪兽流失[0~M]的血量
+到底流失多少？每一次在[0~M]上等概率的获得一个值
+求K次打击之后，英雄把怪兽砍死的概率
+
+arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。
+每个值都认为是一种面值，且认为张数是无限的。
+返回组成aim的最少货币数
+
+给定一个正数n，求n的裂开方法数，
+规定：后面的数不能比前面的数小
+比如4的裂开方法有：
+1+1+1+1、1+1+2、1+3、2+2、4
+5种，所以返回5
+
+
+
+23 暴力递归到动态规划（六）
+
+内容：
+
+以18节为总纲
+
+通过面试题进一步强化动态规划的解题套路
+
+位信息技巧
+
+题目：
+
+给定一个正数数组arr，
+请把arr中所有的数分成两个集合，尽量让两个集合的累加和接近
+返回最接近的情况下，较小集合的累加和
+
+给定一个正数数组arr，请把arr中所有的数分成两个集合
+如果arr长度为偶数，两个集合包含数的个数要一样多
+如果arr长度为奇数，两个集合包含数的个数必须只差一个
+请尽量让两个集合的累加和接近
+返回最接近的情况下，较小集合的累加和
+
+N皇后问题是指在N*N的棋盘上要摆N个皇后，
+要求任何两个皇后不同行、不同列， 也不在同一条斜线上
+给定一个整数n，返回n皇后的摆法有多少种。n=1，返回1
+n=2或3，2皇后和3皇后问题无论怎么摆都不行，返回0
+n=8，返回92
+
+
+
+24 窗口内最大值或最小值的更新结构
+
+内容：
+
+滑动窗口
+
+窗口内最大值或最小值的更新结构
+
+用题目来学习窗口内最大值或最小值的更新结构提供的便利性
+
+题目：
+
+窗口内最大值或最小值更新结构的实现
+假设一个固定大小为W的窗口，依次划过arr，
+返回每一次滑出状况的最大值
+例如，arr = [4,3,5,4,3,3,6,7], W = 3
+返回：[5,5,5,4,6,7]
+
+给定一个整型数组arr，和一个整数num
+某个arr中的子数组sub，如果想达标，必须满足：sub中最大值 – sub中最小值 <= num，
+返回arr中达标子数组的数量
+
+加油站的良好出发点问题
+
+动态规划中利用窗口内最大值或最小值更新结构做优化（难）
+arr是货币数组，其中的值都是正数。再给定一个正数aim。
+每个值都认为是一张货币，
+返回组成aim的最少货币数
+注意：因为是求最少货币数，所以每一张货币认为是相同或者不同就不重要了
+
+
+
+25 单调栈
+
+内容：
+
+单调栈的原理（无重复数+有重复数）
+
+用题目来学习单调栈提供的便利性
+
+题目：
+
+单调栈实现（无重复数+有重复数）
+
+给定一个只包含正数的数组arr，arr中任何一个子数组sub，
+一定都可以算出(sub累加和 )* (sub中的最小值)是什么，
+那么所有子数组中，这个值最大是多少？
+
+给定一个非负数组arr，代表直方图，返回直方图的最大长方形面积
+
+给定一个二维数组matrix，其中的值不是0就是1，返回全部由1组成的最大子矩形内部有多少个1（面积）
+
+给定一个二维数组matrix，其中的值不是0就是1，返回全部由1组成的子矩形数量
+
+
+
+26 单调栈相关的题目（续）、斐波那契数列的矩阵快速幂模型
+
+内容：
+
+再讲一个单调栈相关的面试题
+
+斐波那契数列的矩阵快速幂模型详解
+
+题目：
+
+给定一个数组arr，返回所有子数组最小值的累加和
+
+斐波那契数列矩阵乘法方式的实现
+
+台阶方法数问题
+一个人可以一次往上迈1个台阶，也可以迈2个台阶，返回迈上N级台阶的方法数
+
+奶牛生小牛问题
+第一年农场有1只成熟的母牛A，往后的每年：
+1）每一只成熟的母牛都会生一只母牛
+2）每一只新出生的母牛都在出生的第三年成熟
+3）每一只母牛永远不会死
+返回N年后牛的数量
+
+给定一个数N，想象只由0和1两种字符，组成的所有长度为N的字符串
+如果某个字符串，任何0字符的左边都有1紧挨着，认为这个字符串达标
+返回有多少达标的字符串
+
+用1*2的瓷砖，把N*2的区域填满，返回铺瓷砖的方法数
+
+
+
+27 KMP算法
+
+内容：
+
+KMP算法
+
+和KMP算法相关的面试题
+
+题目：
+
+KMP算法实现
+
+给定两棵二叉树的头节点head1和head2，返回head1中是否有某个子树的结构和head2完全一样
+
+判断str1和str2是否互为旋转字符串
+
+
+
+28 Manacher算法
+
+内容：
+
+Manacher算法
+
+和Manacher算法相关的面试题
+
+题目：
+
+Manacher算法实现
+
+给定一个字符串str，只能在str的后面添加字符，想让str整体变成回文串，返回至少要添加几个字符
+
+
+
+29 在无序数组中找到第K小的数、蓄水池算法
+
+内容：
+
+时间复杂度O(N)可以解决在无序数组中找到第K小的数，这个经典的面试题
+
+改写快排的partition方法
+
+bfprt算法
+
+蓄水池算法
+
+题目：
+
+在无序数组中找到第K小的数（改写快排+bfprt）
+
+设计在无序数组中收集最大的前K个数字的算法（根据不同的三个时间复杂度，设计三个算法）
+给定一个无序数组arr中，长度为N，给定一个正数k，返回top k个最大的数
+不同时间复杂度三个方法：
+1）O(N*logN)
+2）O(N + K*logN)
+3）O(n + k*logk)
+
+蓄水池算法实现
+假设有一个源源吐出不同球的机器，
+只有装下10个球的袋子，每一个吐出的球，要么放入袋子，要么永远扔掉
+如何做到机器吐出每一个球之后，所有吐出的球都等概率被放进袋子里
+
+
+
+
+30 二叉树的Morris遍历
+
+内容：
+
+二叉树之前的遍历方式有空间浪费的问题
+
+Morris遍历时间复杂度O(N)，额外空间复杂度O(1)，通过利用原树中大量空闲指针的方式，达到节省空间的目的
+
+假设来到当前节点cur，开始时cur来到头节点位置
+1）如果cur没有左孩子，cur向右移动(cur = cur.right)
+2）如果cur有左孩子，找到左子树上最右的节点mostRight：
+	a.如果mostRight的右指针指向空，让其指向cur，
+	然后cur向左移动(cur = cur.left)
+	b.如果mostRight的右指针指向cur，让其指向null，
+	然后cur向右移动(cur = cur.right)
+3）cur为空时遍历停止
+
+Morris遍历实现二叉树的先序、中序、后序遍历
+
+题目：
+
+Morris遍历的实现
+
+给定一棵二叉树的头节点head，求以head为头的树中，最小深度是多少？
+
+
+
+31 线段树
+
+内容：
+
+线段树是一种支持范围整体修改和范围整体查询的数据结构
+
+线段树解决的问题范畴：大范围信息可以只由左、右两侧信息加工出，而不必遍历左右两个子范围的具体状况
+
+题目：
+
+给定一个数组arr，用户希望你实现如下三个方法
+1）void add(int L, int R, int V) :  让数组arr[L…R]上每个数都加上V
+2）void update(int L, int R, int V) :  让数组arr[L…R]上每个数都变成V
+3）int sum(int L, int R) :让返回arr[L…R]这个范围整体的累加和
+怎么让这三个方法，时间复杂度都是O(logN)
+
+想象一下标准的俄罗斯方块游戏，X轴是积木最终下落到底的轴线
+下面是这个游戏的简化版：
+1）只会下落正方形积木
+2）[a,b] -> 代表一个边长为b的正方形积木，积木左边缘沿着X = a这条线从上方掉落
+3）认为整个X轴都可能接住积木，也就是说简化版游戏是没有整体的左右边界的
+4）没有整体的左右边界，所以简化版游戏不会消除积木，因为不会有哪一层被填满。
+给定一个N*2的二维数组matrix，可以代表N个积木依次掉落，
+返回每一次掉落之后的最大高度
+Leetcode题目：https://leetcode.com/problems/falling-squares/
+
+
+
+32 IndexTree、AC自动机
+
+内容：
+
+IndexTree
+1）支持区间查询
+2）没有线段树那么强，但是非常容易改成一维、二维、三维的结构
+3）只支持单点更新
+
+AC自动机
+解决在一个大字符串中，找到多个候选字符串的问题
+1）把所有匹配串生成一棵前缀树
+2）前缀树节点增加fail指针
+3）fail指针的含义：如果必须以当前字符结尾，当前形成的路径是str，剩下哪一个字符串的前缀和str的后缀
+   拥有最大的匹配长度。fail指针就指向那个字符串的最后一个字符所对应的节点（迷不迷？听讲述！）
+
+题目：
+
+IndexTree在一维数组和二维数组上的实现
+
+AC自动机的实现
+
+
+
+33 与哈希函数有关的结构
+
+内容：
+
+哈希函数
+
+哈希函数的应用
+
+布隆过滤器
+
+一致性哈希
+
+题目：
+
+原理讲述为主，面试只会聊设计，所以本节无题目
+
+
+
+34 资源限制类题目的解题套路
+
+内容：
+
+布隆过滤器用于集合的建立与查询，并可以节省大量空间
+一致性哈希解决数据服务器的负载管理问题
+利用并查集结构做岛问题的并行计算
+哈希函数可以把数据按照种类均匀分流
+位图解决某一范围上数字的出现情况，并可以节省大量空间
+利用分段统计思想、并进一步节省大量空间
+利用堆、外排序来做多个处理单元的结果合并
+
+题目：
+
+32位无符号整数的范围是0~4,294,967,295，
+现在有一个正好包含40亿个无符号整数的文件，
+可以使用最多1GB的内存，怎么找到出现次数最多的数？
+
+32位无符号整数的范围是0~4,294,967,295，现在有一个正好包含40亿个无符号整数的文件，
+所以在整个范围中必然存在没出现过的数，可以使用最多1GB的内存，怎么找到所有未出现过的数？
+进阶：内存限制为 3KB，但是只用找到一个没出现过的数即可
+
+有一个包含100亿个URL的大文件，假设每个URL占用64B，请找出其中所有重复的URL
+补充：某搜索公司一天的用户搜索词汇是海量的(百亿数据量)，请设计一种求出每天热门Top100词汇的可行办法
+
+32位无符号整数的范围是0~4294967295，现在有40亿个无符号整数，可以使用最多1GB的内存，找出所有出现了两次的数
+
+32位无符号整数的范围是0~4294967295，现在有40亿个无符号整数，可以使用最多3K的内存，怎么找到这40亿个整数的中位数？
+
+32位无符号整数的范围是0~4294967295，有一个10G大小的文件，每一行都装着这种类型的数字，
+整个文件是无序的，给你5G的内存空间，请你输出一个10G大小的文件，就是原文件所有数字排序的结果
+
+
+
+35 有序表（上）
+
+内容：
+
+平衡搜索二叉树
+
+左旋
+
+右旋
+
+AVL树的节点违规4种类型（LL，LR，RL，RR）
+
+题目：
+
+AVL树的实现
+
+
+
+36 有序表（中）
+
+内容：
+
+size-balanced-tree详解
+
+skiplist详解
+
+聊聊红黑树
+
+题目：
+
+size-balanced-tree实现
+
+skiplist实现
+
+
+
+37 有序表（下）
+
+内容：
+
+讲解有序表相关的面试题
+
+讲解改写有序表的题目核心点
+
+题目：
+
+给定一个数组arr，和两个整数a和b（a<=b）。求arr中有多少个子数组，累加和在[a,b]这个范围上。返回达标的子数组数量
+
+有一个滑动窗口：
+1）L是滑动窗口最左位置、R是滑动窗口最右位置，一开始LR都在数组左侧
+2）任何一步都可能R往右动，表示某个数进了窗口
+3）任何一步都可能L往右动，表示某个数出了窗口
+想知道每一个窗口状态的中位数
+
+设计一个结构包含如下两个方法：
+void add(int index, int num)：把num加入到index位置
+int get(int index) ：取出index位置的值
+void remove(int index) ：把index位置上的值删除
+要求三个方法时间复杂度O(logN)
+
+假设有打乱顺序的一群人站成一个队列，数组people表示队列中一些人的属性（不一定按顺序）
+每个people[i]=[hi, ki]表示第i个人的身高为hi，前面正好有ki个身高大于或等于hi的人
+请你重新构造并返回输入数组people所表示的队列，返回的队列应该格式化为数组queue
+其中queue[j]=[hj, kj]是队列中第j个人的属性（queue[0] 是排在队列前面的人）。
+Leetcode题目：https://leetcode.com/problems/queue-reconstruction-by-height/
+
+
+
+38 根据对数器找规律、根据数据量猜解法
+
+内容：
+
+讲解对数器找规律的解题技巧
+
+讲解根据数据量猜解法的技巧
+1）C/C++，1秒处理的指令条数为10的8次方
+2）Java等语言，1~4秒处理的指令条数为10的8次方
+3）这里就有大量的分析提示了
+
+
+题目：
+
+小虎去买苹果，商店只提供两种类型的塑料袋，每种类型都有任意数量
+1）能装下6个苹果的袋子
+2）能装下8个苹果的袋子
+小虎可以自由使用两种袋子来装苹果，但是小虎有强迫症，他要求自己使用的袋子数量必须最少，
+且使用的每个袋子必须装满，给定一个正整数N，返回至少使用多少袋子。如果N无法让使用的每个袋子必须装满，返回-1
+
+给定一个正整数N，表示有N份青草统一堆放在仓库里，有一只牛和一只羊，牛先吃，羊后吃，它俩轮流吃草
+不管是牛还是羊，每一轮能吃的草量必须是：1，4，16，64…(4的某次方)
+谁最先把草吃完，谁获胜，假设牛和羊都绝顶聪明，都想赢，都会做出理性的决定。根据唯一的参数N，返回谁会赢
+
+定义一种数：可以表示成若干（数量>1）连续正数和的数
+比如，5=2+3，5就是这样的数；12=3+4+5，12就是这样的数
+2=1+1，2不是这样的数，因为等号右边不是连续正数
+给定一个参数N，返回是不是可以表示成若干连续正数和的数
+
+int[] d，d[i]：i号怪兽的能力
+int[] p，p[i]：i号怪兽要求的钱
+开始时你的能力是0，你的目标是从0号怪兽开始，通过所有的怪兽。
+如果你当前的能力，小于i号怪兽的能力，你必须付出p[i]的钱，贿赂这个怪兽，然后怪兽就会加入你
+他的能力直接累加到你的能力上；如果你当前的能力，大于等于i号怪兽的能力
+你可以选择直接通过，你的能力并不会下降，你也可以选择贿赂这个怪兽，然后怪兽就会加入你
+他的能力直接累加到你的能力上
+返回通过所有的怪兽，需要花的最小钱数
+（课上会给出不同的数据量描述）
+
+
+
+39 根据数据量猜解法（续）、分治技巧、卡特兰数
+
+内容：
+
+继续熟悉根据数据量猜解法
+
+讲解分治法
+
+讲解卡特兰数（课上证明的时候有小错，在40节开始处修正了）
+
+题目：
+
+给定一个非负数组arr，和一个正数m，返回arr的所有子序列中累加和%m之后的最大值
+
+牛牛家里一共有n袋零食, 第i袋零食体积为v[i]，背包容量为w，牛牛想知道在总体积不超过背包容量的情况下,
+一共有多少种零食放法，体积为0也算一种放法
+1 <= n <= 30, 1 <= w <= 2 * 10^9，v[I] (0 <= v[i] <= 10^9）
+
+假设给你N个0，和N个1，你必须用全部数字拼序列，返回有多少个序列满足任何前缀串，1的数量都不少于0的数量
+
+有N个二叉树节点，每个节点彼此之间无任何差别，返回由N个二叉树节点，组成的不同结构数量是多少？
+
+题目补充：	arr中的值可能为正，可能为负，可能为0，自由选择arr中的数字，能不能累加得到sum（多种做法）
+
+
+
+40 子数组达到规定累加和的最大长度系列问题、矩阵处理技巧题
+
+内容：
+
+修正了39节卡特兰数讲解时的一个小错误
+
+熟悉子数组达到规定累加和的三个模型（正、有正有负有0、累加和<=K）
+
+矩阵处理技巧的宏观调度coding技巧
+
+题目：
+
+给定一个正整数组成的无序数组arr，给定一个正整数值K，找到arr的所有子数组里，哪个子数组的累加和等于K
+并且是长度最大的，返回其长度
+
+给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K
+找到arr的所有子数组里，哪个子数组的累加和等于K，并且是长度最大的，返回其长度
+
+给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K
+找到arr的所有子数组里，哪个子数组的累加和<=K，并且是长度最大的，返回其长度
+
+给定一个数组arr，给定一个值v，求子数组平均值小于等于v的最长子数组长度
+
+给定一个正方形矩阵matrix，原地调整成顺时针90度转动的样子
+
+给定一个正方形或者长方形矩阵matrix，实现转圈打印
+
+给定一个正方形或者长方形矩阵matrix，实现zigzag打印
+
+转圈打印星号*问题
+
+
+
+41 四边形不等式技巧（上）
+
+内容：
+
+区间划分问题中的划分点不回退现象
+
+四边形不等式技巧特征
+1，两个可变参数的区间划分问题
+2，每个格子有枚举行为
+3，当两个可变参数固定一个，另一个参数和答案之间存在单调性关系
+4，而且两组单调关系是反向的：(升 升，降 降)  (升 降，降 升)
+5，能否获得指导枚举优化的位置对：上+右，或者，左+下
+
+四边形不等式技巧注意点
+1，不要证明！用对数器验证！
+2，枚举的时候面对最优答案相等的时候怎么处理？用对数器都试试！
+3，可以把时间复杂度降低一阶
+O(N^3) -> O(N^2)
+O(N^2 * M) -> O(N * M) 
+O(N * M^2) -> O(N * M) 
+4，四边形不等式有些时候是最优解，有些时候不是
+不是的原因：尝试思路，在根儿上不够好
+
+题目：
+
+给定一个非负数组arr，长度为N，
+那么有N-1种方案可以把arr切成左右两部分
+每一种方案都有，min{左部分累加和，右部分累加和}
+求这么多方案中，min{左部分累加和，右部分累加和}的最大值是多少？
+整个过程要求时间复杂度O(N)
+
+把题目一中提到的，min{左部分累加和，右部分累加和}，定义为S(N-1)，也就是说：
+S(N-1)：在arr[0…N-1]范围上，做最优划分所得到的min{左部分累加和，右部分累加和}的最大值
+现在要求返回一个长度为N的s数组，
+s[i] =在arr[0…i]范围上，做最优划分所得到的min{左部分累加和，右部分累加和}的最大值
+得到整个s数组的过程，做到时间复杂度O(N)
+
+摆放着n堆石子。现要将石子有次序地合并成一堆，规定每次只能选相邻的2堆石子合并成新的一堆
+并将新的一堆石子数记为该次合并的得分，求出将n堆石子合并成一堆的最小得分（或最大得分）合并方案
+
+给定一个整型数组 arr，数组中的每个值都为正数，表示完成一幅画作需要的时间，再给定一个整数num
+表示画匠的数量，每个画匠只能画连在一起的画作
+所有的画家并行工作，返回完成所有的画作需要的最少时间
+arr=[3,1,4]，num=2。
+最好的分配方式为第一个画匠画3和1，所需时间为4
+第二个画匠画4，所需时间为4
+所以返回4
+arr=[1,1,1,4,3]，num=3
+最好的分配方式为第一个画匠画前三个1，所需时间为3
+第二个画匠画4，所需时间为4
+第三个画匠画3，所需时间为3
+返回4
+
+
+
+42 四边形不等式技巧（下）
+
+内容：
+
+继续熟悉四边形不等式
+
+展示好的尝试是最关键的
+
+题目：
+
+一条直线上有居民点，邮局只能建在居民点上
+给定一个有序正数数组arr，每个值表示 居民点的一维坐标，再给定一个正数 num，表示邮局数量
+选择num个居民点建立num个邮局，使所有的居民点到最近邮局的总距离最短，返回最短的总距离
+arr=[1,2,3,4,5,1000]，num=2
+第一个邮局建立在3位置，第二个邮局建立在1000位置
+那么1位置到邮局的距离为2，2位置到邮局距离为1，3位置到邮局的距离为0，4位置到邮局的距离为1，5位置到邮局的距离为2
+1000位置到邮局的距离为0
+这种方案下的总距离为6，其他任何方案的总距离都不会比该方案的总距离更短，所以返回6
+
+一座大楼有0~N层，地面算作第0层，最高的一层为第N层
+已知棋子从第0层掉落肯定不会摔碎，从第i层掉落可能会摔碎，也可能不会摔碎(1≤i≤N)
+给定整数N作为楼层数，再给定整数K作为棋子数
+返回如果想找到棋子不会摔碎的最高层数，即使在最差的情况下扔的最少次数
+一次只能扔一个棋子
+N=10，K=1
+返回10
+因为只有1棵棋子，所以不得不从第1层开始一直试到第10层
+在最差的情况下，即第10层是不会摔坏的最高层，最少也要扔10次
+N=3，K=2
+返回2
+先在2层扔1棵棋子，如果碎了试第1层，如果没碎试第3层
+N=105，K=2
+返回14
+第一个棋子先在14层扔，碎了则用仅存的一个棋子试1~13
+若没碎，第一个棋子继续在27层扔，碎了则用仅存的一个棋子试15~26
+若没碎，第一个棋子继续在39层扔，碎了则用仅存的一个棋子试28~38
+若没碎，第一个棋子继续在50层扔，碎了则用仅存的一个棋子试40~49
+若没碎，第一个棋子继续在60层扔，碎了则用仅存的一个棋子试51~59
+若没碎，第一个棋子继续在69层扔，碎了则用仅存的一个棋子试61~68
+若没碎，第一个棋子继续在77层扔，碎了则用仅存的一个棋子试70~76
+若没碎，第一个棋子继续在84层扔，碎了则用仅存的一个棋子试78~83
+若没碎，第一个棋子继续在90层扔，碎了则用仅存的一个棋子试85~89
+若没碎，第一个棋子继续在95层扔，碎了则用仅存的一个棋子试91~94
+若没碎，第一个棋子继续在99层扔，碎了则用仅存的一个棋子试96~98
+若没碎，第一个棋子继续在102层扔，碎了则用仅存的一个棋子试100、101
+若没碎，第一个棋子继续在104层扔，碎了则用仅存的一个棋子试103
+若没碎，第一个棋子继续在105层扔，若到这一步还没碎，那么105便是结果
+
+
+
+43 状态压缩的动态规划
+
+内容：
+
+动态规划的状态压缩技巧
+
+题目：
+
+在"100 game"这个游戏中，两名玩家轮流选择从1到10的任意整数，累计整数和
+先使得累计整数和达到或超过100的玩家，即为胜者，如果我们将游戏规则改为 “玩家不能重复使用整数” 呢？
+例如，两个玩家可以轮流从公共整数池中抽取从1到15的整数（不放回），直到累计整数和 >= 100
+给定一个整数 maxChoosableInteger （整数池中可选择的最大数）和另一个整数 desiredTotal（累计和）
+判断先出手的玩家是否能稳赢（假设两位玩家游戏时都表现最佳）
+你可以假设 maxChoosableInteger 不会大于 20， desiredTotal 不会大于 300。
+Leetcode题目：https://leetcode.com/problems/can-i-win/
+
+TSP问题
+有N个城市，任何两个城市之间的都有距离，任何一座城市到自己的距离都为0
+所有点到点的距离都存在一个N*N的二维数组matrix里，也就是整张图由邻接矩阵表示
+现要求一旅行商从k城市出发必须经过每一个城市且只在一个城市逗留一次，最后回到出发的k城
+参数给定一个matrix，给定k。返回总距离最短的路的距离
+
+铺砖问题（最优解其实是轮廓线dp，但是这个解法对大厂刷题来说比较难，掌握课上的解法即可）
+你有无限的1*2的砖块，要铺满M*N的区域，
+不同的铺法有多少种?
+
+
+
+44 DC3生成后缀数组详解
+
+内容：
+
+后缀数组
+
+介绍用DC3算法生成后缀数组的流程
+
+题目：
+
+给你一个字符串 s，找出它的所有子串并按字典序排列，返回排在最后的那个子串
+Leetcode题目：https://leetcode.com/problems/last-substring-in-lexicographical-order/
+
+DC3算法的实现（完全根据论文描述）
+
+
+
+45 后缀数组解决的面试题
+
+内容：
+
+通过题目进一步熟悉DC3算法
+
+通过DC3算法得到height数组
+
+题目：
+
+给定两个字符串str1和str2，想把str2整体插入到str1中的某个位置，形成最大的字典序，返回字典序最大的结果
+
+给两个长度分别为M和N的整型数组nums1和nums2，其中每个值都不大于9，再给定一个正数K。 你可以在nums1和nums2中挑选数字，要求一共挑选K个，并且要从左到右挑。返回所有可能的结果中，代表最大数字的结果
+
+最长公共子串问题是面试常见题目之一，假设str1长度N，str2长度M
+一般在面试场上回答出O(N*M)的解法已经是比较优秀了
+因为得到O(N*M)的解法，就已经需要用到动态规划了
+但其实这个问题的最优解是O(N+M)，需要用到后缀数组+height数组
+课上将对本题解法代码进行详解
+
+
+
+46 动态规划猜法中和外部信息简化的相关问题（上）、哈夫曼树
+
+内容：
+
+以18节做总纲
+
+有些动态规划面试题，需要很好的设计参数，这种设计方式都有"外部信息简化"的特征
+
+哈夫曼树
+
+题目：
+
+有n个气球，编号为0到n-1，每个气球上都标有一个数字，这些数字存在数组nums中
+现在要求你戳破所有的气球。戳破第i个气球，你可以获得nums[i - 1] * nums[i] * nums[i + 1] 枚硬币
+这里的i-1和i+1代表和i相邻的、没有被戳爆的！两个气球的序号
+如果i-1或i+1超出了数组的边界，那么就当它是一个数字为1的气球
+求所能获得硬币的最大数量
+Leetcode题目：https://leetcode.com/problems/burst-balloons/
+
+给出一些不同颜色的盒子，盒子的颜色由数字表示，即不同的数字表示不同的颜色，你将经过若干轮操作去去掉盒子
+直到所有的盒子都去掉为止，每一轮你可以移除具有相同颜色的连续k个盒子（k >= 1）
+这样一轮之后你将得到 k * k 个积分，当你将所有盒子都去掉之后，求你能获得的最大积分和
+Leetcode题目：https://leetcode.com/problems/remove-boxes/
+
+如果一个字符相邻的位置没有相同字符，那么这个位置的字符出现不能被消掉
+比如:"ab"，其中a和b都不能被消掉
+如果一个字符相邻的位置有相同字符，就可以一起消掉
+比如:"abbbc"，中间一串的b是可以被消掉的，消除之后剩下"ac"
+某些字符如果消掉了，剩下的字符认为重新靠在一起
+给定一个字符串，你可以决定每一步消除的顺序，目标是请尽可能多的消掉字符，返回最少的剩余字符数量
+比如："aacca", 如果先消掉最左侧的"aa"，那么将剩下"cca"，然后把"cc"消掉，剩下的"a"将无法再消除，返回1
+但是如果先消掉中间的"cc"，那么将剩下"aaa"，最后都消掉就一个字符也不剩了，返回0，这才是最优解。
+再比如："baaccabb"，
+如果先消除最左侧的两个a，剩下"bccabb"，如果再消除最左侧的两个c，剩下"babb"，最后消除最右侧的两个b，剩下"ba"无法再消除，返回2
+而最优策略是：
+如果先消除中间的两个c，剩下"baaabb"，如果再消除中间的三个a，剩下"bbb"，最后消除三个b，不留下任何字符，返回0，这才是最优解
+
+给定一个数组arr，和一个正数M，返回在arr的子数组在长度不超过M的情况下，最大的累加和
+
+哈夫曼树的实现
+
+
+
+47 动态规划猜法中和外部信息简化的相关问题（下）、最大网络流算法之Dinic算法
+
+内容：
+
+进一步解决带有"外部信息简化"特征的动态规划
+
+Dinic算法
+
+题目：
+
+有台奇怪的打印机有以下两个特殊要求：
+打印机每次只能打印由同一个字符组成的序列。
+每次可以在任意起始和结束位置打印新字符，并且会覆盖掉原来已有的字符。
+给你一个字符串s，你的任务是计算这个打印机打印它需要的最少打印次数。
+Leetcode题目：https://leetcode.com/problems/strange-printer/
+
+整型数组arr长度为n(3 <= n <= 10^4)，最初每个数字是<=200的正数且满足如下条件：
+1. 0位置的要求：arr[0]<=arr[1] 
+2. n-1位置的要求：arr[n-1]<=arr[n-2]
+3. 中间i位置的要求：arr[i]<=max(arr[i-1],arr[i+1]) 
+但是在arr有些数字丢失了，比如k位置的数字之前是正数，丢失之后k位置的数字为0
+请你根据上述条件，计算可能有多少种不同的arr可以满足以上条件
+比如 [6,0,9] 只有还原成 [6,9,9]满足全部三个条件，所以返回1，即[6,9,9]达标
+
+Dinic算法详解
+测试链接：https://lightoj.com/problem/internet-bandwidth
+
+
diff --git "a/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\346\226\260\346\211\213\347\217\255" "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\346\226\260\346\211\213\347\217\255"
new file mode 100644
index 0000000..19eb874
--- /dev/null
+++ "b/\350\257\276\345\240\202\345\206\205\345\256\271\346\261\207\346\200\273/\347\256\227\346\263\225\345\222\214\346\225\260\346\215\256\347\273\223\346\236\204\346\226\260\346\211\213\347\217\255"
@@ -0,0 +1,225 @@
+算法和数据结构新手班
+
+01 位运算、算法是什么、介绍位运算和简单排序
+
+内容：
+
+讲解二进制、位运算
+
+介绍什么是算法
+
+讲解冒泡、选择、插入排序
+
+题目：
+
+实现打印一个整数的二进制
+
+给定一个参数N，返回1!+2!+3!+4!+…+N!的结果
+
+实现冒泡排序
+
+实现选择排序
+
+实现插入排序
+
+
+
+02 数据结构的大分类、介绍前缀和与对数器
+
+内容：
+
+什么是数据结构、组成各种数据结构最基本的元件
+
+前缀和数组
+
+随机函数
+
+对数器的使用
+
+题目：
+
+实现前缀和数组
+
+如何用1~5的随机函数加工出1~7的随机函数
+
+如何用a~b的随机函数加工出c~d的随机函数
+
+展示对数器的使用
+
+如何把不等概率随机函数变成等概率随机函数
+
+
+
+03 介绍二分法，介绍时间复杂度、动态数组、哈希表和有序表
+
+内容：
+
+二分法
+
+使用二分法解决不同的题目
+
+时间复杂度
+
+动态数组
+
+按值传递、按引用传递
+
+哈希表
+
+有序表
+
+题目：
+
+有序数组中找到num
+
+有序数组中找到>=num最左的位置
+
+有序数组中找到<=num最右的位置
+
+局部最小值问题
+
+哈希表使用的code讲解
+
+有序表使用的code讲解
+
+
+
+04 链表相关的简单面试题
+
+内容：
+
+单双链表的定义
+
+栈、队列
+
+双端队列
+
+题目：
+
+反转单链表
+
+反转双链表
+
+用单链表实现队列
+
+用单链表实现栈
+
+用双链表实现双端队列
+
+K个节点的组内逆序调整问题：
+给定一个单链表的头节点head，和一个正数k
+实现k个节点的小组内部逆序，如果最后一组不够k个就不调整
+例子: 
+调整前：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8，k = 3
+调整后：3 -> 2 -> 1 -> 6 -> 5 -> 4 -> 7 -> 8
+
+两个链表相加问题
+给定两个链表的头节点head1和head2，
+认为从左到右是某个数字从低位到高位，返回相加之后的链表
+例子     4 -> 3 -> 6        2 -> 5 -> 3
+返回     6 -> 8 -> 9
+解释     634 + 352 = 986
+
+两个有序链表的合并
+给定两个有序链表的头节点head1和head2，
+返回合并之后的大链表，要求依然有序
+例子     1 -> 3 -> 3 -> 5 -> 7   2 -> 2 -> 3 -> 3-> 7
+返回     1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 3 -> 5 -> 7
+
+
+
+05 位图、位运算实现加减乘除
+
+内容：
+
+位图
+
+位运算使用的进一步学习：实现加减乘除
+
+题目：
+
+现场写位图的code、讲解
+
+位运算的加减乘除
+
+
+
+06 比较器、优先级队列、二叉树
+
+内容：
+
+比较器
+
+优先级队列
+
+二叉树的基本遍历
+
+二叉树的递归套路
+
+题目：
+
+补充了一个链表的题目
+合并多个有序链表
+Leetcode原题，https://leetcode.com/problems/merge-k-sorted-lists
+
+判断两颗树是否结构相同
+Leetcode原题，https://leetcode.com/problems/same-tree
+
+判断一棵树是否是镜面树
+Leetcode原题，https://leetcode.com/problems/symmetric-tree
+
+返回一棵树的最大深度
+Leetcode原题，https://leetcode.com/problems/maximum-depth-of-binary-tree
+
+用先序数组和中序数组重建一棵树
+Leetcode原题，https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
+
+用code展示比较器的使用
+
+二叉树先序、中序、后序遍历的代码实现、介绍递归序
+
+
+
+07 继续二叉树的很多题目
+
+内容：
+
+进一步讲解二叉树题目，来熟悉二叉树
+
+题目：
+
+二叉树按层遍历并收集节点
+Leetcode原题，https://leetcode.com/problems/binary-tree-level-order-traversal-ii
+
+判断是否是平衡搜索二叉树
+Leetcode原题，https://leetcode.com/problems/balanced-binary-tree
+
+在二叉树上能否组成路径和
+Leetcode原题，https://leetcode.com/problems/path-sum
+
+在二叉树上收集所有达标的路径和
+Leetcode原题，https://leetcode.com/problems/path-sum-ii
+
+判断二叉树是否是搜索二叉树
+
+
+
+08 介绍归并排序和快速排序
+
+内容：
+
+讲解一个位运算的题目
+
+归并排序
+
+快速排序
+
+题目：
+
+不要用任何比较判断，返回两个数中较大的数
+
+归并排序的递归实现和非递归实现
+
+快速排序的递归实现和非递归实现
+
+
diff --git "a/\350\257\276\345\240\202\347\254\224\350\256\260/\347\256\227\346\263\225\350\257\276\347\254\224\350\256\260" "b/\350\257\276\345\240\202\347\254\224\350\256\260/\347\256\227\346\263\225\350\257\276\347\254\224\350\256\260"
deleted file mode 100644
index 4c439c8..0000000
--- "a/\350\257\276\345\240\202\347\254\224\350\256\260/\347\256\227\346\263\225\350\257\276\347\254\224\350\256\260"
+++ /dev/null
@@ -1,2647 +0,0 @@
-算法和数据结构新手班
-
-01 位运算、算法是什么、介绍位运算和简单排序
-
-内容：
-
-讲解二进制、位运算
-
-介绍什么是算法
-
-讲解冒泡、选择、插入排序
-
-题目：
-
-实现打印一个整数的二进制
-
-给定一个参数N，返回1!+2!+3!+4!+…+N!的结果
-
-实现冒泡排序
-
-实现选择排序
-
-实现插入排序
-
-
-
-02 数据结构的大分类、介绍前缀和与对数器
-
-内容：
-
-什么是数据结构、组成各种数据结构最基本的元件
-
-前缀和数组
-
-随机函数
-
-对数器的使用
-
-题目：
-
-实现前缀和数组
-
-如何用1~5的随机函数加工出1~7的随机函数
-
-如何用a~b的随机函数加工出c~d的随机函数
-
-展示对数器的使用
-
-如何把不等概率随机函数变成等概率随机函数
-
-
-
-03 介绍二分法，介绍时间复杂度、动态数组、哈希表和有序表
-
-内容：
-
-二分法
-
-使用二分法解决不同的题目
-
-时间复杂度
-
-动态数组
-
-按值传递、按引用传递
-
-哈希表
-
-有序表
-
-题目：
-
-有序数组中找到num
-
-有序数组中找到>=num最左的位置
-
-有序数组中找到<=num最右的位置
-
-局部最小值问题
-
-哈希表使用的code讲解
-
-有序表使用的code讲解
-
-
-
-04 链表相关的简单面试题
-
-内容：
-
-单双链表的定义
-
-栈、队列
-
-双端队列
-
-题目：
-
-反转单链表
-
-反转双链表
-
-用单链表实现队列
-
-用单链表实现栈
-
-用双链表实现双端队列
-
-K个节点的组内逆序调整问题：
-给定一个单链表的头节点head，和一个正数k
-实现k个节点的小组内部逆序，如果最后一组不够k个就不调整
-例子: 
-调整前：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8，k = 3
-调整后：3 -> 2 -> 1 -> 6 -> 5 -> 4 -> 7 -> 8
-
-两个链表相加问题
-给定两个链表的头节点head1和head2，
-认为从左到右是某个数字从低位到高位，返回相加之后的链表
-例子     4 -> 3 -> 6        2 -> 5 -> 3
-返回     6 -> 8 -> 9
-解释     634 + 352 = 986
-
-两个有序链表的合并
-给定两个有序链表的头节点head1和head2，
-返回合并之后的大链表，要求依然有序
-例子     1 -> 3 -> 3 -> 5 -> 7   2 -> 2 -> 3 -> 3-> 7
-返回     1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 3 -> 5 -> 7
-
-
-
-05 位图、位运算实现加减乘除
-
-内容：
-
-位图
-
-位运算使用的进一步学习：实现加减乘除
-
-题目：
-
-现场写位图的code、讲解
-
-位运算的加减乘除
-
-
-
-06 比较器、优先级队列、二叉树
-
-内容：
-
-比较器
-
-优先级队列
-
-二叉树的基本遍历
-
-二叉树的递归套路
-
-题目：
-
-补充了一个链表的题目
-合并多个有序链表
-Leetcode原题，https://leetcode.com/problems/merge-k-sorted-lists
-
-判断两颗树是否结构相同
-Leetcode原题，https://leetcode.com/problems/same-tree
-
-判断一棵树是否是镜面树
-Leetcode原题，https://leetcode.com/problems/symmetric-tree
-
-返回一棵树的最大深度
-Leetcode原题，https://leetcode.com/problems/maximum-depth-of-binary-tree
-
-用先序数组和中序数组重建一棵树
-Leetcode原题，https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
-
-用code展示比较器的使用
-
-二叉树先序、中序、后序遍历的代码实现、介绍递归序
-
-
-
-07 继续二叉树的很多题目
-
-内容：
-
-进一步讲解二叉树题目，来熟悉二叉树
-
-题目：
-
-二叉树按层遍历并收集节点
-Leetcode原题，https://leetcode.com/problems/binary-tree-level-order-traversal-ii
-
-判断是否是平衡搜索二叉树
-Leetcode原题，https://leetcode.com/problems/balanced-binary-tree
-
-在二叉树上能否组成路径和
-Leetcode原题，https://leetcode.com/problems/path-sum
-
-在二叉树上收集所有达标的路径和
-Leetcode原题，https://leetcode.com/problems/path-sum-ii
-
-判断二叉树是否是搜索二叉树
-
-
-
-08 介绍归并排序和快速排序
-
-内容：
-
-讲解一个位运算的题目
-
-归并排序
-
-快速排序
-
-题目：
-
-不要用任何比较判断，返回两个数中较大的数
-
-归并排序的递归实现和非递归实现
-
-快速排序的递归实现和非递归实现
-
-
-
-======================================================================================================================================
-
-
-
-算法和数据结构体系学习班
-
-00 算法和数据结构学前必看
-
-内容：
-
-算法和数据结构课程体系介绍
-
-算法和数据结构学习路线
-
-算法和数据结构学习方式推荐
-
-算法和数据结构面试软技巧
-
-同学们的各种答疑问题
-
-
-
-01 时间复杂度、空间复杂度、对数器和二分法
-
-内容：
-
-评估算法优劣的核心指标
-
-时间复杂度、空间复杂度、估算方式、意义
-
-常数时间的操作
-
-选择排序、冒泡排序、插入排序
-
-最优解
-
-对数器
-
-二分法
-
-题目：
-
-选择排序及其对数器验证
-
-冒泡排序及其对数器验证
-
-插入排序及其对数器验证
-
-有序数组中找到num
-
-有序数组中找到>=num最左的位置
-
-有序数组中找到<=num最右的位置
-
-局部最小值问题
-定义何为局部最小值：
-arr[0] < arr[1]，0位置是局部最小；
-arr[N-1] < arr[N-2]，N-1位置是局部最小；
-arr[i-1] > arr[i] < arr[i+1]，i位置是局部最小；
-给定一个数组arr，已知任何两个相邻的数都不相等，找到随便一个局部最小位置返回
-
-
-
-02 异或运算、进一步认识对数器的重要性
-
-内容：
-
-异或运算的性质
-
-异或运算的题目
-
-题目：
-
-不用额外变量交换两个数的值
-
-不用额外变量交换数组中两个数的值
-
-一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这种数 
-
-怎么把一个int类型的数，提取出二进制中最右侧的1来
-
-一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数 
-
-一个数组中有一种数出现K次，其他数都出现了M次，
-已知M > 1，K < M，找到出现了K次的数
-要求额外空间复杂度O(1)，时间复杂度O(N)
-
-
-
-03 单双链表、栈和队列、递归和Master公式、哈希表和有序表的使用和性能
-
-内容：
-
-单链表、双链表
-
-栈、队列
-
-递归的物理实质
-
-评估递归复杂度的Master公式
-
-哈希表的使用和性能
-
-有序表的使用和性能
-
-题目：
-
-反转单链表、反转双链表
-
-在链表中删除指定值的所有节点
-
-用双链表实现栈和队列
-
-用环形数组实现栈和队列
-
-实现有getMin功能的栈
-
-两个栈实现队列
-
-两个队列实现栈
-
-用递归行为得到数组中的最大值，并用master公式来估计时间复杂度
-
-哈希表和有序表使用的code展示
-
-
-
-04 归并排序及其常见面试题
-
-内容：
-
-归并排序
-
-题目：
-
-归并排序的递归和非递归实现
-
-在一个数组中，一个数左边比它小的数的总和，叫该数的小和
-所有数的小和累加起来，叫数组小和
-例子： [1,3,4,2,5] 
-1左边比1小的数：没有
-3左边比3小的数：1
-4左边比4小的数：1、3
-2左边比2小的数：1
-5左边比5小的数：1、3、4、 2
-所以数组的小和为1+1+3+1+1+3+4+2=16 
-给定一个数组arr，求数组小和
-
-在一个数组中，任何一个前面的数a，和任何一个后面的数b，如果(a,b)是降序的，就称为降序对
-给定一个数组arr，求数组的降序对总数量
-
-在一个数组中，对于任何一个数num，求有多少个(后面的数*2)依然<num，返回总个数
-比如：[3,1,7,0,2]
-3的后面有：1，0
-1的后面有：0
-7的后面有：0，2
-0的后面没有
-2的后面没有
-所以总共有5个
-
-
-
-05 归并排序面试题(续)、快速排序
-
-内容：
-
-再来一个归并排序面试题
-
-荷兰国旗问题
-
-快速排序1.0
-
-快速排序2.0
-
-快速排序3.0
-
-题目：
-
-给定一个数组arr，两个整数lower和upper，
-返回arr中有多少个子数组的累加和在[lower,upper]范围上
-Leetcode题目：https://leetcode.com/problems/count-of-range-sum/
-
-荷兰国旗问题的实现
-
-快速排序从1.0到3.0的实现
-
-快速排序的递归实现和非递归实现
-
-code附加，双向链表进行快速排序的code实现
-
-
-
-06 比较器、堆结构、堆排序
-
-内容：
-
-比较器
-
-堆结构
-
-堆排序
-
-建立大根堆的两种方式，从上到下、从下到上，及其复杂度分析
-
-题目：
-
-比较器使用的code展示
-
-堆结构的实现
-
-堆排序的实现
-
-已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k
-k相对于数组长度来说是比较小的。请选择一个合适的排序策略，对这个数组进行排序。 
-
-
-
-07 和堆有关的面试题、加强堆结构
-
-内容：
-
-线段最大重合问题
-
-加强堆的实现
-
-题目：
-
-给定很多线段，每个线段都有两个数[start, end]，
-表示线段开始位置和结束位置，左右都是闭区间
-规定：
-1）线段的开始和结束位置一定都是整数值
-2）线段重合区域的长度必须>=1
-返回线段最多重合区域中，包含了几条线段
-
-加强堆的实现、注意点解析
-
-做一个加强堆的题目，给定一个整型数组，int[] arr；和一个布尔类型数组，boolean[] op
-两个数组一定等长，假设长度为N，arr[i]表示客户编号，op[i]表示客户操作
-arr= [3,3,1,2,1,2,5…
-op = [T,T,T,T,F,T,F…
-依次表示：
-3用户购买了一件商品
-3用户购买了一件商品
-1用户购买了一件商品
-2用户购买了一件商品
-1用户退货了一件商品
-2用户购买了一件商品
-5用户退货了一件商品…
-一对arr[i]和op[i]就代表一个事件：
-用户号为arr[i]，op[i] == T就代表这个用户购买了一件商品
-op[i] == F就代表这个用户退货了一件商品
-现在你作为电商平台负责人，你想在每一个事件到来的时候，
-都给购买次数最多的前K名用户颁奖。
-所以每个事件发生后，你都需要一个得奖名单（得奖区）。
-得奖系统的规则：
-1，如果某个用户购买商品数为0，但是又发生了退货事件，
-     则认为该事件无效，得奖名单和上一个事件发生后一致，例子中的5用户
-2，某用户发生购买商品事件，购买商品数+1，发生退货事件，购买商品数-1
-3，每次都是最多K个用户得奖，K也为传入的参数
-      如果根据全部规则，得奖人数确实不够K个，那就以不够的情况输出结果
-4，得奖系统分为得奖区和候选区，任何用户只要购买数>0，
-      一定在这两个区域中的一个
-5，购买数最大的前K名用户进入得奖区，
-      在最初时如果得奖区没有到达K个用户，那么新来的用户直接进入得奖区
-6，如果购买数不足以进入得奖区的用户，进入候选区
-7，如果候选区购买数最多的用户，已经足以进入得奖区，
-     该用户就会替换得奖区中购买数最少的用户（大于才能替换），
-     如果得奖区中购买数最少的用户有多个，就替换最早进入得奖区的用户
-     如果候选区中购买数最多的用户有多个，机会会给最早进入候选区的用户
-8，候选区和得奖区是两套时间，
-     因用户只会在其中一个区域，所以只会有一个区域的时间，另一个没有
-     从得奖区出来进入候选区的用户，得奖区时间删除，
-     进入候选区的时间就是当前事件的时间（可以理解为arr[i]和op[i]中的i）
-     从候选区出来进入得奖区的用户，候选区时间删除，
-     进入得奖区的时间就是当前事件的时间（可以理解为arr[i]和op[i]中的i）
-9，如果某用户购买数==0，不管在哪个区域都离开，区域时间删除，
-     离开是指彻底离开，哪个区域也不会找到该用户
-     如果下次该用户又发生购买行为，产生>0的购买数，
-     会再次根据之前规则回到某个区域中，进入区域的时间重记
-请遍历arr数组和op数组，遍历每一步输出一个得奖名单
-public List<List<Integer>>  topK (int[] arr, boolean[] op, int k)
-
-
-
-08 前缀树、不基于比较的排序（计数排序、基数排序）、排序算法的稳定性
-
-内容：
-
-前缀树
-
-计数排序
-
-基数排序
-
-排序算法的稳定性
-
-题目：
-
-前缀树实现
-
-计数排序
-
-基数排序
-
-
-
-09 排序算法大总结、链表及其相关面试题
-
-内容：
-
-排序算法总结
-
-排序算法常见的坑
-
-工程上对排序的常见改进
-
-链表面试题的常见技巧
-
-题目：
-
-输入链表头节点，奇数长度返回中点，偶数长度返回上中点
-输入链表头节点，奇数长度返回中点，偶数长度返回下中点
-输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个
-输入链表头节点，奇数长度返回中点前一个，偶数长度返回下中点前一个
-
-给定一个单链表的头节点head，请判断该链表是否为回文结构
-
-给定一个单链表的头节点head，给定一个整数n，将链表按n划分成左边<n、中间==n、右边>n
-
-一种特殊的单链表节点类描述如下 
-class Node {
-int value; 
-Node next; 
-Node rand; 
-Node(int val) { value = val; } 
-} 
-rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null
-给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表的复制
-返回复制的新链表的头节点，要求时间复杂度O(N)，额外空间复杂度O(1) 
-
-
-
-10 链表相关面试题（续）、二叉树的常见遍历
-
-内容：
-
-单链表的相交节点系列问题
-
-一种看似高效其实搞笑的节点删除方式
-
-二叉树的中序、先序、后序遍历
-
-题目：
-
-给定两个可能有环也可能无环的单链表，头节点head1和head2
-请实现一个函数，如果两个链表相交，请返回相交的第一个节点。如果不相交返回null 
-要求如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)
-
-能不能不给单链表的头节点，只给想要删除的节点，就能做到在链表上把这个点删掉？
-
-二叉树先序、中序、后序的递归遍历和递归序
-
-二叉树先序、中序、后序的非递归遍历
-
-
-
-11 二叉树常见面试题和二叉树的递归套路（上）
-
-内容：
-
-通过题目来熟悉二叉树的解题技巧
-
-题目：
-
-二叉树的按层遍历
-
-二叉树的序列化和反序列化
-
-N叉树如何通过二叉树来序列化、并完成反序列化
-Leetcode题目：https://leetcode.com/problems/encode-n-ary-tree-to-binary-tree/
-
-打印二叉树的函数设计
-
-求二叉树的最大宽度
-
-求二叉树某个节点的后继节点
-二叉树结构如下定义：
-Class Node {
-	V value;
-	Node left;
-	Node right;
-	Node parent;
-}
-给你二叉树中的某个节点，返回该节点的后继节点 
-
-折纸问题
-请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后展开
-此时折痕是凹下去的，即折痕突起的方向指向纸条的背面
-如果从纸条的下边向上方连续对折2次，压出折痕后展开
-此时有三条折痕，从上到下依次是下折痕、下折痕和上折痕。 
-给定一个输入参数N，代表纸条都从下边向上方连续对折N次
-请从上到下打印所有折痕的方向。 
-N=1时，打印: down 
-N=2时，打印: down down up 
-
-
-
-12 二叉树常见面试题和二叉树的递归套路（中）
-
-内容：
-
-通过题目来熟悉二叉树的解题技巧
-
-介绍二叉树的递归套路
-1）假设以X节点为头，假设可以向X左树和X右树要任何信息
-2）在上一步的假设下，讨论以X为头节点的树，得到答案的可能性（最重要）
-3）列出所有可能性后，确定到底需要向左树和右树要什么样的信息
-4）把左树信息和右树信息求全集，就是任何一棵子树都需要返回的信息S
-5）递归函数都返回S，每一棵子树都这么要求
-6）写代码，在代码中考虑如何把左树的信息和右树信息整合出整棵树的信息
-
-题目：
-
-判断二叉树是不是搜索二叉树
-
-判断二叉树是不是平衡二叉树
-
-判断二叉树是不是满二叉树
-
-给定一棵二叉树的头节点head，返回这颗二叉树中最大的二叉搜索子树的大小
-
-给定一棵二叉树的头节点head，任何两个节点之间都存在距离，返回整棵二叉树的最大距离
-
-
-
-13 二叉树常见面试题和二叉树的递归套路（下）、贪心算法
-
-内容：
-
-二叉树递归套路继续实践
-
-一道贪心算法从头到尾的完整做法
-
-解决贪心题目的重要技巧，即对数器来验证脑洞
-
-再次强调对数器的重要性
-
-题目：
-
-判断二叉树是不是完全二叉树（一般方法解决、递归套路解决）
-
-给定一棵二叉树的头节点head，返回这颗二叉树中最大的二叉搜索子树的头节点
-
-给定一棵二叉树的头节点head，和另外两个节点a和b，返回a和b的最低公共祖先
-
-派对的最大快乐值
- 员工信息的定义如下:
-class Employee {
-    public int happy; // 这名员工可以带来的快乐值
-    List<Employee> subordinates; // 这名员工有哪些直接下级
-}
-公司的每个员工都符合 Employee 类的描述。整个公司的人员结构可以看作是一棵标准的、 没有环的多叉树
-树的头节点是公司唯一的老板，除老板之外的每个员工都有唯一的直接上级
-叶节点是没有任何下属的基层员工(subordinates列表为空)，除基层员工外每个员工都有一个或多个直接下级
-这个公司现在要办party，你可以决定哪些员工来，哪些员工不来，规则：
-1.如果某个员工来了，那么这个员工的所有直接下级都不能来
-2.派对的整体快乐值是所有到场员工快乐值的累加
-3.你的目标是让派对的整体快乐值尽量大
-给定一棵多叉树的头节点boss，请返回派对的最大快乐值。
-
-给定一个由字符串组成的数组strs，必须把所有的字符串拼接起来，返回所有可能的拼接结果中字典序最小的结果
-
-
-
-14 贪心算法（续）、并查集
-
-内容：
-
-贪心算法继续实战
-
-并查集详解
-
-题目：
-
-给定一个字符串str，只由'X'和'.'两种字符构成
-'X'表示墙，不能放灯，也不需要点亮；'.'表示居民点，可以放灯，需要点亮
-如果灯放在i位置，可以让i-1，i和i+1三个位置被点亮
-返回如果点亮str中所有需要点亮的位置，至少需要几盏灯
-
-一块金条切成两半，是需要花费和长度数值一样的铜板
-比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板? 
-例如，给定数组{10,20,30}，代表一共三个人，整块金条长度为60，金条要分成10，20，30三个部分。
-如果先把长度60的金条分成10和50，花费60；再把长度50的金条分成20和30，花费50；一共花费110铜板
-但如果先把长度60的金条分成30和30，花费60；再把长度30金条分成10和20，花费30；一共花费90铜板
-输入一个数组，返回分割的最小代价
-
-一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲，给你每一个项目开始的时间和结束的时间
-你来安排宣讲的日程，要求会议室进行的宣讲的场次最多，返回最多的宣讲场次
-
-输入正数数组costs、正数数组profits、正数K和正数M
-costs[i]表示i号项目的花费
-profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润)
-K表示你只能串行的最多做k个项目
-M表示你初始的资金
-说明：每做完一个项目，马上获得的收益，可以支持你去做下一个项目，不能并行的做项目。
-输出：最后获得的最大钱数
-
-并查集的实现
-
-
-
-15 并查集相关的常见面试题
-
-内容：
-
-通过解答实际出现的面试题来体会并查集的优势、熟悉并查集的使用
-
-题目：
-
-一群朋友中，有几个不相交的朋友圈
-Leetcode题目：https://leetcode.com/problems/friend-circles/
-
-岛问题（递归解法 + 并查集解法 + 并行解法）
-给定一个二维数组matrix，里面的值不是1就是0，上、下、左、右相邻的1认为是一片岛，返回matrix中岛的数量
-
-
-
-16 图及其与图相关的算法
-
-内容：
-
-图的表达方式
-
-图的常见描述
-
-图的宽度优先遍历
-
-图的深度优先遍历
-
-图的拓扑排序
-
-最小生成树算法Kruskal
-
-最小生成树算法Prim
-
-单元最短路径算法Dijkstra
-
-题目：
-
-图的数据结构抽象
-
-实现图的宽度优先遍历
-
-实现图的深度优先遍历
-
-三种方式实现图的拓扑排序
-
-用并查集实现Kruskal算法
-
-用堆实现Prim算法
-
-实现Dijkstra算法，用加强堆做更好的实现（16节+17节一开始）
-
-
-
-17 用加强堆更好的实现Dijkstra算法、常见的递归
-
-内容：
-
-加强堆实现Dijkstra算法
-
-递归的设计
-
-常见的递归
-
-题目：
-
-打印n层汉诺塔从最左边移动到最右边的全部过程（递归+非递归实现）
-
-打印一个字符串的全部子序列
-
-打印一个字符串的全部子序列，要求不要出现重复字面值的子序列
-
-打印一个字符串的全部排列
-
-打印一个字符串的全部排列，要求不要出现重复的排列
-
-给定一个栈，请逆序这个栈，不能申请额外的数据结构，只能使用递归函数
-
-
-
-18 暴力递归到动态规划（一）
-
-内容：
-
-讲述暴力递归和动态规划的关系
-
-记忆化搜索
-
-动态规划都可以由暴力递归改进过来，解决动态规划的套路
-
-常见的尝试模型
-
-设计尝试过程的原则
-
-本节是暴力递归到动态规划的总纲（很重要）
-
-后续的课都是在讲述这一系列的套路
-
-题目：
-
-假设有排成一行的N个位置记为1~N，N一定大于或等于2
-开始时机器人在其中的M位置上(M一定是1~N中的一个)
-如果机器人来到1位置，那么下一步只能往右来到2位置；
-如果机器人来到N位置，那么下一步只能往左来到N-1位置；
-如果机器人来到中间位置，那么下一步可以往左走或者往右走；
-规定机器人必须走K步，最终能来到P位置(P也是1~N中的一个)的方法有多少种
-给定四个参数 N、M、K、P，返回方法数
-
-给定一个整型数组arr，代表数值不同的纸牌排成一条线
-玩家A和玩家B依次拿走每张纸牌
-规定玩家A先拿，玩家B后拿
-但是每个玩家每次只能拿走最左或最右的纸牌
-玩家A和玩家B都绝顶聪明
-请返回最后获胜者的分数
-
-
-
-19 暴力递归到动态规划（二）
-
-内容：
-
-以18节为总纲
-
-背包问题
-
-记忆化搜索的一个很重要的注意点
-
-通过面试题进一步强化动态规划的解题套路
-
-题目：
-
-背包问题
-给定两个长度都为N的数组weights和values，weights[i]和values[i]分别代表 i号物品的重量和价值
-给定一个正数bag，表示一个载重bag的袋子，装的物品不能超过这个重量
-返回能装下的最大价值
-
-规定1和A对应、2和B对应、3和C对应...26和Z对应
-那么一个数字字符串比如"111”就可以转化为:
-"AAA"、"KA"和"AK"
-给定一个只有数字字符组成的字符串str，返回有多少种转化结果 
-
-给定一个字符串str，给定一个字符串类型的数组arr，出现的字符都是小写英文
-arr每一个字符串，代表一张贴纸，你可以把单个字符剪开使用，目的是拼出str来
-返回需要至少多少张贴纸可以完成这个任务
-例子：str= "babac"，arr = {"ba","c","abcd"}
-ba + ba + c  3  abcd + abcd 2  abcd+ba 2
-所以返回2
-
-给定两个字符串str1和str2，
-返回这两个字符串的最长公共子序列长度
-比如 ： str1 = “a12b3c456d”,str2 = “1ef23ghi4j56k”
-最长公共子序列是“123456”，所以返回长度6
-
-
-
-20 暴力递归到动态规划（三）
-
-内容：
-
-以18节为总纲
-
-通过面试题进一步强化动态规划的解题套路
-
-题目：
-
-给定一个字符串str，返回这个字符串的最长回文子序列长度
-比如 ： str = “a12b3c43def2ghi1kpm”
-最长回文子序列是“1234321”或者“123c321”，返回长度7
-
-请同学们自行搜索或者想象一个象棋的棋盘，
-然后把整个棋盘放入第一象限，棋盘的最左下角是(0,0)位置
-那么整个棋盘就是横坐标上9条线、纵坐标上10条线的区域
-给你三个 参数 x，y，k
-返回“马”从(0,0)位置出发，必须走k步
-最后落在(x,y)上的方法数有多少种? 
-
-给定一个数组arr，arr[i]代表第i号咖啡机泡一杯咖啡的时间
-给定一个正数N，表示N个人等着咖啡机泡咖啡，每台咖啡机只能轮流泡咖啡
-只有一台咖啡机，一次只能洗一个杯子，时间耗费a，洗完才能洗下一杯
-每个咖啡杯也可以自己挥发干净，时间耗费b，咖啡杯可以并行挥发
-假设所有人拿到咖啡之后立刻喝干净，
-返回从开始等到所有咖啡机变干净的最短时间
-三个参数：int[] arr、int N，int a、int b
-
-
-
-21 暴力递归到动态规划（四）
-
-内容：
-
-以18节为总纲
-
-通过面试题进一步强化动态规划的解题套路
-
-题目：
-
-给定一个二维数组matrix，一个人必须从左上角出发，最后到达右下角
-沿途只可以向下或者向右走，沿途的数字都累加就是距离累加和
-返回最小距离累加和
-
-arr是货币数组，其中的值都是正数。再给定一个正数aim。
-每个值都认为是一张货币，
-即便是值相同的货币也认为每一张都是不同的，
-返回组成aim的方法数
-例如：arr = {1,1,1}，aim = 2
-第0个和第1个能组成2，第1个和第2个能组成2，第0个和第2个能组成2
-一共就3种方法，所以返回3
-
-arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。
-每个值都认为是一种面值，且认为张数是无限的。
-返回组成aim的方法数
-例如：arr = {1,2}，aim = 4
-方法如下：1+1+1+1、1+1+2、2+2
-一共就3种方法，所以返回3
-
-arr是货币数组，其中的值都是正数。再给定一个正数aim。
-每个值都认为是一张货币，
-认为值相同的货币没有任何不同，
-返回组成aim的方法数
-例如：arr = {1,2,1,1,2,1,2}，aim = 4
-方法：1+1+1+1、1+1+2、2+2
-一共就3种方法，所以返回3
-
-给定5个参数，N，M，row，col，k
-表示在N*M的区域上，醉汉Bob初始在(row,col)位置
-Bob一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位
-任何时候Bob只要离开N*M的区域，就直接死亡
-返回k步之后，Bob还在N*M的区域的概率
-
-
-
-22 暴力递归到动态规划（五）
-
-内容：
-
-以18节为总纲
-
-通过面试题进一步强化动态规划的解题套路
-
-斜率优化技巧
-
-题目：
-
-给定3个参数，N，M，K
-怪兽有N滴血，等着英雄来砍自己
-英雄每一次打击，都会让怪兽流失[0~M]的血量
-到底流失多少？每一次在[0~M]上等概率的获得一个值
-求K次打击之后，英雄把怪兽砍死的概率
-
-arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。
-每个值都认为是一种面值，且认为张数是无限的。
-返回组成aim的最少货币数
-
-给定一个正数n，求n的裂开方法数，
-规定：后面的数不能比前面的数小
-比如4的裂开方法有：
-1+1+1+1、1+1+2、1+3、2+2、4
-5种，所以返回5
-
-
-
-23 暴力递归到动态规划（六）
-
-内容：
-
-以18节为总纲
-
-通过面试题进一步强化动态规划的解题套路
-
-位信息技巧
-
-题目：
-
-给定一个正数数组arr，
-请把arr中所有的数分成两个集合，尽量让两个集合的累加和接近
-返回最接近的情况下，较小集合的累加和
-
-给定一个正数数组arr，请把arr中所有的数分成两个集合
-如果arr长度为偶数，两个集合包含数的个数要一样多
-如果arr长度为奇数，两个集合包含数的个数必须只差一个
-请尽量让两个集合的累加和接近
-返回最接近的情况下，较小集合的累加和
-
-N皇后问题是指在N*N的棋盘上要摆N个皇后，
-要求任何两个皇后不同行、不同列， 也不在同一条斜线上
-给定一个整数n，返回n皇后的摆法有多少种。n=1，返回1
-n=2或3，2皇后和3皇后问题无论怎么摆都不行，返回0
-n=8，返回92
-
-
-
-24 窗口内最大值或最小值的更新结构
-
-内容：
-
-滑动窗口
-
-窗口内最大值或最小值的更新结构
-
-用题目来学习窗口内最大值或最小值的更新结构提供的便利性
-
-题目：
-
-窗口内最大值或最小值更新结构的实现
-假设一个固定大小为W的窗口，依次划过arr，
-返回每一次滑出状况的最大值
-例如，arr = [4,3,5,4,3,3,6,7], W = 3
-返回：[5,5,5,4,6,7]
-
-给定一个整型数组arr，和一个整数num
-某个arr中的子数组sub，如果想达标，必须满足：sub中最大值 – sub中最小值 <= num，
-返回arr中达标子数组的数量
-
-加油站的良好出发点问题
-
-动态规划中利用窗口内最大值或最小值更新结构做优化（难）
-arr是货币数组，其中的值都是正数。再给定一个正数aim。
-每个值都认为是一张货币，
-返回组成aim的最少货币数
-注意：因为是求最少货币数，所以每一张货币认为是相同或者不同就不重要了
-
-
-
-25 单调栈
-
-内容：
-
-单调栈的原理（无重复数+有重复数）
-
-用题目来学习单调栈提供的便利性
-
-题目：
-
-单调栈实现（无重复数+有重复数）
-
-给定一个只包含正数的数组arr，arr中任何一个子数组sub，
-一定都可以算出(sub累加和 )* (sub中的最小值)是什么，
-那么所有子数组中，这个值最大是多少？
-
-给定一个非负数组arr，代表直方图，返回直方图的最大长方形面积
-
-给定一个二维数组matrix，其中的值不是0就是1，返回全部由1组成的最大子矩形内部有多少个1（面积）
-
-给定一个二维数组matrix，其中的值不是0就是1，返回全部由1组成的子矩形数量
-
-
-
-26 单调栈相关的题目（续）、斐波那契数列的矩阵快速幂模型
-
-内容：
-
-再讲一个单调栈相关的面试题
-
-斐波那契数列的矩阵快速幂模型详解
-
-题目：
-
-给定一个数组arr，返回所有子数组最小值的累加和
-
-斐波那契数列矩阵乘法方式的实现
-
-台阶方法数问题
-一个人可以一次往上迈1个台阶，也可以迈2个台阶，返回迈上N级台阶的方法数
-
-奶牛生小牛问题
-第一年农场有1只成熟的母牛A，往后的每年：
-1）每一只成熟的母牛都会生一只母牛
-2）每一只新出生的母牛都在出生的第三年成熟
-3）每一只母牛永远不会死
-返回N年后牛的数量
-
-给定一个数N，想象只由0和1两种字符，组成的所有长度为N的字符串
-如果某个字符串，任何0字符的左边都有1紧挨着，认为这个字符串达标
-返回有多少达标的字符串
-
-用1*2的瓷砖，把N*2的区域填满，返回铺瓷砖的方法数
-
-
-
-27 KMP算法
-
-内容：
-
-KMP算法
-
-和KMP算法相关的面试题
-
-题目：
-
-KMP算法实现
-
-给定两棵二叉树的头节点head1和head2，返回head1中是否有某个子树的结构和head2完全一样
-
-判断str1和str2是否互为旋转字符串
-
-
-
-28 Manacher算法
-
-内容：
-
-Manacher算法
-
-和Manacher算法相关的面试题
-
-题目：
-
-Manacher算法实现
-
-给定一个字符串str，只能在str的后面添加字符，想让str整体变成回文串，返回至少要添加几个字符
-
-
-
-29 在无序数组中找到第K小的数、蓄水池算法
-
-内容：
-
-时间复杂度O(N)可以解决在无序数组中找到第K小的数，这个经典的面试题
-
-改写快排的partition方法
-
-bfprt算法
-
-蓄水池算法
-
-题目：
-
-在无序数组中找到第K小的数（改写快排+bfprt）
-
-设计在无序数组中收集最大的前K个数字的算法（根据不同的三个时间复杂度，设计三个算法）
-给定一个无序数组arr中，长度为N，给定一个正数k，返回top k个最大的数
-不同时间复杂度三个方法：
-1）O(N*logN)
-2）O(N + K*logN)
-3）O(n + k*logk)
-
-蓄水池算法实现
-假设有一个源源吐出不同球的机器，
-只有装下10个球的袋子，每一个吐出的球，要么放入袋子，要么永远扔掉
-如何做到机器吐出每一个球之后，所有吐出的球都等概率被放进袋子里
-
-
-
-
-30 二叉树的Morris遍历
-
-内容：
-
-二叉树之前的遍历方式有空间浪费的问题
-
-Morris遍历时间复杂度O(N)，额外空间复杂度O(1)，通过利用原树中大量空闲指针的方式，达到节省空间的目的
-
-假设来到当前节点cur，开始时cur来到头节点位置
-1）如果cur没有左孩子，cur向右移动(cur = cur.right)
-2）如果cur有左孩子，找到左子树上最右的节点mostRight：
-	a.如果mostRight的右指针指向空，让其指向cur，
-	然后cur向左移动(cur = cur.left)
-	b.如果mostRight的右指针指向cur，让其指向null，
-	然后cur向右移动(cur = cur.right)
-3）cur为空时遍历停止
-
-Morris遍历实现二叉树的先序、中序、后序遍历
-
-题目：
-
-Morris遍历的实现
-
-给定一棵二叉树的头节点head，求以head为头的树中，最小深度是多少？
-
-
-
-31 线段树
-
-内容：
-
-线段树是一种支持范围整体修改和范围整体查询的数据结构
-
-线段树解决的问题范畴：大范围信息可以只由左、右两侧信息加工出，而不必遍历左右两个子范围的具体状况
-
-题目：
-
-给定一个数组arr，用户希望你实现如下三个方法
-1）void add(int L, int R, int V) :  让数组arr[L…R]上每个数都加上V
-2）void update(int L, int R, int V) :  让数组arr[L…R]上每个数都变成V
-3）int sum(int L, int R) :让返回arr[L…R]这个范围整体的累加和
-怎么让这三个方法，时间复杂度都是O(logN)
-
-想象一下标准的俄罗斯方块游戏，X轴是积木最终下落到底的轴线
-下面是这个游戏的简化版：
-1）只会下落正方形积木
-2）[a,b] -> 代表一个边长为b的正方形积木，积木左边缘沿着X = a这条线从上方掉落
-3）认为整个X轴都可能接住积木，也就是说简化版游戏是没有整体的左右边界的
-4）没有整体的左右边界，所以简化版游戏不会消除积木，因为不会有哪一层被填满。
-给定一个N*2的二维数组matrix，可以代表N个积木依次掉落，
-返回每一次掉落之后的最大高度
-Leetcode题目：https://leetcode.com/problems/falling-squares/
-
-
-
-32 IndexTree、AC自动机
-
-内容：
-
-IndexTree
-1）支持区间查询
-2）没有线段树那么强，但是非常容易改成一维、二维、三维的结构
-3）只支持单点更新
-
-AC自动机
-解决在一个大字符串中，找到多个候选字符串的问题
-1）把所有匹配串生成一棵前缀树
-2）前缀树节点增加fail指针
-3）fail指针的含义：如果必须以当前字符结尾，当前形成的路径是str，剩下哪一个字符串的前缀和str的后缀
-   拥有最大的匹配长度。fail指针就指向那个字符串的最后一个字符所对应的节点（迷不迷？听讲述！）
-
-题目：
-
-IndexTree在一维数组和二维数组上的实现
-
-AC自动机的实现
-
-
-
-33 与哈希函数有关的结构
-
-内容：
-
-哈希函数
-
-哈希函数的应用
-
-布隆过滤器
-
-一致性哈希
-
-题目：
-
-原理讲述为主，面试只会聊设计，所以本节无题目
-
-
-
-34 资源限制类题目的解题套路
-
-内容：
-
-布隆过滤器用于集合的建立与查询，并可以节省大量空间
-一致性哈希解决数据服务器的负载管理问题
-利用并查集结构做岛问题的并行计算
-哈希函数可以把数据按照种类均匀分流
-位图解决某一范围上数字的出现情况，并可以节省大量空间
-利用分段统计思想、并进一步节省大量空间
-利用堆、外排序来做多个处理单元的结果合并
-
-题目：
-
-32位无符号整数的范围是0~4,294,967,295，
-现在有一个正好包含40亿个无符号整数的文件，
-可以使用最多1GB的内存，怎么找到出现次数最多的数？
-
-32位无符号整数的范围是0~4,294,967,295，现在有一个正好包含40亿个无符号整数的文件，
-所以在整个范围中必然存在没出现过的数，可以使用最多1GB的内存，怎么找到所有未出现过的数？
-进阶：内存限制为 3KB，但是只用找到一个没出现过的数即可
-
-有一个包含100亿个URL的大文件，假设每个URL占用64B，请找出其中所有重复的URL
-补充：某搜索公司一天的用户搜索词汇是海量的(百亿数据量)，请设计一种求出每天热门Top100词汇的可行办法
-
-32位无符号整数的范围是0~4294967295，现在有40亿个无符号整数，可以使用最多1GB的内存，找出所有出现了两次的数
-
-32位无符号整数的范围是0~4294967295，现在有40亿个无符号整数，可以使用最多3K的内存，怎么找到这40亿个整数的中位数？
-
-32位无符号整数的范围是0~4294967295，有一个10G大小的文件，每一行都装着这种类型的数字，
-整个文件是无序的，给你5G的内存空间，请你输出一个10G大小的文件，就是原文件所有数字排序的结果
-
-
-
-35 有序表（上）
-
-内容：
-
-平衡搜索二叉树
-
-左旋
-
-右旋
-
-AVL树的节点违规4种类型（LL，LR，RL，RR）
-
-题目：
-
-AVL树的实现
-
-
-
-36 有序表（中）
-
-内容：
-
-size-balanced-tree详解
-
-skiplist详解
-
-聊聊红黑树
-
-题目：
-
-size-balanced-tree实现
-
-skiplist实现
-
-
-
-37 有序表（下）
-
-内容：
-
-讲解有序表相关的面试题
-
-讲解改写有序表的题目核心点
-
-题目：
-
-给定一个数组arr，和两个整数a和b（a<=b）。求arr中有多少个子数组，累加和在[a,b]这个范围上。返回达标的子数组数量
-
-有一个滑动窗口：
-1）L是滑动窗口最左位置、R是滑动窗口最右位置，一开始LR都在数组左侧
-2）任何一步都可能R往右动，表示某个数进了窗口
-3）任何一步都可能L往右动，表示某个数出了窗口
-想知道每一个窗口状态的中位数
-
-设计一个结构包含如下两个方法：
-void add(int index, int num)：把num加入到index位置
-int get(int index) ：取出index位置的值
-void remove(int index) ：把index位置上的值删除
-要求三个方法时间复杂度O(logN)
-
-假设有打乱顺序的一群人站成一个队列，数组people表示队列中一些人的属性（不一定按顺序）
-每个people[i]=[hi, ki]表示第i个人的身高为hi，前面正好有ki个身高大于或等于hi的人
-请你重新构造并返回输入数组people所表示的队列，返回的队列应该格式化为数组queue
-其中queue[j]=[hj, kj]是队列中第j个人的属性（queue[0] 是排在队列前面的人）。
-Leetcode题目：https://leetcode.com/problems/queue-reconstruction-by-height/
-
-
-
-38 根据对数器找规律、根据数据量猜解法
-
-内容：
-
-讲解对数器找规律的解题技巧
-
-讲解根据数据量猜解法的技巧
-1）C/C++，1秒处理的指令条数为10的8次方
-2）Java等语言，1~4秒处理的指令条数为10的8次方
-3）这里就有大量的分析提示了
-
-
-题目：
-
-小虎去买苹果，商店只提供两种类型的塑料袋，每种类型都有任意数量
-1）能装下6个苹果的袋子
-2）能装下8个苹果的袋子
-小虎可以自由使用两种袋子来装苹果，但是小虎有强迫症，他要求自己使用的袋子数量必须最少，
-且使用的每个袋子必须装满，给定一个正整数N，返回至少使用多少袋子。如果N无法让使用的每个袋子必须装满，返回-1
-
-给定一个正整数N，表示有N份青草统一堆放在仓库里，有一只牛和一只羊，牛先吃，羊后吃，它俩轮流吃草
-不管是牛还是羊，每一轮能吃的草量必须是：1，4，16，64…(4的某次方)
-谁最先把草吃完，谁获胜，假设牛和羊都绝顶聪明，都想赢，都会做出理性的决定。根据唯一的参数N，返回谁会赢
-
-定义一种数：可以表示成若干（数量>1）连续正数和的数
-比如，5=2+3，5就是这样的数；12=3+4+5，12就是这样的数
-2=1+1，2不是这样的数，因为等号右边不是连续正数
-给定一个参数N，返回是不是可以表示成若干连续正数和的数
-
-int[] d，d[i]：i号怪兽的能力
-int[] p，p[i]：i号怪兽要求的钱
-开始时你的能力是0，你的目标是从0号怪兽开始，通过所有的怪兽。
-如果你当前的能力，小于i号怪兽的能力，你必须付出p[i]的钱，贿赂这个怪兽，然后怪兽就会加入你
-他的能力直接累加到你的能力上；如果你当前的能力，大于等于i号怪兽的能力
-你可以选择直接通过，你的能力并不会下降，你也可以选择贿赂这个怪兽，然后怪兽就会加入你
-他的能力直接累加到你的能力上
-返回通过所有的怪兽，需要花的最小钱数
-（课上会给出不同的数据量描述）
-
-
-
-39 根据数据量猜解法（续）、分治技巧、卡特兰数
-
-内容：
-
-继续熟悉根据数据量猜解法
-
-讲解分治法
-
-讲解卡特兰数（课上证明的时候有小错，在40节开始处修正了）
-
-题目：
-
-给定一个非负数组arr，和一个正数m，返回arr的所有子序列中累加和%m之后的最大值
-
-牛牛家里一共有n袋零食, 第i袋零食体积为v[i]，背包容量为w，牛牛想知道在总体积不超过背包容量的情况下,
-一共有多少种零食放法，体积为0也算一种放法
-1 <= n <= 30, 1 <= w <= 2 * 10^9，v[I] (0 <= v[i] <= 10^9）
-
-假设给你N个0，和N个1，你必须用全部数字拼序列，返回有多少个序列满足任何前缀串，1的数量都不少于0的数量
-
-有N个二叉树节点，每个节点彼此之间无任何差别，返回由N个二叉树节点，组成的不同结构数量是多少？
-
-题目补充：	arr中的值可能为正，可能为负，可能为0，自由选择arr中的数字，能不能累加得到sum（多种做法）
-
-
-
-40 子数组达到规定累加和的最大长度系列问题、矩阵处理技巧题
-
-内容：
-
-修正了39节卡特兰数讲解时的一个小错误
-
-熟悉子数组达到规定累加和的三个模型（正、有正有负有0、累加和<=K）
-
-矩阵处理技巧的宏观调度coding技巧
-
-题目：
-
-给定一个正整数组成的无序数组arr，给定一个正整数值K，找到arr的所有子数组里，哪个子数组的累加和等于K
-并且是长度最大的，返回其长度
-
-给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K
-找到arr的所有子数组里，哪个子数组的累加和等于K，并且是长度最大的，返回其长度
-
-给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K
-找到arr的所有子数组里，哪个子数组的累加和<=K，并且是长度最大的，返回其长度
-
-给定一个数组arr，给定一个值v，求子数组平均值小于等于v的最长子数组长度
-
-给定一个正方形矩阵matrix，原地调整成顺时针90度转动的样子
-
-给定一个正方形或者长方形矩阵matrix，实现转圈打印
-
-给定一个正方形或者长方形矩阵matrix，实现zigzag打印
-
-转圈打印星号*问题
-
-
-
-41 四边形不等式技巧（上）
-
-内容：
-
-区间划分问题中的划分点不回退现象
-
-四边形不等式技巧特征
-1，两个可变参数的区间划分问题
-2，每个格子有枚举行为
-3，当两个可变参数固定一个，另一个参数和答案之间存在单调性关系
-4，而且两组单调关系是反向的：(升 升，降 降)  (升 降，降 升)
-5，能否获得指导枚举优化的位置对：上+右，或者，左+下
-
-四边形不等式技巧注意点
-1，不要证明！用对数器验证！
-2，枚举的时候面对最优答案相等的时候怎么处理？用对数器都试试！
-3，可以把时间复杂度降低一阶
-O(N^3) -> O(N^2)
-O(N^2 * M) -> O(N * M) 
-O(N * M^2) -> O(N * M) 
-4，四边形不等式有些时候是最优解，有些时候不是
-不是的原因：尝试思路，在根儿上不够好
-
-题目：
-
-给定一个非负数组arr，长度为N，
-那么有N-1种方案可以把arr切成左右两部分
-每一种方案都有，min{左部分累加和，右部分累加和}
-求这么多方案中，min{左部分累加和，右部分累加和}的最大值是多少？
-整个过程要求时间复杂度O(N)
-
-把题目一中提到的，min{左部分累加和，右部分累加和}，定义为S(N-1)，也就是说：
-S(N-1)：在arr[0…N-1]范围上，做最优划分所得到的min{左部分累加和，右部分累加和}的最大值
-现在要求返回一个长度为N的s数组，
-s[i] =在arr[0…i]范围上，做最优划分所得到的min{左部分累加和，右部分累加和}的最大值
-得到整个s数组的过程，做到时间复杂度O(N)
-
-摆放着n堆石子。现要将石子有次序地合并成一堆，规定每次只能选相邻的2堆石子合并成新的一堆
-并将新的一堆石子数记为该次合并的得分，求出将n堆石子合并成一堆的最小得分（或最大得分）合并方案
-
-给定一个整型数组 arr，数组中的每个值都为正数，表示完成一幅画作需要的时间，再给定一个整数num
-表示画匠的数量，每个画匠只能画连在一起的画作
-所有的画家并行工作，返回完成所有的画作需要的最少时间
-arr=[3,1,4]，num=2。
-最好的分配方式为第一个画匠画3和1，所需时间为4
-第二个画匠画4，所需时间为4
-所以返回4
-arr=[1,1,1,4,3]，num=3
-最好的分配方式为第一个画匠画前三个1，所需时间为3
-第二个画匠画4，所需时间为4
-第三个画匠画3，所需时间为3
-返回4
-
-
-
-42 四边形不等式技巧（下）
-
-内容：
-
-继续熟悉四边形不等式
-
-展示好的尝试是最关键的
-
-题目：
-
-一条直线上有居民点，邮局只能建在居民点上
-给定一个有序正数数组arr，每个值表示 居民点的一维坐标，再给定一个正数 num，表示邮局数量
-选择num个居民点建立num个邮局，使所有的居民点到最近邮局的总距离最短，返回最短的总距离
-arr=[1,2,3,4,5,1000]，num=2
-第一个邮局建立在3位置，第二个邮局建立在1000位置
-那么1位置到邮局的距离为2，2位置到邮局距离为1，3位置到邮局的距离为0，4位置到邮局的距离为1，5位置到邮局的距离为2
-1000位置到邮局的距离为0
-这种方案下的总距离为6，其他任何方案的总距离都不会比该方案的总距离更短，所以返回6
-
-一座大楼有0~N层，地面算作第0层，最高的一层为第N层
-已知棋子从第0层掉落肯定不会摔碎，从第i层掉落可能会摔碎，也可能不会摔碎(1≤i≤N)
-给定整数N作为楼层数，再给定整数K作为棋子数
-返回如果想找到棋子不会摔碎的最高层数，即使在最差的情况下扔的最少次数
-一次只能扔一个棋子
-N=10，K=1
-返回10
-因为只有1棵棋子，所以不得不从第1层开始一直试到第10层
-在最差的情况下，即第10层是不会摔坏的最高层，最少也要扔10次
-N=3，K=2
-返回2
-先在2层扔1棵棋子，如果碎了试第1层，如果没碎试第3层
-N=105，K=2
-返回14
-第一个棋子先在14层扔，碎了则用仅存的一个棋子试1~13
-若没碎，第一个棋子继续在27层扔，碎了则用仅存的一个棋子试15~26
-若没碎，第一个棋子继续在39层扔，碎了则用仅存的一个棋子试28~38
-若没碎，第一个棋子继续在50层扔，碎了则用仅存的一个棋子试40~49
-若没碎，第一个棋子继续在60层扔，碎了则用仅存的一个棋子试51~59
-若没碎，第一个棋子继续在69层扔，碎了则用仅存的一个棋子试61~68
-若没碎，第一个棋子继续在77层扔，碎了则用仅存的一个棋子试70~76
-若没碎，第一个棋子继续在84层扔，碎了则用仅存的一个棋子试78~83
-若没碎，第一个棋子继续在90层扔，碎了则用仅存的一个棋子试85~89
-若没碎，第一个棋子继续在95层扔，碎了则用仅存的一个棋子试91~94
-若没碎，第一个棋子继续在99层扔，碎了则用仅存的一个棋子试96~98
-若没碎，第一个棋子继续在102层扔，碎了则用仅存的一个棋子试100、101
-若没碎，第一个棋子继续在104层扔，碎了则用仅存的一个棋子试103
-若没碎，第一个棋子继续在105层扔，若到这一步还没碎，那么105便是结果
-
-
-
-43 状态压缩的动态规划
-
-内容：
-
-动态规划的状态压缩技巧
-
-题目：
-
-在"100 game"这个游戏中，两名玩家轮流选择从1到10的任意整数，累计整数和
-先使得累计整数和达到或超过100的玩家，即为胜者，如果我们将游戏规则改为 “玩家不能重复使用整数” 呢？
-例如，两个玩家可以轮流从公共整数池中抽取从1到15的整数（不放回），直到累计整数和 >= 100
-给定一个整数 maxChoosableInteger （整数池中可选择的最大数）和另一个整数 desiredTotal（累计和）
-判断先出手的玩家是否能稳赢（假设两位玩家游戏时都表现最佳）
-你可以假设 maxChoosableInteger 不会大于 20， desiredTotal 不会大于 300。
-Leetcode题目：https://leetcode.com/problems/can-i-win/
-
-TSP问题
-有N个城市，任何两个城市之间的都有距离，任何一座城市到自己的距离都为0
-所有点到点的距离都存在一个N*N的二维数组matrix里，也就是整张图由邻接矩阵表示
-现要求一旅行商从k城市出发必须经过每一个城市且只在一个城市逗留一次，最后回到出发的k城
-参数给定一个matrix，给定k。返回总距离最短的路的距离
-
-铺砖问题（最优解其实是轮廓线dp，但是这个解法对大厂刷题来说比较难，掌握课上的解法即可）
-你有无限的1*2的砖块，要铺满M*N的区域，
-不同的铺法有多少种?
-
-
-
-44 DC3生成后缀数组详解
-
-内容：
-
-后缀数组
-
-介绍用DC3算法生成后缀数组的流程
-
-题目：
-
-给你一个字符串 s，找出它的所有子串并按字典序排列，返回排在最后的那个子串
-Leetcode题目：https://leetcode.com/problems/last-substring-in-lexicographical-order/
-
-DC3算法的实现（完全根据论文描述）
-
-
-
-45 后缀数组解决的面试题
-
-内容：
-
-通过题目进一步熟悉DC3算法
-
-通过DC3算法得到height数组
-
-题目：
-
-给定两个字符串str1和str2，想把str2整体插入到str1中的某个位置，形成最大的字典序，返回字典序最大的结果
-
-给两个长度分别为M和N的整型数组nums1和nums2，其中每个值都不大于9，再给定一个正数K。 你可以在nums1和nums2中挑选数字，要求一共挑选K个，并且要从左到右挑。返回所有可能的结果中，代表最大数字的结果
-
-最长公共子串问题是面试常见题目之一，假设str1长度N，str2长度M
-一般在面试场上回答出O(N*M)的解法已经是比较优秀了
-因为得到O(N*M)的解法，就已经需要用到动态规划了
-但其实这个问题的最优解是O(N+M)，需要用到后缀数组+height数组
-课上将对本题解法代码进行详解
-
-
-
-46 动态规划猜法中和外部信息简化的相关问题（上）、哈夫曼树
-
-内容：
-
-以18节做总纲
-
-有些动态规划面试题，需要很好的设计参数，这种设计方式都有"外部信息简化"的特征
-
-哈夫曼树
-
-题目：
-
-有n个气球，编号为0到n-1，每个气球上都标有一个数字，这些数字存在数组nums中
-现在要求你戳破所有的气球。戳破第i个气球，你可以获得nums[i - 1] * nums[i] * nums[i + 1] 枚硬币
-这里的i-1和i+1代表和i相邻的、没有被戳爆的！两个气球的序号
-如果i-1或i+1超出了数组的边界，那么就当它是一个数字为1的气球
-求所能获得硬币的最大数量
-Leetcode题目：https://leetcode.com/problems/burst-balloons/
-
-给出一些不同颜色的盒子，盒子的颜色由数字表示，即不同的数字表示不同的颜色，你将经过若干轮操作去去掉盒子
-直到所有的盒子都去掉为止，每一轮你可以移除具有相同颜色的连续k个盒子（k >= 1）
-这样一轮之后你将得到 k * k 个积分，当你将所有盒子都去掉之后，求你能获得的最大积分和
-Leetcode题目：https://leetcode.com/problems/remove-boxes/
-
-如果一个字符相邻的位置没有相同字符，那么这个位置的字符出现不能被消掉
-比如:"ab"，其中a和b都不能被消掉
-如果一个字符相邻的位置有相同字符，就可以一起消掉
-比如:"abbbc"，中间一串的b是可以被消掉的，消除之后剩下"ac"
-某些字符如果消掉了，剩下的字符认为重新靠在一起
-给定一个字符串，你可以决定每一步消除的顺序，目标是请尽可能多的消掉字符，返回最少的剩余字符数量
-比如："aacca", 如果先消掉最左侧的"aa"，那么将剩下"cca"，然后把"cc"消掉，剩下的"a"将无法再消除，返回1
-但是如果先消掉中间的"cc"，那么将剩下"aaa"，最后都消掉就一个字符也不剩了，返回0，这才是最优解。
-再比如："baaccabb"，
-如果先消除最左侧的两个a，剩下"bccabb"，如果再消除最左侧的两个c，剩下"babb"，最后消除最右侧的两个b，剩下"ba"无法再消除，返回2
-而最优策略是：
-如果先消除中间的两个c，剩下"baaabb"，如果再消除中间的三个a，剩下"bbb"，最后消除三个b，不留下任何字符，返回0，这才是最优解
-
-给定一个数组arr，和一个正数M，返回在arr的子数组在长度不超过M的情况下，最大的累加和
-
-哈夫曼树的实现
-
-
-
-47 动态规划猜法中和外部信息简化的相关问题（下）、最大网络流算法之Dinic算法
-
-内容：
-
-进一步解决带有"外部信息简化"特征的动态规划
-
-Dinic算法
-
-题目：
-
-有台奇怪的打印机有以下两个特殊要求：
-打印机每次只能打印由同一个字符组成的序列。
-每次可以在任意起始和结束位置打印新字符，并且会覆盖掉原来已有的字符。
-给你一个字符串s，你的任务是计算这个打印机打印它需要的最少打印次数。
-Leetcode题目：https://leetcode.com/problems/strange-printer/
-
-整型数组arr长度为n(3 <= n <= 10^4)，最初每个数字是<=200的正数且满足如下条件：
-1. 0位置的要求：arr[0]<=arr[1] 
-2. n-1位置的要求：arr[n-1]<=arr[n-2]
-3. 中间i位置的要求：arr[i]<=max(arr[i-1],arr[i+1]) 
-但是在arr有些数字丢失了，比如k位置的数字之前是正数，丢失之后k位置的数字为0
-请你根据上述条件，计算可能有多少种不同的arr可以满足以上条件
-比如 [6,0,9] 只有还原成 [6,9,9]满足全部三个条件，所以返回1，即[6,9,9]达标
-
-Dinic算法详解
-测试链接：https://lightoj.com/problem/internet-bandwidth
-
-
-
-======================================================================================================================================
-
-
-
-01 大厂高频算法和数据结构面试题1
-
-题目：
-
-给定一个有序数组arr，代表坐落在X轴上的点，给定一个正数K，代表绳子的长度，返回绳子最多压中几个点？
-即使绳子边缘处盖住点也算盖住
-
-给定一个文件目录的路径，写一个函数统计这个目录下所有的文件数量并返回，隐藏文件也算，但是文件夹不算
-
-给定一个非负整数num，如何不用循环语句，返回>=num，并且离num最近的，2的某次方
-
-一个数组中只有两种字符'G'和'B'，可以让所有的G都放在左侧，所有的B都放在右侧
-或者可以让所有的G都放在右侧，所有的B都放在左侧，但是只能在相邻字符之间进行交换操作，返回至少需要交换几次
-
-给定一个二维数组matrix，你可以从任何位置出发，走向上、下、左、右四个方向，返回能走出来的最长的递增链长度
-
-给定两个非负数组x和hp，长度都是N，再给定一个正数range
-x有序，x[i]表示i号怪兽在x轴上的位置
-hp[i]表示i号怪兽的血量
-再给定一个正数range，表示如果法师释放技能的范围长度
-被打到的每只怪兽损失1点血量。返回要把所有怪兽血量清空，至少需要释放多少次AOE技能？
-
-给定一个数组arr，你可以在每个数字之前决定+或者-但是必须所有数字都参与，再给定一个数target
-请问最后算出target的方法数
-
-
-
-02 大厂高频算法和数据结构面试题2
-
-题目：
-
-给定数组hard和money，长度都为N，hard[i]表示i号工作的难度， money[i]表示i号工作的收入
-给定数组ability，长度都为M，ability[j]表示j号人的能力，每一号工作，都可以提供无数的岗位，难度和收入都一样
-但是人的能力必须>=这份工作的难度，才能上班。返回一个长度为M的数组ans，ans[j]表示j号人能获得的最好收入
-
-贩卖机只支持硬币支付，且收退都只支持10 ，50，100三种面额
-一次购买只能出一瓶可乐，且投钱和找零都遵循优先使用大钱的原则
-需要购买的可乐数量是m，其中手头拥有的10、50、100的数量分别为a、b、c，可乐的价格是x(x是10的倍数)
-请计算出需要投入硬币次数
-
-已知一个消息流会不断地吐出整数1~N，但不一定按照顺序依次吐出，如果上次打印的序号为i， 那么当i+1出现时
-请打印i+1及其之后接收过的并且连续的所有数，直到1~N全部接收并打印完，请设计这种接收并打印的结构
-
-现有司机N*2人，调度中心会将所有司机平分给A、B两区域，i号司机去A可得收入为income[i][0]，去B可得收入为income[i][1]
-返回能使所有司机总收入最高的方案是多少钱?
-
-设计有setAll功能的哈希表，put、get、setAll方法，时间复杂度O(1)
-
-给定一个数组arr，只能对arr中的一个子数组排序，但是想让arr整体都有序，返回满足这一设定的子数组中最短的是多长
-
-
-
-03 大厂高频算法和数据结构面试题3
-
-题目：
-
-求一个字符串中，最长无重复字符子串长度
-
-只由小写字母（a~z）组成的一批字符串，都放在字符类型的数组String[] arr中，如果其中某两个字符串所含有的字符种类完全一样
-就将两个字符串算作一类，比如baacbba和bac就算作一类，返回arr中有多少类
-
-给定一个只有0和1组成的二维数组，返回边框全是1（内部无所谓）的最大正方形面积
-
-给定一个数组arr，代表每个人的能力值。再给定一个非负数k，如果两个人能力差值正好为k，那么可以凑在一起比赛
-一局比赛只有两个人，返回最多可以同时有多少场比赛
-
-给定一个正数数组arr，代表若干人的体重，再给定一个正数limit，表示所有船共同拥有的载重量，每艘船最多坐两人，且不能超过载重
-想让所有的人同时过河，并且用最好的分配方法让船尽量少，返回最少的船数
-
-给定整数数组nums和目标值goal，需要从nums中选出一个子序列，使子序列元素总和最接近goal
-也就是说如果子序列元素和为sum ，需要最小化绝对差abs(sum - goal)，返回 abs(sum - goal)可能的最小值
-注意数组的子序列是通过移除原始数组中的某些元素（可能全部或无）而形成的数组。
-
-电子游戏“辐射4”中，任务“通向自由”要求玩家到达名为“Freedom Trail Ring”的金属表盘，并使用表盘拼写特定关键词才能开门
-给定一个字符串 ring，表示刻在外环上的编码；给定另一个字符串 key，表示需要拼写的关键词。您需要算出能够拼写关键词中所有字符的最少步数
-最初，ring 的第一个字符与12:00方向对齐。您需要顺时针或逆时针旋转 ring 以使 key 的一个字符在 12:00 方向对齐，然后按下中心按钮，以此逐个拼写完 key 中的所有字符
-旋转 ring 拼出 key 字符 key[i] 的阶段中：
-您可以将 ring 顺时针或逆时针旋转一个位置，计为1步。旋转的最终目的是将字符串 ring 的一个字符与 12:00 方向对齐，并且这个字符必须等于字符 key[i] 。
-如果字符 key[i] 已经对齐到12:00方向，您需要按下中心按钮进行拼写，这也将算作 1 步。按完之后，您可以开始拼写 key 的下一个字符（下一阶段）, 直至完成所有拼写。
-Leetcode题目：https://leetcode.com/problems/freedom-trail/
-
-给定三个参数，二叉树的头节点head，树上某个节点target，正数K。从target开始，可以向上走或者向下走，返回与target的距离是K的所有节点
-
-
-
-04 大厂高频算法和数据结构面试题4
-
-题目：
-
-数组为{3, 2, 2, 3, 1}，查询为(0, 3, 2)，意思是在数组里下标0~3这个范围上，有几个？答案返回2
-假设给你一个数组arr，对这个数组的查询非常频繁，且都给了查询组，请返回所有查询的结果
-
-返回一个数组中子数组最大累加和
-
-返回一个二维数组中子矩阵最大累加和
-
-返回一个数组中所选数字不能相邻的情况下最大子序列累加和
-
-老师想给孩子们分发糖果，有N个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分
-你需要按照以下要求，帮助老师给这些孩子分发糖果：
-每个孩子至少分配到 1 个糖果。
-评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
-那么这样下来，返回老师至少需要准备多少颗糖果
-进阶：在原来要求的基础上，增加一个要求，相邻的孩子间如果分数一样，分的糖果数必须一样，返回至少需要准备多少颗糖果
-
-生成长度为size的达标数组，什么叫达标？对于任意的i<k<j，满足[i]+[j]!=[k]*2。给定一个正数size，返回长度为size的达标数组
-
-给定三个字符串s1、s2、s3，请你帮忙验证s3是否是由s1和s2交错组成的
-Leetcode题目：https://leetcode.com/problems/interleaving-string/
-
-大楼轮廓线问题
-Leetcode题目：https://leetcode.com/problems/the-skyline-problem/
-
-
-
-05 大厂高频算法和数据结构面试题5
-
-题目：
-
-已知一棵搜索二叉树上没有重复值的节点，现在有一个数组arr，是这棵搜索二叉树先序遍历的结果，请根据arr生成整棵树并返回头节点
-
-如果一个节点X，它左树结构和右树结构完全一样，那么我们说以X为头的树是相等树，给定一棵二叉树的头节点head，返回head整棵树上有多少棵相等子树
-
-编辑距离问题
-
-给定两个字符串s1和s2，问s2最少删除多少字符可以成为s1的子串？比如 s1 = "abcde"，s2 = "axbc"，s2删掉'x'即可，返回1
-
-
-
-06 大厂高频算法和数据结构面试题6
-
-数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，返回arr的最大子数组异或和
-
-数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，想知道arr中哪两个数的异或结果最大，返回最大的异或结果
-Leetcode题目：https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/
-
-给定一个非负整数组成的数组nums。另有一个查询数组queries，其中queries[i]=[xi, mi]
-第i个查询的答案是xi和任何nums数组中不超过mi的元素按位异或（XOR）得到的最大值
-换句话说，答案是max(nums[j] XOR xi)，其中所有j均满足nums[j]<= mi。如果nums中的所有元素都大于mi，最终答案就是-1
-返回一个整数数组answer作为查询的答案，其中answer.length==queries.length且answer[i]是第i个查询的答案
-Leetcode题目：https://leetcode.com/problems/maximum-xor-with-an-element-from-array/
-
-数组中所有数都异或起来的结果，叫做异或和。给定一个数组arr，可以任意切分成若干个不相交的子数组。其中一定存在一种最优方案，使得切出异或和为0的子数组最多，返回这个最多数量
-
-Nim博弈，给定一个正数数组arr，先手和后手每次可以选择在一个位置拿走若干值，这个值要大于0，但是要小于该处的剩余，谁最先拿空arr谁赢，根据arr返回谁赢
-
-
-
-07 大厂高频算法和数据结构面试题7
-
-给定一个非负数组成的数组，长度一定大于1，想知道数组中哪两个数&的结果最大，返回这个最大结果。要求时间复杂度O(N)，额外空间复杂度O(1)
-
-给定一个二叉树，我们在树的节点上安装摄像头，节点上的每个摄影头都可以监视其父对象、自身及其直接子对象，计算监控树的所有节点所需的最小摄像头数量
-
-给定一个数组arr，返回如果排序之后（注意是如果排序），相邻两数的最大差值。要求时间复杂度O(N)，不能使用非基于比较的排序
-
-给定一个有序数组arr，其中值可能为正、负、0。返回arr中每个数都平方之后不同的结果有多少种？
-给定一个数组arr，先递减然后递增，返回arr中有多少个不同的数字？
-
-假设所有字符都是小写字母，大字符串是str，arr是去重的单词表, 每个单词都不是空字符串且可以使用任意次。使用arr中的单词有多少种拼接str的方式，返回方法数。
-
-String str, int K, String[] parts, int[] record
-Parts和records的长度一样长，str一定要分割成k个部分，分割出来的每部分在parts里必须得有，那一部分的得分在record里，请问str切成k个部分，返回最大得分
-
-
-
-08 大厂高频算法和数据结构面试题8
-
-给定一个字符串str，str表示一个公式，公式里可能有整数、加减乘除符号和左右括号。返回公式的计算结果
-难点在于括号可能嵌套很多层，str="48*((70-65)-43)+8*1"，返回-1816。str="3+1*4"，返回7。str="3+(1*4)"，返回7。
-1，可以认为给定的字符串一定是正确的公式，即不需要对str做公式有效性检查
-2，如果是负数，就需要用括号括起来，比如"4*(-3)"但如果负数作为公式的开头或括号部分的开头，则可以没有括号，比如"-3*4"和"(-3*4)"都是合法的
-3，不用考虑计算过程中会发生溢出的情况。
-
-给定n个非负整数a1，a2，...an，每个数代表坐标中的一个点 (i, ai)。在坐标内画n条垂直线
-垂直线i的两个端点分别为(i, ai)和(i, 0)，找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水
-Leetcode题目：https://leetcode.com/problems/container-with-most-water/
-
-给定一个char[][] matrix，也就是char类型的二维数组，再给定一个字符串word，
-可以从任何一个某个位置出发，可以走上、下、左、右，能不能找到word？
- char[][] m = {  { 'a', 'b', 'z' }, 
-                 { 'c', 'd', 'o' }, 
-                 { 'f', 'e', 'o' } }
-设定1：可以走重复路的情况下，返回能不能找到
-比如，word = "zoooz"，是可以找到的，z -> o -> o -> o -> z，因为允许走一条路径中已经走过的字符
-设定2：不可以走重复路的情况下，返回能不能找到
-比如，word = "zoooz"，是不可以找到的，因为允许走一条路径中已经走过的字符不能重复走 
-
-给定一个矩阵matrix，值有正、负、0。蛇可以空降到最左列的任何一个位置，初始增长值是0。蛇每一步可以选择右上、右、右下三个方向的任何一个前进
-沿途的数字累加起来，作为增长值；但是蛇一旦增长值为负数，就会死去。蛇有一种能力，可以使用一次：把某个格子里的数变成相反数
-蛇可以走到任何格子的时候停止，返回蛇能获得的最大增长值
-
-
-
-09 大厂高频算法和数据结构面试题9
-
-题目：
-
-给定一个数组arr，长度为N，arr中的值不是0就是1。arr[i]表示第i栈灯的状态，0代表灭灯，1代表亮灯
-每一栈灯都有开关，但是按下i号灯的开关，会同时改变i-1、i、i+1栈灯的状态
-问题一：如果N栈灯排成一条直线,请问最少按下多少次开关？
-i为中间位置时，i号灯的开关能影响i-1、i和i+1
-0号灯的开关只能影响0和1位置的灯
-N-1号灯的开关只能影响N-2和N-1位置的灯
-问题二：如果N栈灯排成一个圈,请问最少按下多少次开关,能让灯都亮起来
-i为中间位置时，i号灯的开关能影响i-1、i和i+1
-0号灯的开关能影响N-1、0和1位置的灯
-N-1号灯的开关能影响N-2、N-1和0位置的灯
-
-给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。返回所有可能的结果。答案可以按任意顺序返回
-Leetcode题目：https://leetcode.com/problems/remove-invalid-parentheses/
-
-给定一个数组arr，求最长递增子序列长度
-Leetcode题目：https://leetcode.com/problems/longest-increasing-subsequence
-
-给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度
-当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样
-请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）
-注意：不允许旋转信封
-
-定义何为step sum？比如680，680 + 68 + 6 = 754，680的step sum叫754。给定一个正数num，判断它是不是某个数的step sum
-
-
-
-10 大厂高频算法和数据结构面试题10
-
-题目：
-
-给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。
-你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。
-
-Top K Frequent Words II
-Implement three methods for Topk Class:
-TopK(k). The constructor.
-add(word). Add a new word.
-topk(). Get the current top k frequent words.
-LintCode题目：https://www.lintcode.com/problem/550/
-
-给出两个整数n和k，找出所有包含从1到n的数字，且恰好拥有k个逆序对的不同的数组的个数
-逆序对的定义如下：对于数组的第i个和第 j个元素，如果满i < j且 a[i] > a[j]，则其为一个逆序对，否则不是
-由于答案可能很大，只需要返回 答案 mod 10^9 + 7 的值
-Leetcode题目：https://leetcode.com/problems/k-inverse-pairs-array/
-
-给定一棵搜索二叉树头节点，转化成首尾相接的有序双向链表（节点都有两个方向的指针）
-
-给定一个布尔表达式和一个期望的布尔结果 result，布尔表达式由 0 (false)、1 (true)、& (AND)、 | (OR) 和 ^ (XOR) 符号组成。实现一个函数，算出有几种可使该表达式得出 result 值的括号方法。
-Leetcode题目：https://leetcode-cn.com/problems/boolean-evaluation-lcci/
-
-
-
-11 大厂高频算法和数据结构面试题11
-
-题目：
-
-问题一：一个字符串至少需要添加多少个字符能整体变成回文串
-问题二：返回问题一的其中一种添加结果
-问题三：返回问题一的所有添加结果
-
-问题一：一个字符串至少要切几刀能让切出来的子串都是回文串
-问题二：返回问题一的其中一种划分结果
-问题三：返回问题一的所有划分结果
-
-
-
-12 大厂高频算法和数据结构面试题12
-
-题目：
-
-给定长度为m的字符串aim，以及一个长度为n的字符串str，问能否在str中找到一个长度为m的连续子串，
-使得这个子串刚好由aim的m个字符组成，顺序无所谓，返回任意满足条件的一个子串的起始位置，未找到返回-1
-
-给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数
-进阶，在两个都有序的数组中找整体第K小的数，可以做到O(log(Min(M,N)))
-
-给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
-
-给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
-'.' 匹配任意单个字符
-'*' 匹配零个或多个前面的那一个元素
-所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。
-返回p能否匹配s
-
-
-
-13 大厂高频算法和数据结构面试题13
-
-题目：
-
-谷歌面试题扩展版，面值为1~N的牌组成一组，每次你从组里等概率的抽出1~N中的一张，下次抽会换一个新的组，有无限组
-当累加和<a时，你将一直抽牌；当累加和>=a且<b时，你将获胜；当累加和>=b时，你将失败
-返回获胜的概率，给定的参数为N，a，b
-
-假设有 n 台超级洗衣机放在同一排上。开始的时候，每台洗衣机内可能有一定量的衣服，也可能是空的
-在每一步操作中，你可以选择任意 m （1 ≤ m ≤ n） 台洗衣机，与此同时将每台洗衣机的一件衣服送到相邻的一台洗衣机
-给定一个非负整数数组代表从左至右每台洗衣机中的衣物数量，请给出能让所有洗衣机中剩下的衣物的数量相等的最少的操作步数
-如果不能使每台洗衣机中衣物的数量相等，则返回-1
-Leetcode题目：https://leetcode.com/problems/super-washing-machines/
-
-旋变字符串
-使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：
-如果字符串的长度为 1 ，算法停止
-如果字符串的长度 > 1 ，执行下述步骤：
-在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
-随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
-在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
-给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。
-Leetcode题目：https://leetcode.com/problems/scramble-string/
-
-有一个 m x n 的二元网格，其中 1 表示砖块，0 表示空白。砖块 稳定（不会掉落）的前提是：
-一块砖直接连接到网格的顶部，或者至少有一块相邻（4 个方向之一）砖块稳定不会掉落时
-给你一个数组 hits ，这是需要依次消除砖块的位置。每当消除 hits[i] = (rowi, coli) 位置上的砖块时，对应位置的砖块（若存在）会消失
-然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落，它会立即从网格中消失（即，它不会落在其他稳定的砖块上）
-返回一个数组 result ，其中 result[i] 表示第 i 次消除操作对应掉落的砖块数目
-注意，消除可能指向是没有砖块的空白位置，如果发生这种情况，则没有砖块掉落。
-Leetcode题目：https://leetcode.com/problems/bricks-falling-when-hit/
-
-
-
-14 大厂高频算法和数据结构面试题14
-
-题目：
-
-给定一个只由左括号和右括号的字符串，返回最长的有效括号子串的长度
-
-arr中求子数组的累加和是<=K的并且是最大的，返回这个最大的累加和
-
-从二叉树的某个节点x开始，往下子节点都要的，叫子树；在二叉树上只要能连起来的任何结构，叫子拓扑结构；
-返回二叉树上满足搜索二叉树性质的、最大子拓扑结构的节点数
-
-给定一个棵完全二叉树，返回这棵树的节点个数，要求时间复杂度小于O(树的节点数)
-
-给定一个棵搜索二叉树的头节点head，其中有两个节点错了，交换过来就能让整棵树重新变成搜索二叉树，怎么找到并调整正确？
-Leetcode题目：https://leetcode.com/problems/recover-binary-search-tree/
-
-给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
- 
-
-
-15 大厂高频算法和数据结构面试题15
-
-题目：股票系列问题
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/
-
-https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
-
-
-
-16 大厂高频算法和数据结构面试题16
-
-题目：
-
-给定一个有正、有负、有0的数组arr，
-给定一个整数k，
-返回arr的子集是否能累加出k
-1）正常怎么做？
-2）如果arr中的数值很大，但是arr的长度不大，怎么做？
-
-给定一个正数数组arr，
-返回arr的子集不能累加出的最小正数
-1）正常怎么做？
-2）如果arr中肯定有1这个值，怎么做？
-
-给定一个已排序的正整数数组 nums，和一个正整数 n 。从 [1, n] 区间内选取任意个数字补充到 nums 中，
-使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示，请输出满足上述要求的最少需要补充的数字个数
-
-给定整数power，给定一个数组arr，给定一个数组reverse。含义如下：
-arr的长度一定是2的power次方，reverse中的每个值一定都在0~power范围。
-例如power = 2, arr = {3, 1, 4, 2}，reverse = {0, 1, 0, 2}
-任何一个在前的数字可以和任何一个在后的数组，构成一对数。可能是升序关系、相等关系或者降序关系。
-比如arr开始时有如下的降序对：(3,1)、(3,2)、(4,2)，一共3个。
-接下来根据reverse对arr进行调整：
-reverse[0] = 0, 表示在arr中，划分每1(2的0次方)个数一组，然后每个小组内部逆序，那么arr变成[3,1,4,2]，此时有3个逆序对。
-reverse[1] = 1, 表示在arr中，划分每2(2的1次方)个数一组，然后每个小组内部逆序，那么arr变成[1,3,2,4]，此时有1个逆序对
-reverse[2] = 0, 表示在arr中，划分每1(2的0次方)个数一组，然后每个小组内部逆序，那么arr变成[1,3,2,4]，此时有1个逆序对。
-reverse[3] = 2, 表示在arr中，划分每4(2的2次方)个数一组，然后每个小组内部逆序，那么arr变成[4,2,3,1]，此时有4个逆序对。
-所以返回[3,1,1,4]，表示每次调整之后的逆序对数量。
-输入数据状况：
-power的范围[0,20]
-arr长度范围[1,10的7次方]
-reverse长度范围[1,10的6次方]
-
-约瑟夫环问题
-给定一个链表头节点head，和一个正数m，从头开始，每次数到m就杀死当前节点，然后被杀节点的下一个节点从1开始重新数，周而复始直到只剩一个节点，返回最后的节点
-Leetcode题目：https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/
-
-
-
-17 大厂高频算法和数据结构面试题17
-
-题目：
-
-给定一个每一行有序、每一列也有序，整体可能无序的二维数组，再给定一个数num，返回二维数组中有没有num这个数
-
-给定一个每一行有序、每一列也有序，整体可能无序的二维数组，再给定一个正数k，返回二维数组中第k小的数
-Leetcode题目：https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/
-
-给定一个字符串数组arr，里面都是互不相同的单词，找出所有不同的索引对(i, j)，使得列表中的两个单词，words[i] + words[j]，可拼接成回文串。
-Leetcode题目：https://leetcode.com/problems/palindrome-pairs/
-
-给定两个字符串S和T，返回S的所有子序列中有多少个子序列的字面值等于T
-
-给定一个字符串str，返回str的所有子序列中有多少不同的字面值
-Leetcode题目：https://leetcode.com/problems/distinct-subsequences-ii/
-
-
-
-18 大厂高频算法和数据结构面试题18
-
-题目：
-
-给定一个数组arr，长度为N，arr中的值只有1，2，3三种
-arr[i] == 1，代表汉诺塔问题中，从上往下第i个圆盘目前在左
-arr[i] == 2，代表汉诺塔问题中，从上往下第i个圆盘目前在中
-arr[i] == 3，代表汉诺塔问题中，从上往下第i个圆盘目前在右
-那么arr整体就代表汉诺塔游戏过程中的一个状况，如果这个状况不是汉诺塔最优解运动过程中的状况，返回-1
-如果这个状况是汉诺塔最优解运动过程中的状态，返回它是第几个状态
-
-在给定的二维二进制数组 A 中，存在两座岛。（岛是由四面相连的 1 形成的一个最大组。）现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。
-返回必须翻转的 0 的最小数目。（可以保证答案至少是1）
-Leetcode题目：https://leetcode.com/problems/shortest-bridge/
-
-给定一个矩阵matrix，先从左上角开始，每一步只能往右或者往下走，走到右下角。然后从右下角出发，每一步只能往上或者往左走，再回到左上角。任何一个位置的数字，只能获得一遍。返回最大路径和。
-输入描述:
-第一行输入两个整数M和N，M,N<=200
-接下来M行，每行N个整数，表示矩阵中元素
-输出描述:
-输出一个整数，表示最大路径和
-牛客网题目：https://www.nowcoder.com/questionTerminal/8ecfe02124674e908b2aae65aad4efdf
-
-给定两个有序数组arr1和arr2，再给定一个整数k，返回来自arr1和arr2的两个数相加和最大的前k个，两个数必须分别来自两个数组，按照降序输出
-时间复杂度为O(klogk)
-输入描述：
-第一行三个整数N, K分别表示数组arr1, arr2的大小，以及需要询问的数
-接下来一行N个整数，表示arr1内的元素
-再接下来一行N个整数，表示arr2内的元素
-输出描述：
-输出K个整数表示答案
-牛客网题目：https://www.nowcoder.com/practice/7201cacf73e7495aa5f88b223bbbf6d1
-
-
-
-19 大厂高频算法和数据结构面试题19
-
-题目：
-
-LRU内存/缓存替换算法
-Leetcode题目：https://leetcode.com/problems/lru-cache/
-
-LFU内存/缓存替换算法
-Leetcode题目：https://leetcode.com/problems/lfu-cache/
-
-给定一个正数N，比如N = 13，在纸上把所有数都列出来如下：
-1 2 3 4 5 6 7 8 9 10 11 12 13
-可以数出1这个字符出现了6次，给定一个正数N，如果把1~N都列出来，返回1这个字符出现的多少次
-
-你有k个非递减排列的整数列表。找到一个最小区间，使得k个列表中的每个列表至少有一个数包含在其中
-我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。
-Leetcode题目：https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/
-
-一张扑克有3个属性，每种属性有3种值（A、B、C）
-比如"AAA"，第一个属性值A，第二个属性值A，第三个属性值A
-比如"BCA"，第一个属性值B，第二个属性值C，第三个属性值A
-给定一个字符串类型的数组cards[]，每一个字符串代表一张扑克
-从中挑选三张扑克，一个属性达标的条件是：这个属性在三张扑克中全一样，或全不一样
-挑选的三张扑克达标的要求是：每种属性都满足上面的条件
-比如："ABC"、"CBC"、"BBC"
-第一张第一个属性为"A"、第二张第一个属性为"C"、第三张第一个属性为"B"，全不一样
-第一张第二个属性为"B"、第二张第二个属性为"B"、第三张第二个属性为"B"，全一样
-第一张第三个属性为"C"、第二张第三个属性为"C"、第三张第三个属性为"C"，全一样
-每种属性都满足在三张扑克中全一样，或全不一样，所以这三张扑克达标
-返回在cards[]中任意挑选三张扑克，达标的方法数
-
-
-
-20 大厂高频算法和数据结构面试题20
-
-题目：
-
-如果只给定一个二叉树前序遍历数组pre和中序遍历数组in，能否不重建树，而直接生成这个二叉树的后序数组并返回，已知二叉树中没有重复值
-
-给定一个由不同正整数的组成的非空数组 A，考虑下面的图：有 A.length 个节点，按从 A[0] 到 A[A.length - 1] 标记；
-只有当 A[i] 和 A[j] 共用一个大于 1 的公因数时，A[i] 和 A[j] 之间才有一条边。返回图中最大连通集合的大小
-Leetcode题目：https://leetcode.com/problems/largest-component-size-by-common-factor/
-
-完美洗牌问题
-给定一个长度为偶数的数组arr，假设长度为N*2
-左部分：arr[L1...Ln] 右部分： arr[R1...Rn]
-请把arr调整成arr[L1,R1,L2,R2,L3,R3,...,Ln,Rn]
-要求时间复杂度O(N)，额外空间复杂度O(1)
-
-给定一个字符串str，当然可以生成很多子序列，返回有多少个子序列是回文子序列，空序列不算回文
-比如，str = “aba”，回文子序列：{a}、{a}、 {a,a}、 {b}、{a,b,a}，返回5
-
-
-
-21 大厂高频算法和数据结构面试题21
-
-题目：
-
-树链剖分专题
-给定数组father，大小为N，表示一共有N个节点
-father[i] = j 表示点i的父亲是点j， father表示的树一定是一棵树而不是森林
-给定数组values，大小为N，values[i]=v表示节点i的权值是v
-实现如下4个方法，保证4个方法都很快！
-1)让某个子树所有节点值加上v，入参：int head, int v
-2)查询某个子树所有节点值的累加和，入参：int head
-3)在树上从a到b的整条链上所有加上v，入参：int a, int b, int v
-4)查询在树上从a到b的整条链上所有节点值的累加和，入参：int a, int b
-
-
-
-22 大厂高频算法和数据结构面试题22
-
-题目：
-
-给定数组 nums 由正整数组成，找到三个互不重叠的子数组的最大和。每个子数组的长度为k，我们要使这3*k个项的和最大化。返回每个区间起始索引的列表（索引从 0 开始）。如果有多个结果，返回字典序最小的一个。
-Leetcode题目：https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/
-
-给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水
-Leetcode题目：https://leetcode.com/problems/trapping-rain-water/
-
-给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。
-Leetcode题目：https://leetcode.com/problems/trapping-rain-water-ii/
-
-一个不含有负数的数组可以代表一圈环形山，每个位置的值代表山的高度
-比如， {3,1,2,4,5}、{4,5,3,1,2}或{1,2,4,5,3}都代表同样结构的环形山
-山峰A和山峰B能够相互看见的条件为: 
-1.如果A和B是同一座山，认为不能相互看见
-2.如果A和B是不同的山，并且在环中相邻，认为可以相互看见
-3.如果A和B是不同的山，并且在环中不相邻，假设两座山高度的最小值为min
-       1)如果A通过顺时针方向到B的途中没有高度比min大的山峰，认为A和B可以相互看见
-       2)如果A通过逆时针方向到B的途中没有高度比min大的山峰，认为A和B可以相互看见
-两个方向只要有一个能看见，就算A和B可以相互看见
-给定一个不含有负数且没有重复值的数组 arr，请返回有多少对山峰能够相互看见
-进阶，给定一个不含有负数但可能含有重复值的数组arr，返回有多少对山峰能够相互看见
-
-你正在安装一个广告牌，并希望它高度最大。这块广告牌将有两个钢制支架，两边各一个。每个钢支架的高度必须相等。
-你有一堆可以焊接在一起的钢筋 rods。举个例子，如果钢筋的长度为 1、2 和 3，则可以将它们焊接在一起形成长度为 6 的支架。
-返回广告牌的最大可能安装高度。如果没法安装广告牌，请返回 0。
-Leetcode题目：https://leetcode.com/problems/tallest-billboard/
-
-
-
-23 大厂高频算法和数据结构面试题23
-
-题目：
-
-给定数组father大小为N，表示一共有N个节点
-father[i] = j 表示点i的父亲是点j， father表示的树一定是一棵树而不是森林
-queries是二维数组，大小为M*2，每一个长度为2的数组都表示一条查询
-[4,9], 表示想查询4和9之间的最低公共祖先… 
-[3,7], 表示想查询3和7之间的最低公共祖先…
-tree和queries里面的所有值，都一定在0~N-1之间
-返回一个数组ans，大小为M，ans[i]表示第i条查询的答案
-
-给定一个数组arr，长度为N > 1，从中间切一刀，保证左部分和右部分都有数字，一共有N-1种切法
-如此多的切法中，每一种都有:绝对值(左部分最大值 – 右部分最大值)，返回最大的绝对值是多少
-
-定义什么是可整合数组：一个数组排完序之后，除了最左侧的数外，有arr[i] = arr[i-1]+1
-则称这个数组为可整合数组比如{5,1,2,4,3}、{6,2,3,1,5,4}都是可整合数组，返回arr中最长可整合子数组的长度
-
-超级水王问题
-给定一个数组arr，长度为N，如果某个数出现次数大于N/2，称该数为水王数，如果arr中有水王数，打印这个数；如果没有水王数，打印没有水王数
-要求时间复杂度O(N)，额外空间复杂度O(1)
-扩展1：摩尔投票
-扩展2：给定一个正数K，返回所有出现次数>N/K的数
-
-有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。
-找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。
-Leetcode题目：https://leetcode.com/problems/minimum-cost-to-merge-stones/
-
-
-
-24 大厂高频算法和数据结构面试题24
-
-题目：
-
-给定一个正数数组arr，长度一定大于6（>=7），一定要选3个数字做分割点，从而分出4个部分，并且每部分都有数
-分割点的数字直接删除，不属于任何4个部分中的任何一个。返回有没有可能分出的4个部分累加和一样大
-如：{3,2,3,7,4,4,3,1,1,6,7,1,5,2}。可以分成{3,2,3}、{4,4}、{1,1,6}、{1,5,2}。分割点是不算的！
-
-长度为N的数组arr，一定可以组成N^2个数字对。例如arr = [3,1,2]，数字对有(3,3) (3,1) (3,2) (1,3) (1,1) (1,2) (2,3) (2,1) (2,2)
-也就是任意两个数都可以，而且自己和自己也算数字对。数字对怎么排序？第一维数据从小到大；第一维数据一样的，第二维数组也从小到大
-所以上面的数值对排序的结果为：(1,1)(1,2)(1,3)(2,1)(2,2)(2,3)(3,1)(3,2)(3,3)。给定一个数组arr，和整数k，返回第k小的数值对
-
-正常的里程表会依次显示自然数表示里程
-吉祥的里程表会忽略含有4的数字而跳到下一个完全不含有4的数
-正常：1 2 3 4 5 6 7 8  9 10 11 12 13 14 15
-吉祥：1 2 3 5 6 7 8 9 10 11 12 13 15 16 17 ... 38 39 50 51 52 53 55
-给定一个吉祥里程表的数字num(当然这个数字中不含有4)
-返回这个数字代表的真实里程
-
-N * M的棋盘（N和M是输入参数），每种颜色的格子数必须相同的，上下左右的格子算相邻，相邻格子染的颜色必须不同，所有格子必须染色，返回至少多少种颜色可以完成任务
-
-给定两个字符串str1和str2，在str1中寻找一个最短子串，能包含str2的所有字符，字符顺序无所谓，str1的这个最短子串也可以包含多余的字符，返回这个最短包含子串
-
-给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）
-Leetcode题目：https://leetcode.com/problems/remove-duplicate-letters/
-
-
-
-25 大厂高频算法和数据结构面试题25
-
-题目：
-
-An IP address is a formatted 32-bit unsigned integer where each group of 8 bits is printed as a decimal number and the dot character '.' splits the groups.
-For example, the binary number 00001111 10001000 11111111 01101011 (spaces added for clarity) formatted as an IP address would be "15.136.255.107".
-A CIDR block is a format used to denote a specific set of IP addresses. It is a string consisting of a base IP address, followed by a slash, followed by a prefix length k.
-The addresses it covers are all the IPs whose first k bits are the same as the base IP address.
-For example, "123.45.67.89/20" is a CIDR block with a prefix length of 20. Any IP address whose binary representation matches
-01111011 00101101 0100xxxx xxxxxxxx, where x can be either 0 or 1, is in the set covered by the CIDR block.
-You are given a start IP address ip and the number of IP addresses we need to cover n. 
-Your goal is to use as few CIDR blocks as possible to cover all the IP addresses in the inclusive range [ip, ip + n - 1] exactly
-No other IP addresses outside of the range should be covered.
-Return the shortest list of CIDR blocks that covers the range of IP addresses. If there are multiple answers, return any of them.
-Leetcode题目：https://leetcode.com/problems/ip-to-cidr/
-
-给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组
-注意：答案中不可以包含重复的三元组
-Leetcode题目：https://leetcode.com/problems/3sum/
-
-给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。
-Leetcode题目：https://leetcode.com/problems/max-points-on-a-line/
-
-良好加油站问题最优解
-Leetcode题目：https://leetcode.com/problems/gas-station/
-
-
-
-26 大厂高频算法和数据结构面试题26
-
-题目：
-
-有三个有序数组，分别在三个数组中挑出3个数，x、y、z。返回 |x-y| + |y-z| + |z-x|最小是多少？
-Leetcode题目：https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/
-
-给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words，找出所有同时在二维网格和字典中出现的单词
-单词必须按照字母顺序，通过 相邻的单元格 内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格
-同一个单元格内的字母在一个单词中不允许被重复使用。
-Leetcode题目：https://leetcode.com/problems/word-search-ii/
-
-给定一个仅包含数字 0-9 的字符串和一个目标值，在数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回所有能够得到目标值的表达式。
-输入: num = "123", target = 6
-输出: ["1+2+3", "1*2*3"] 
-示例 2:
-输入: num = "232", target = 8
-输出: ["2*3+2", "2+3*2"]
-示例 3:
-输入: num = "105", target = 5
-输出: ["1*0+5","10-5"]
-示例 4:
-输入: num = "00", target = 0
-输出: ["0+0", "0-0", "0*0"]
-Leetcode题目：https://leetcode.com/problems/expression-add-operators/
-
-按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足：
-每对相邻的单词之间仅有单个字母不同。
-转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词
-给你两个单词 beginWord 和 endWord ，以及一个字典 wordList
-请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表
-每个序列都应该以单词列表 [beginWord, s1, s2, ..., sk] 的形式返回
-Leetcode题目：https://leetcode.com/problems/word-ladder-ii/
-
-
-
-27 大厂高频算法和数据结构面试题27
-
-题目：
-
-每一个项目都有三个数，[a,b,c]表示这个项目a和b乐队参演，花费为c
-每一个乐队可能在多个项目里都出现了，但是只能被挑一次
-nums是可以挑选的项目数量，所以一定会有nums*2只乐队被挑选出来
-返回一共挑nums轮(也就意味着一定请到所有的乐队)，最少花费是多少？
-如果怎么都无法在nums轮请到nums*2只乐队且每只乐队只能被挑一次，返回-1
-nums<9，programs长度小于500，每组测试乐队的全部数量一定是nums*2，且标号一定是0 ~ nums*2-1
-
-企鹅厂每年都会发文化衫，文化衫有很多种，厂庆的时候，企鹅们都需要穿文化衫来拍照
-一次采访中，记者随机遇到的企鹅，企鹅会告诉记者还有多少企鹅跟他穿一种文化衫
-我们将这些回答放在answers数组里，返回鹅厂中企鹅的最少数量
-Leetcode题目：https://leetcode.com/problems/rabbits-in-forest/
-
-给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标
-你可以假设每种输入只会对应一个答案。但是数组中同一个元素在答案里不能重复出现，你可以按任意顺序返回答案
-Leetcode题目：https://leetcode.com/problems/two-sum/
-
-给你一个32位的有符号整数x，返回将x中的数字部分反转后的结果，如果反转后整数超过 32 位的有符号整数的范围，就返回0
-假设环境不允许存储 64 位整数（有符号或无符号）
-Leetcode题目：https://leetcode.com/problems/reverse-integer/
-
-
-
-28 大厂高频算法和数据结构面试题28
-
-题目：
-
-请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）
-函数 myAtoi(string s) 的算法如下：
-读入字符串并丢弃无用的前导空格
-检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
-读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
-将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
-如果整数数超过 32 位有符号整数范围 [−231,  231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为231 − 1。
-返回整数作为最终结果。
-注意：本题中的空白字符只包括空格字符 ' ' 。除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
-Leetcode题目：https://leetcode.com/problems/string-to-integer-atoi/
-
-罗马数字包含以下七种字符： I， V， X， L，C，D 和 M
-字符          数值
-I             1
-V             5
-X             10
-L             50
-C             100
-D             500
-M             1000
-例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
-通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
-I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
-X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
-C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
-给你一个整数，将其转为罗马数字
-Leetcode题目：https://leetcode.com/problems/integer-to-roman/
-
-罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
-字符          数值
-I             1
-V             5
-X             10
-L             50
-C             100
-D             500
-M             1000
-例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
-通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 
-同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
-I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
-X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
-C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
-给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
-Leetcode题目：https://leetcode.com/problems/roman-to-integer/
-
-编写一个函数来查找字符串数组中的最长公共前缀，如果不存在公共前缀，返回空字符串 ""。
-Leetcode题目：https://leetcode.com/problems/longest-common-prefix/
-
-给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
-给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
-按键2对应：'a', 'b', 'c'
-按键3对应：'d', 'e', 'f'
-按键4对应：'g', 'h', 'i'
-按键5对应：'j', 'k', 'l'
-按键6对应：'m', 'n', 'o'
-按键7对应：'p', 'q', 'r', 's'
-按键8对应：'t', 'u', 'v'
-按键9对应：'w', 'x', 'y', 'z'
-示例 1：
-输入：digits = "23"
-输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
-示例 2：
-输入：digits = ""
-输出：[]
-示例 3：
-输入：digits = "2"
-输出：["a","b","c"]
-Leetcode题目：https://leetcode.com/problems/letter-combinations-of-a-phone-number/
-
-给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
-进阶：你能尝试使用一趟扫描实现吗？
-Leetcode题目：https://leetcode.com/problems/remove-nth-node-from-end-of-list/
-
-给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
-有效字符串需满足：
-左括号必须用相同类型的右括号闭合。
-左括号必须以正确的顺序闭合。
-Leetcode题目：https://leetcode.com/problems/valid-parentheses/
-
-数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。
-示例 1：
-输入：n = 3
-输出：["((()))","(()())","(())()","()(())","()()()"]
-示例 2：
-输入：n = 1
-输出：["()"]
-Leetcode题目：https://leetcode.com/problems/generate-parentheses/
-
-给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
-不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
-示例 1：
-输入：nums = [1,1,2]
-输出：2, nums = [1,2,_]
-解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
-示例 2：
-输入：nums = [0,0,1,1,1,2,2,3,3,4]
-输出：5, nums = [0,1,2,3,4,_,_,_,_,_]
-解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
-Leetcode题目：https://leetcode.com/problems/remove-duplicates-from-sorted-array/
-
-给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
-如果数组中不存在目标值 target，返回 [-1, -1]。
-要求：设计并实现时间复杂度为 O(log n) 的算法
-Leetcode题目：https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
-
-请你判断一个 9x9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
-数字 1-9 在每一行只能出现一次。
-数字 1-9 在每一列只能出现一次。
-数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
-数独部分空格内已填入了数字，空白格用 '.' 表示。
-注意：
-一个有效的数独（部分已被填充）不一定是可解的。
-只需要根据以上规则，验证已经填入的数字是否有效即可。
-Leetcode题目：https://leetcode.com/problems/valid-sudoku/
-
-编写一个程序，通过填充空格来解决数独问题。
-数独的解法需遵循如下规则：
-数字 1-9 在每一行只能出现一次。
-数字 1-9 在每一列只能出现一次。
-数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次
-数独部分空格内已填入了数字，空白格用 '.' 表示。
-Leetcode题目：https://leetcode.com/problems/sudoku-solver/
-
-给定一个正整数 n ，输出的第 n 项。
-前五项如下：
-1.     1
-2.     11
-3.     21
-4.     1211
-5.     111221
-第一项是数字 1 
-描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
-描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
-描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
-描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
-返回第N项的字符串
-Leetcode题目：https://leetcode.com/problems/count-and-say/
-
-给定一个字符串数组，将字母异位词组合在一起。可以按任意顺序返回结果列表。
-字母异位词指字母相同，但排列不同的字符串。
-示例 1:
-输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
-输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
-示例 2:
-输入: strs = [""]
-输出: [[""]]
-示例 3:
-输入: strs = ["a"]
-输出: [["a"]]
-Leetcode题目：https://leetcode.com/problems/group-anagrams/
-
-
-
-29 大厂高频算法和数据结构面试题29
-
-题目：
-
-整数数组 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 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
-Leetcode题目：https://leetcode.com/problems/search-in-rotated-sorted-array/
-
-实现 pow(x, n) ，即计算 x 的 n 次幂函数
-Leetcode题目：https://leetcode.com/problems/powx-n/
-
-以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]
-请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间
-Leetcode题目：https://leetcode.com/problems/merge-intervals/
-
-一个机器人位于一个 m x n 网格的左上角
-机器人每次只能向下或者向右移动一步
-机器人试图达到网格的右下角
-问总共有多少条不同的路径？
-Leetcode题目：https://leetcode.com/problems/unique-paths/
-
-给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加1
-最高位数字存放在数组的首位， 数组中每个元素只存储单个数字
-你可以假设除了整数 0 之外，这个整数不会以零开头
-示例 1：
-输入：digits = [1,2,3]
-输出：[1,2,4]
-解释：输入数组表示数字 123。
-示例 2：
-输入：digits = [9,9,9]
-输出：[1,0,0,0]
-解释：输入数组表示数字 1000。
-示例 3：
-输入：digits = [0]
-输出：[1]
-Leetcode题目：https://leetcode.com/problems/plus-one/
-
-实现 int sqrt(int x) 函数。
-计算并返回 x 的平方根，其中 x 是非负整数。
-由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
-示例 1:
-输入: 4
-输出: 2
-示例 2:
-输入: 8
-输出: 2
-说明: 8 的平方根是 2.82842...，由于返回类型是整数，小数部分将被舍去。
-Leetcode题目：https://leetcode.com/problems/sqrtx/
-
-给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
-进阶：
-一个直观的解决方案是使用 O(m * n) 的额外空间，但这并不是一个好的解决方案。
-一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
-你能想出一个仅使用常量空间的解决方案吗？
-Leetcode题目：https://leetcode.com/problems/set-matrix-zeroes/
-
-
-