Knight

首先我们要去找组数中最大的元素max，然后使用candies[i] + extraCandies是否大于等于max,如果大于则证明它是拥有最多糖果的孩子

看见最大公因子就要想到gcd(辗转相除法)

题目来源。

题目来源。

1、我们定义两个指针，分别称之为 g(guard 守卫) 和 p(point)。我们首先根据方法的参数 m 确定 g 和 p 的位置。将 g 移动到第一个要反转的节点的前面，将 p 移动到第一个要反转的节点的位置上。我们以 m=2，n=4为例。2、将 p 后面的元素删除，然后添加到 g 的后面。3、根据 m 和 n 重复步骤（2） 4、返回 dummyHead.next。

非递归方法：理解了全链表反转，该题只需要注意指针的处理。反转前n个节点，需要保存第n+1个节点，与反转后的前N个节点链表进行拼接。递归方法类似全链表反转，注意递归的终止条件。

输入一个节点 head，将「以 head 为起点」的链表反转，并返回反转之后的头结点。reverse 函数会返回反转之后的头结点，我们用变量 last 接收了。定义两个指针： pre 和 cur；pre 在前 cur 在后。意思是如果链表只有一个节点的时候反转也是它自己，直接返回即可。每次让 cur 的 next 指向 pre，实现一次局部反转。局部反转完成之后，pre 和 cur 同时往前移动一个位置。循环上述过程，直至 cur 到达链表尾部。

从题目可知，牛牛向右走的距离必须是ai的整数倍，所以遍历顺序从左到右。初始化dp，将草地的斤数赋值给dp,因为牛牛可以从任何一块地开始。定义dp[i]为牛牛当前最多能吃到多少斤草。temp是之前能走到dp[i]的最大值。wi[i]代表牛牛能吃到多少斤草。ai[i]代表牛牛能走到哪隔吃草。

【模板】拓扑排序。

然后对每个「字符对」所对应的两个 int 值执行 & 操作（若两字符无重复字符，则结果为 0），并得出最终答案。我们可以使用一个 int 来代指某个 word[i]：低 26 来代指字母 a-z 是否出现过。

【代码】剑指 Offer 32 - II. 从上到下打印二叉树 II。

【代码】剑指 Offer 32 - I. 从上到下打印二叉树。

题目要求只包含小写字母，我们可以定义一个长度为26的数组，如果重复字母就进行累加，如果当前索引的数是1，说明当前字符只出现了一次。初始化一个HashMap< Character , Boolean>查找数量为 1 的字符： 遍历字符串 s 中的每个字符 c；返回 ’ ’ ，代表字符串无数量为 1 的字符。

当 matrix[i][j] > target 时，执行 i-- ，即消去第 i 行元素；当 matrix[i][j] < target 时，执行 j++ ，即消去第 j 列元素；时间复杂度 O(M+N)：其中，N和 M分别为矩阵行数和列数，此算法最多循环 M+N 次。当 matrix[i][j] = target 时，返回 true ，代表找到目标值。若行索引或列索引越界，则代表矩阵中无目标值，返回 false。

返回值： 跳出时，变量 i 和 j 分别指向 “右子数组的首位元素” 和 “左子数组的末位元素”。因此返回 i 即可。初始化： 左边界 i=0 ，右边界 j=nums.length−1。循环二分： 当闭区间 [i, j] 无元素时跳出；

返回值： 应用两次二分，分别查找 right 和 left ，最终返回 right−left−1 即可。初始化： 左边界 i=0 ，右边界 j=nums.length−1。循环二分： 当闭区间 [i, j] 无元素时跳出；最终直接l-r-1即可，完整代码。求比target大的值。求比taget小的值。

题目要求了在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内，说明有与索引相同的数字，比如nums[i]=i;使用HashSet判断是否有重复的数字。

再向 builder添加 “首位至第 n-1 位的字符”；新建一个StringBuilder，记为 builder；先向 builder添加 “第 n 位至末位的字符”；将 builder转化为字符串并返回。

