「这是我参与2022首次更文挑战的第15天，活动详情查看：2022首次更文挑战」。
LeetCode习题集 有些题可能直接略过了，整理一下之前刷leetcode
691. 贴纸拼词
我们给出了 N 种不同类型的贴纸。每个贴纸上都有一个小写的英文单词。
你希望从自己的贴纸集合中裁剪单个字母并重新排列它们，从而拼写出给定的目标字符串 target。
如果你愿意的话，你可以不止一次地使用每一张贴纸，而且每一张贴纸的数量都是无限的。
拼出目标 target 所需的最小贴纸数量是多少？如果任务不可能，则返回 -1。
示例 1：
输入：
["with", "example", "science"], "thehat" 输出：
3 解释：
我们可以使用 2 个 "with" 贴纸，和 1 个 "example" 贴纸。 把贴纸上的字母剪下来并重新排列后，就可以形成目标 “thehat“ 了。 此外，这是形成目标字符串所需的最小贴纸数量。 示例 2：
输入：
["notice", "possible"], "basicbasic" 输出：
-1 解释：
我们不能通过剪切给定贴纸的字母来形成目标“basicbasic”。
提示：
stickers 长度范围是 [1, 50]。 stickers 由小写英文单词组成（不带撇号）。 target 的长度在 [1, 15] 范围内，由小写字母组成。 在所有的测试案例中，所有的单词都是从 1000 个最常见的美国英语单词中随机选取的，目标是两个随机单词的串联。 时间限制可能比平时更具挑战性。预计 50 个贴纸的测试案例平均可在35ms内解决。
PS:
先计算每一张贴纸含有的字符数量
递归目标字符串，
如果有字符串能构成目标字符串的某个字符，就使用这个字符串
然后记录还差的字符，凑成字符串递归给下一个
返回回来取最小的（以前最小的贴纸数，或者当前贴纸数+1）
class Solution {
public int minStickers(String[] stickers, String target) {
int m = stickers.length;
int[][] mp = new int[m][26];
Map<String, Integer> dp = new HashMap<>();
for (int i = 0; i < m; i++)
for (char c : stickers[i].toCharArray()) mp[i][c - 'a']++;
dp.put("", 0);
return helper(dp, mp, target);
}
private int helper(Map<String, Integer> dp, int[][] mp, String target) {
if (dp.containsKey(target)) return dp.get(target);
int ans = Integer.MAX_VALUE, n = mp.length;
int[] tar = new int[26];
for (char c : target.toCharArray()) tar[c - 'a']++;
for (int i = 0; i < n; i++) {
if (mp[i][target.charAt(0) - 'a'] == 0) continue;
StringBuilder sb = new StringBuilder();
for (int j = 0; j < 26; j++) {
if (tar[j] > 0)
for (int k = 0; k < Math.max(0, tar[j] - mp[i][j]); k++)
sb.append((char) ('a' + j));
}
String s = sb.toString();
int tmp = helper(dp, mp, s);
if (tmp != -1) ans = Math.min(ans, 1 + tmp);
}
dp.put(target, ans == Integer.MAX_VALUE ? -1 : ans);
return dp.get(target);
}
}
692. 前K个高频单词
给一非空的单词列表，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序。
示例 1：
输入: ["i", "love", "leetcode", "i", "love", "coding"], k = 2 输出: ["i", "love"] 解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。 注意，按字母顺序 "i" 在 "love" 之前。
示例 2：
输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4 输出: ["the", "is", "sunny", "day"] 解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词， 出现次数依次为 4, 3, 2 和 1 次。
注意：
假定 k 总为有效值， 1 ≤ k ≤ 集合元素数。 输入的单词均由小写字母组成。
扩展练习：
尝试以 O(n log k) 时间复杂度和 O(n) 空间复杂度解决。
PS:
先序队列放字符串，按照字符串的出现次数，以及字典序排列
然后把所有不重复单词都放进先序队列，因为只要前k个，如果先序队列元素数量大于k，直接把出现次数最小的弹出去
因为先序队列是按照升序走的，我们返回的时候要反转一下字符串
class Solution {
public List<String> topKFrequent(String[] words, int k) {
HashMap<String,Integer>count = new HashMap<>();
for(String word:words){
count.put(word,count.getOrDefault(word,0)+1);
}
PriorityQueue<String>heap = new PriorityQueue<String>((w1,w2)->count.get(w1).equals(count.get(w2))?w2.compareTo(w1):count.get(w1)-count.get(w2));
for(String word:count.keySet()){
heap.add(word);
if(heap.size()>k)heap.poll();
}
List<String>res = new LinkedList<>();
while(!heap.isEmpty())res.add(heap.poll());
Collections.reverse(res);
return res;
}
}
693. 交替位二进制数
给定一个正整数，检查他是否为交替位二进制数：换句话说，就是他的二进制数相邻的两个位数永不相等。
示例 1:
输入: 5 输出: True 解释: 5的二进制数是: 101 示例 2:
输入: 7 输出: False 解释: 7的二进制数是: 111 示例 3:
输入: 11 输出: False 解释: 11的二进制数是: 1011 示例 4:
输入: 10 输出: True 解释: 10的二进制数是: 1010
PS:
用一个变量保存二进制中上一位的值
n&1 是判断 n 二进制情况下最后一位是 1 还是 0
如果pre和 当前二进制最后一位相等，返回false
如果循环完了，没有返回false ，就是返回true
class Solution {
public boolean hasAlternatingBits(int n) {
boolean res = true;
int pre = -1;
while(n != 0){
if(pre != -1 && pre == (n & 1)){
res = false;
break;
}else{
pre = n & 1;
n = n >> 1;
}
}
return res;
}
}
695. 岛屿的最大面积
给定一个包含了一些 0 和 1 的非空二维数组 grid 。
一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)
示例 1:
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]
对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。
示例 2:
[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。
注意: 给定的矩阵grid 的长度和宽度都不超过 50。
PS:
经典DFS
如果当前位置是土地，就把当前位置递归，四个方向找土地，返回找到的最大的土地的面积
四个方向找土地的时候，用 1 + 四个方向的土地
class Solution {
public int maxAreaOfIsland(int[][] grid) {
int ans = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) ans = Math.max(ans, dfs(i, j, grid));
}
}
return ans;
}
int dfs(int x, int y, int[][] grid) {
if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == 0) return 0;
grid[x][y] = 0;
return 1 + dfs(x + 1, y, grid) + dfs(x - 1, y, grid) + dfs(x, y + 1, grid) + dfs(x, y - 1, grid);
}
}
696. 计数二进制子串
给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。
重复出现的子串要计算它们出现的次数。
示例 1 :
输入: "00110011" 输出: 6 解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。
请注意，一些重复出现的子串要计算它们出现的次数。
另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。 示例 2 :
输入: "10101" 输出: 4 解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。 注意：
s.length 在1到50,000之间。 s 只包含“0”或“1”字符。
class Solution {
public int countBinarySubstrings(String s) {
char[] chars = s.toCharArray();
int res = 0;
int cur = 1;
int pre = 0;
char value = chars[0];
for (int i = 1; i < chars.length; i++) {
//当前位和上一位不等的时候，就可以算作一次
if(value == chars[i])
++cur;
else {
if(pre > 0) {
res += Math.min(pre,cur);
}
pre = cur;
cur = 1;
}
value = chars[i];
}
if(pre > 0) res += Math.min(cur,pre);
return res;
}
}
697. 数组的度
给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。
你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。
示例 1:
输入: [1, 2, 2, 3, 1] 输出: 2 解释: 输入数组的度是2，因为元素1和2的出现频数最大，均为2. 连续子数组里面拥有相同度的有如下所示: [1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2] 最短连续子数组[2, 2]的长度为2，所以返回2. 示例 2:
输入: [1,2,2,3,1,4,2] 输出: 6 注意:
nums.length 在1到50,000区间范围内。 nums[i] 是一个在0到49,999范围内的整数。
PS：
一个记录最左面的下标，一个记录右面的下标，一个记录这个数字出现的次数
class Solution {
public int findShortestSubArray(int[] nums) {
int max = 0;
for (int num : nums) {
max = Math.max(num, max);
}
int[] leftMap = new int[max + 1];//用于元素最左索引（+1）
int[] rightMap = new int[max + 1];//用于元素最右索引
int[] countMap = new int[max + 1];//用于元素计数
int maxCount = 0;
for (int i = 0; i < nums.length; i++) {
int num = nums[i];
if (leftMap[num] == 0) {
leftMap[num] = i + 1;
}
rightMap[num] = i;
countMap[num]++;
if (countMap[num] > maxCount) {
maxCount = countMap[num];
}
}
int res = nums.length;
for (int num = 0; num < countMap.length; num++) {
int count = countMap[num];
if (count == maxCount) {
int length = rightMap[num] - leftMap[num] + 2;
if (length < res) {
res = length;
}
}
}
return res;
}
}
698. 划分为k个相等的子集
给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
示例 1：
输入： nums = [4, 3, 2, 3, 5, 2, 1], k = 4 输出： True 说明： 有可能将其分成 4 个子集（5），（1,4），（2,3），（2,3）等于总和。
注意:
1 <= k <= len(nums) <= 16 0 < nums[i] < 10000
PS:
分成 k 个相等的子集，每个子集的值要想等，也就是总和一定是 K 的倍数
把 arr 填充上 sum / k ，然后以最后数组内的值为0，作为结束
深搜：
cur是操作nums的cur下标的数（cur 从末尾开始）
循环每一个arr（i -> k）
如果当前arr的值等于nums[cur] 或者说 比nums[cur]大于等于nums[0] （如果比nums[cur]大的话，一定要大于数组内的最小值，否则是无法凑成的）
如果符合条件，就把 arr 减去 nums[cur] ,然后递归调用 cur - 1
等递归调用回来，再把arr复原，加上nums[cur]
class Solution {
int K = 0, N = 0;
public boolean canPartitionKSubsets(int[] nums, int k) {
int n = nums.length, sum = 0, eachSum = 0;
if (n == 0 || k == 0)
return false;
N = n;
K = k;
int[] arr = new int[k];
for (int i : nums)
sum += i;
if (sum % k != 0)
return false;
eachSum = sum / k;
Arrays.fill(arr, eachSum);
Arrays.sort(nums);
return helper(nums, n-1, arr);
}
boolean helper(int[] nums, int cur, int[] arr) {
if (cur < 0)
return true;
int temp = nums[cur];
for (int i = 0; i < K; i++) {
if (arr[i] == temp || (cur > 0 && arr[i] - temp >= nums[0])) {
arr[i] -= temp;
if (helper(nums, cur - 1, arr)) {
return true;
}
arr[i] += temp;
}
}
return false;
}
}
699. 掉落的方块
在无限长的数轴（即 x 轴）上，我们根据给定的顺序放置对应的正方形方块。
第 i 个掉落的方块（positions[i] = (left, side_length)）是正方形，其中 left 表示该方块最左边的点位置(positions[i][0])，side_length 表示该方块的边长(positions[i][1])。
每个方块的底部边缘平行于数轴（即 x 轴），并且从一个比目前所有的落地方块更高的高度掉落而下。在上一个方块结束掉落，并保持静止后，才开始掉落新方块。
方块的底边具有非常大的粘性，并将保持固定在它们所接触的任何长度表面上（无论是数轴还是其他方块）。邻接掉落的边不会过早地粘合在一起，因为只有底边才具有粘性。
返回一个堆叠高度列表 ans 。每一个堆叠高度 ans[i] 表示在通过 positions[0], positions[1], ..., positions[i] 表示的方块掉落结束后，目前所有已经落稳的方块堆叠的最高高度。
示例 1:
输入: [[1, 2], [2, 3], [6, 1]]
输出: [2, 5, 5]
解释:
第一个方块 positions[0] = [1, 2] 掉落：
_aa
_aa
-------
方块最大高度为 2 。
第二个方块 positions[1] = [2, 3] 掉落：
__aaa
__aaa
__aaa
_aa__
_aa__
--------------
方块最大高度为5。
大的方块保持在较小的方块的顶部，不论它的重心在哪里，因为方块的底部边缘有非常大的粘性。
第三个方块 positions[1] = [6, 1] 掉落：
__aaa
__aaa
__aaa
_aa
_aa___a
--------------
方块最大高度为5。
因此，我们返回结果[2, 5, 5]。
示例 2:
输入: [[100, 100], [200, 100]]
输出: [100, 100]
解释: 相邻的方块不会过早地卡住，只有它们的底部边缘才能粘在表面上。
注意:
1 <= positions.length <= 1000. 1 <= positions[i][0] <= 10^8. 1 <= positions[i][1] <= 10^6.
PS：
按照左端点放进树
import java.util.*;
class Solution {
// 描述方块以及高度
private class Node {
int l, r, h, maxR;
Node left, right;
public Node(int l, int r, int h, int maxR) {
this.l = l;
this.r = r;
this.h = h;
this.maxR = maxR;
this.left = null;
this.right = null;
}
}
//
public List<Integer> fallingSquares(int[][] positions) {
// 创建返回值
List<Integer> res = new ArrayList<>();
// 根节点，默认为零
Node root = null;
// 目前最高的高度
int maxH = 0;
for (int[] position : positions) {
int l = position[0]; // 左横坐标
int r = position[0] + position[1]; // 右横坐标
int e = position[1]; // 边长
int curH = query(root, l, r); // 目前区间的最高的高度
root = insert(root, l, r, curH + e);
maxH = Math.max(maxH, curH + e);
res.add(maxH);
}
return res;
}
private Node insert(Node root, int l, int r, int h) {
if (root == null) return new Node(l, r, h, r);
if (l <= root.l)
root.left = insert(root.left, l, r, h);
else
root.right = insert(root.right, l, r, h);
// 最终目标是仅仅需要根节点更新 maxR
root.maxR = Math.max(r, root.maxR);
return root; // 返回根节点
}
private int query(Node root, int l, int r) {
// 新节点的左边界大于等于目前的maxR的话，直接得到0，不需要遍历了
if (root == null || l >= root.maxR) return 0;
// 高度
int curH = 0;
if (!(r <= root.l || root.r <= l)) // 是否跟这个节点相交
curH = root.h;
// 剪枝
curH = Math.max(curH, query(root.left, l, r));
if (r > root.l)
curH = Math.max(curH, query(root.right, l, r));
return curH;
}
}
700. 二叉搜索树中的搜索
给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
例如，
给定二叉搜索树:
4
/ \
2 7
/ \
1 3
和值: 2 你应该返回如下子树:
2
/ \
1 3
在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。
PS:
遍历树
二叉搜索树的特点，左结点值 < 根结点值 < 右结点值
如果当前结点值和目标值相等，返回当前结点
如果当前结点值小于目标值，则找右子结点
如果当前结点值大于目标值，则找左子节点
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if (root == null) {
return null;
}
if (root.val == val) {
return root;
}
if (val > root.val) {
return searchBST(root.right, val);
}
if (val < root.val) {
return searchBST(root.left, val);
}
return null;
}
}
