994. 腐烂的橘子
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。
示例 1：
**输入：**grid = [[2,1,1],[1,1,0],[0,1,1]]
**输出：**4
示例 2：
**输入：**grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
**解释：**左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。
示例 3：
**输入：**grid = [[0,2]]
**输出：**0
**解释：**因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 10
grid[i][j] 仅为 0、1 或 2
与找岛屿过程类似，从腐烂的橘子出发，向四周扩散，即BFS
注意 ...
739. 每日温度
给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 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
对于每个位置寻找向右看到的第一个大于自身的值，很容易想到最右边的没有，所以直接填0
可以考虑倒着看，如果自身比后面的元素大，那很明显后面的元素为无效元素
这种左边大的元素能覆盖右边小元素，想到使用单调栈记录下标，每次遇到左边大元素时把栈内小元素弹出即可
123456789 ...
560. 和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。
子数组是数组中元素的连续非空序列。
示例 1：
**输入：**nums = [1,1,1], k = 2
**输出：**2
示例 2：
**输入：**nums = [1,2,3], k = 3
**输出：**2
提示：
1 <= nums.length <= 2 * 10(4)
-1000 <= nums[i] <= 1000
-10(7) <= k <= 10(7)
暴力解法是遍历数组做第一个元素，再遍历后续元素分别做最后一个元素
在此基础上可以考虑用前缀和数组进行优化，求和时只需sum[i]-sum[j]=k
将上述式子移项有，sum[i]-k=sum[j]
也就是说当第i个元素做最后一项时，前面的项只要前缀和为sum[i]-k就可以作为第一个元素
所以我们可以遍历数组，分别做最后一个元素，
然后求前缀和，加上满足条件的前缀和出现的次数，再更新前缀和频率
12345678910111213141516class Solution {pub ...
543. 二叉树的直径
给你一棵二叉树的根节点，返回该树的 直径 。
二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。
两节点之间路径的 长度 由它们之间边数表示。
示例 1：
**输入：**root = [1,2,3,4,5]
**输出：**3
**解释：**3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2：
**输入：**root = [1,2]
**输出：**1
提示：
树中节点数目在范围 [1, 10(4)] 内
-100 <= Node.val <= 100
求得直径所经过的路径一定有一个根节点，
所以题目就变成了寻找一个根节点，他的左右子树深度相加最大
需要一个全局变量，在递归求深度的过程中记录最大的左右子树深度和
123456789101112131415161718class Solution {public: int ans = 0; int diameterOfBinaryTree(TreeNode *root) { if (root == n ...
438. 找到字符串中所有字母异位词
给定两个字符串 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 仅包含小写字母
因为s，p仅包含小写字母所以我们可以用一个定长数组来记录各字母出现次数
维护一个定长滑动窗口，每次移动都与频次数组比较即可
123456789101112131415161718192021222324252627 ...
347. 前 K 个高频元素
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1：
**输入：**nums = [1,1,1,2,2,3], k = 2
输出：[1,2]
示例 2：
**输入：**nums = [1], k = 1
输出：[1]
示例 3：
**输入：**nums = [1,2,1,2,1,2,3,1,3,2], k = 2
输出：[1,2]
提示：
1 <= nums.length <= 10(5)
-10(4) <= nums[i] <= 10(4)
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的
**进阶：**你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
统计出出现频次后与找topK类似，可使用小顶堆或快速排序的思路
123456789101112131415161718192021222324252627282930313233343536373839404142class S ...