初始化一个StringBuilder，记为 builder；(StringBuilder比StringBuffer的效率要高，因为没加Synchronized)当 c 为空格时：向 builder后添加字符串 “%20”；当 c 不为空格时：向 builder后添加字符 c；将列表 res 转化为字符串并返回。

直接使用原来的链表来进行删除操作。设置一个虚拟头结点在进行删除操作。

调用并返回 recur(head, null)。传入 null 是因为反转链表后， head 节点指向 null；考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的 next 引用指向。空间复杂度 O(1) ： 变量 pre 和 cur 使用常数大小额外空间。时间复杂度 O(N) ： 遍历链表使用线性大小时间。

利用哈希表的查询特点，考虑构建 原链表节点 和 新链表对应节点 的键值对映射关系，再遍历构建新链表各节点的 next 和 random 引用指向即可。

出栈： 将各节点值 pop 出栈，存储于数组并返回。入栈： 遍历链表，将各节点值 push 入栈。使用ArrayList集合。不使用ArrayList。

直接返回栈 A 的栈顶元素即可，即返回 A.peek()。直接返回栈 B 的栈顶元素即可，即返回 B.peek()。重点为保持栈 B的元素是 非严格降序 的。重点为保持栈 A,B 的 元素一致性。

加入队尾 appendTail()函数： 将数字 value 加入栈 A 即可。删除队首deleteHead()函数： 有以下三种情况。

为示例数组 [2,4,1,0,3,5] 的快速排序流程。观察发现，快速排序和 二分法 的原理类似，都是以 logn 时间复杂度实现搜索区间缩小。递归： 对 左子数组 和 右子数组 递归执行 哨兵划分，直至子数组长度为 1 时终止递归，即可完成对整个数组的排序。以数组某个元素（一般选取首元素）为 基准数 ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。时间复杂度：基于随机选取主元的快速排序时间复杂度为期望 O(nlogn)，其中 n 为数组的长度。

为示例数组 [2,4,1,0,3,5] 的快速排序流程。观察发现，快速排序和 二分法 的原理类似，都是以 logn 时间复杂度实现搜索区间缩小。递归： 对 左子数组 和 右子数组 递归执行 哨兵划分，直至子数组长度为 1 时终止递归，即可完成对整个数组的排序。以数组某个元素（一般选取首元素）为 基准数 ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。时间复杂度：基于随机选取主元的快速排序时间复杂度为期望 O(nlogn)，其中 n 为数组的长度。

LeetCode-374. 猜数字大小

从题目的要求和示例我们可以看出，这其实是一个查找整数的问题，并且这个整数是有范围的。因此我们可以使用「二分查找」来查找这个整数，不断缩小范围去猜。猜的数平方以后小了，可能猜的数就是，也可能不是。猜的数平方以后恰恰好等于输入的数就找到了；猜的数平方以后大了就往小了猜；

以输入：matrix = [[“1”,“0”,“1”,“0”,“0”],[“1”,“0”,“1”,“1”,“1”],[“1”,“1”,“1”,“1”,“1”],[“1”,“0”,“0”,“1”,“0”]]为例。从递推公式dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1可知，遍历顺序从上到下，从左到右。用 dp(i, j) 表示以 matrix[i][j] 为右下角的最大正方形的边长。

如果 nums[i] 是负数该怎么办呢？dp[i - 1] 是正数的时候，越乘越小，dp[i - 1] 是负数的时候，越乘越大，于是我们可能就需要记录一下负数的那个最小数。根据递推公式可知，可以推出我们要初始化dp[0][0]和dp[0][1]为当前数nums[0]说明：牢记状态的定义，一定以下标 i 结尾，即：乘积数组中 nums[i] 必须被选取。dp[i][2]：包括下标i（以nums[i]为结尾）的乘积最大子数组积为dp[i]。如果 dp[i - 1] 是负数，乘上 nums[i] 还是负数。

常规： triangle[i][j]一定会经过triangle[i-1][j]或者triangle[i-1][j-1], 所以状态dp[i][j]一定等于dp[i-1][j]或者dp[i-1][j-1]的最小值+triangle[i][j]由递推公式dp[i][j]=Math.min(dp[i-1][j],dp[i-1][j-1])+triangle[i][j]可知，我们要推前面的一个，所以dp[0][0] = triangle.get(0).get(0);3.dp数组如何初始化。

dp[0]代表前0个数字的方案数，这样的状态定义其实是没有实际意义的，但是dp[0]的值需要保证边界是对的，即dp[1]和dp[2]是对的。解码前两个数，如果第1个数和第2个数可以组合起来解码，那么dp[2] = dp[1] + dp[0] = 2，否则只能单独解码第2个数，即f[2] = f[1] = 1。只能由位置 i 的与前一位置（i-1）共同作为一个 item，设为 b，转移的前提是 b 的数值范围为 [10,26]，转移逻辑为 dp[i]=dp[i−2]。以s = "226"例。

从递归公式 dp[i][j] = Math.min(dp[i][j-1],dp[i-1][j]) + grid[i][j]中可以看出，遍历的顺序一定是从上到下，从左到右遍历。当前位置既能通过 往下 也能 往右 移动，即有 dp[i][j] = Math.min(dp[i][j-1],dp[i-1][j]) + grid[i][j]当前位置只能通过 往下 移动而来，即有 dp[i][j] = dp[i-1][j] + grid[i][j]dp 初始化即可，不需要修改初始 0 值。

对于当前位置 i，如果之前的位置 j 能够跳到位置 i 需要满足：位置 j加上位置 j 所能跳到的最远长度要大于等于 i，即 j + nums[j] >= i。而跳到下标 i 所需要的最小跳跃次数则等于满足上述要求的位置 j 中最小跳跃次数加 1，即 dp[i] = Math.min(dp[i], dp[j] + 1)。从递归公式dp[i] = Math.min(dp[i], dp[j] + 1)中可以看出，遍历的顺序一定是从前到后遍历的。有点贪心的含义，因为题目给了总是可以到达数组的最后一个位置。

从递归公式dp[i]=Math.max(dp[i−1],nums[i]+i)中可以看出，dp[i]是依赖 dp[i - 1] ，那么遍历的顺序一定是从前到后遍历的。由递推公式可知dp[i]=Math.max(dp[i−1],nums[i]+i)，我们依赖于前一个数，那么我们要初始化dp[0] = nums[0];i每次移动只能在cover的范围内移动，每移动一个元素，cover得到该元素数值（新的覆盖范围）的补充，让i继续移动下去。dp[i]：从[0,i]的任意一点处出发，你最大可以跳跃到的位置。

在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。首先定义 一个HashMap，key放a和b两数之和，value 放a和b两数之和出现的次数。定义int变量count，用来统计 a+b+c+d = 0 出现的次数。遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。最后返回统计值 count 就可以了。4个for循环，会出现超时情况。

首先需要一个字符串builder来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。当剩下的)比(多时，才可以选)，否则，)不能选，选了就非法。因为：剩下的)比(少，即，使用的)比(多，不能成双成对。如果builder字符长度等于n*2，得到最终结果，把它放进result里面。只要(有剩，就可以选(。(((((这么选，都还不能判定为非法。总结一句话:剩下的)比(多时，才可以选)，相等的话也只能选(这道题的思路:就是不停选括号，要么选左括号，要么选右括号。

从递归公式dp[i] = dp[i - 1] + dp[i - 2] + dp[i-3];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2] 和 dp[i - 3]，那么遍历的顺序一定是从前到后遍历的。按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2] + dp[i-3];状态转移方程 dp[i] = dp[i-1] + dp[i-2] + dp[i-3];dp[i]的定义为：第i个数的泰波那契数值是dp[i]

思路分析 题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，如果重复出现就代表陷入死循环。使用哈希法，来判断这个sum是否重复出现，如果重复了就结束循环，判断n==1