🔥 LeetCode 热题 HOT 100（71-80）
253. 会议室 II(NO)
279. 完全平方数
class Solution {
public int numSquares(int n) {
// dp[i] : 组成和为 i 的最少完全平方数个数
// base case: dp[0] = 0;
int[] dp = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
// 最大值即为i
dp[i] = i;
// 转移方程
for (int j = 1; i - j*j >= 0; j++) {
dp[i] = Math.min(dp[i], dp[i - j*j] + 1);
}
}
return dp[n];
}
}
推荐题解：画解算法：279. 完全平方数
283. 移动零
思路一：双指针，i 指向 非0 元素的下一个待插入位置，j 遍历数组，每次遇到 非0 元素就插入 i 指向的位置并一起向后移动，最后将 i 及其后面全部补0即可。
class Solution {
public void moveZeroes(int[] nums) {
int len = nums.length;
int i = 0; // i 指向 非0 元素的下一个待插入位置
// j 一直向后遍历，每次遇到 非0 元素就插入i指向的位置并一起向后移动
for (int j = 0; j < len; j++) {
if (nums[j] != 0) {
nums[i++] = nums[j];
}
}
// i 及其后面全部补0即可
for ( ; i < len; i++) {
nums[i] = 0;
}
}
}
思路二：双指针，i 指向 非0 元素的下一个待插入位置，j 遍历数组，每次遇到 非0 元素就与 i 指向元素交换并一起向后移动，最后 [0, i) 之前全部为非0元素，(i, j)之间全部为 0。
class Solution {
public void moveZeroes(int[] nums) {
int len = nums.length;
int i = 0; // i 指向 非0 元素的下一个待插入位置
// 每次遇到 非0 元素就与 i 指向元素交换并一起向后移动
for (int j = 0; j < len; j++) {
if (nums[j] != 0) {
swap(nums, i, j);
i++;
}
}
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
287. 寻找重复数
该题最简单的思路便是使用set，但题目要求空间复杂度为O(1)。另外一种简单思路是使用排序，然后检查重复数即可，但题目又要求时间复杂度为O(nlogn)，且不能修改原数组。面试时我们应该询问面试官 时间 和 空间复杂度 要求之后再确定具体使用的方法。
思路一：快慢指针，建议先刷：141. 环形链表、142. 环形链表 II。
推荐题解：287.寻找重复数
class Solution {
public int findDuplicate(int[] nums) {
int slow = 0;
int fast = nums[slow];
while (slow != fast) {
fast = nums[nums[fast]];
slow = nums[slow];
}
fast = nums[slow];
slow = 0;
while (slow != fast) {
fast = nums[fast];
slow = nums[slow];
}
return slow;
}
}
思路二：将所有元素放置在其值减1的下标位置。如：1 应该放置在 0 位置，3 应该放置在 2 位置，这样，重复的元素至少有一个无法放置在对应位置。思路来自：剑指 Offer 03. 数组中重复的数字
class Solution {
public int findDuplicate(int[] nums) {
int len = nums.length;
for (int i = 0; i < len - 1; i++) {
// 如果元素的 值 和 下标 不匹配，则将其交换至对的位置
while ((nums[i] - 1) != i) {
// 如果发现待交换的两个元素相同则直接返回 如：[3,1,3,4,2]
if (nums[i] == nums[nums[i] - 1]) {
return nums[i];
}
swap(nums, i, nums[i] - 1);
}
}
// 通常，最后一个元素为重复元素
return nums[len - 1];
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
备注：该方法修改了原来的数组。时间复杂度为O(n)，因为每个元素至多交换一次，空间复杂度为O(1)。
297. 二叉树的序列化与反序列化
思路一：使用先序遍历进行序列化（dfs）
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Codec {
// Encodes a tree to a single string.
public String serialize(TreeNode root) {
if (root == null) {
return "#";
}
String leftSerial = serialize(root.left);
String rightSerial = serialize(root.right);
return root.val + "," + leftSerial + "," + rightSerial;
}
// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
String[] strs = data.split(",");
Deque<String> queue = new LinkedList<>();
for (String str : strs) {
queue.offer(str);
}
return deserialize(queue);
}
private TreeNode deserialize(Deque<String> queue) {
String rootVal = queue.poll();
if (rootVal.equals("#")) {
return null;
}
TreeNode root = new TreeNode(Integer.parseInt(rootVal));
root.left = deserialize(queue);
root.right = deserialize(queue);
return root;
}
}
// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));
思路二：使用层次遍历进行序列化（bfs）
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Codec {
// Encodes a tree to a single string.
public String serialize(TreeNode root) {
Deque<TreeNode> queue = new LinkedList<>();
StringBuilder sb = new StringBuilder();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode temp = queue.poll();
if (temp != null) {
sb.append(temp.val).append(",");
queue.offer(temp.left);
queue.offer(temp.right);
} else {
sb.append("#").append(",");
}
}
System.out.println(sb.toString());
return sb.toString();
}
// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
String[] strs = data.split(",");
Deque<TreeNode> queue = new LinkedList<>();
int i = 0;
if (strs[i].equals("#")) return null;
TreeNode root = new TreeNode(Integer.parseInt(strs[i++]));
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode temp = queue.poll();
String leftVal = strs[i++];
String rightVal = strs[i++];
if (!leftVal.equals("#")) {
TreeNode leftChild = new TreeNode(Integer.parseInt(leftVal));
temp.left = leftChild;
queue.offer(leftChild);
}
if (!rightVal.equals("#")) {
TreeNode rightChild = new TreeNode(Integer.parseInt(rightVal));
temp.right = rightChild;
queue.offer(rightChild);
}
}
return root;
}
}
// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));
推荐题解：『手画图解』剖析DFS、BFS解法 | 二叉树的序列化与反序列化
300. 最长递增子序列
思路：动态规划
状态：以当前字符结尾的字符串中最长递增子序列的长度
转移方程：dp[i] = max(dp[j] + 1, dp[i])，其中 j < i 且 nums[j] < nums[i]
base case：dp[i] = 1
class Solution {
public int lengthOfLIS(int[] nums) {
int len = nums.length;
// dp[i] 表示以当前字符结尾的字符串中最长递增子序列的长度
int[] dp = new int[len];
int maxLen = 0;
for (int i = 0; i < len; i++) {
//base case
dp[i] = 1;
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
maxLen = Math.max(maxLen, dp[i]);
}
return maxLen;
}
}
301. 删除无效的括号
思路：回溯法
class Solution {
public List<String> removeInvalidParentheses(String s) {
// 左括号和右括号最少需要移除的个数
int leftRemove = 0, rightRemove = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(') {
leftRemove++;
} else if (s.charAt(i) == ')') {
//存在左括号则消去一个
if (leftRemove > 0) {
leftRemove--;
} else if (leftRemove == 0) {
rightRemove++;
}
}
}
StringBuilder track = new StringBuilder();
dfs(s, 0, track, 0, 0, leftRemove, rightRemove);
return new ArrayList<>(res);
}
private Set<String> res = new HashSet<>();
private void dfs(String s, int index, StringBuilder track, int leftCnt, int rightCnt, int leftRemove, int rightRemove) {
if (s.length() == index) {
if (leftRemove == 0 && rightRemove == 0) {
res.add(track.toString());
}
return;
}
char ch = s.charAt(index);
// 选择1：删除当前字符
if (ch == '(' && leftRemove > 0) {
dfs(s, index + 1, track, leftCnt, rightCnt, leftRemove - 1, rightRemove);
} else if (ch == ')' && rightRemove > 0) {
dfs(s, index + 1, track, leftCnt, rightCnt, leftRemove, rightRemove - 1);
}
// 选择2：保留当前字符
track.append(ch);
if (ch == '(' ) {
dfs(s, index + 1, track, leftCnt + 1, rightCnt, leftRemove, rightRemove);
} else if (ch == ')' && leftCnt > rightCnt) {
dfs(s, index + 1, track, leftCnt, rightCnt + 1, leftRemove, rightRemove);
} else if (ch != '(' && ch != ')') {
dfs(s, index + 1, track, leftCnt, rightCnt, leftRemove, rightRemove);
}
track.deleteCharAt(track.length() - 1);
}
}
推荐题解：删除无效的括号
309. 最佳买卖股票时机含冷冻期
思路：动态规划
class Solution {
public int maxProfit(int[] prices) {
int len = prices.length;
int[][] dp = new int[len][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for (int i = 1; i < len; i++) {
dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
dp[i][1] = Math.max(dp[i - 1][1], (i >= 2 ? dp[i - 2][0] : 0) - prices[i]);
}
return dp[len - 1][0];
}
}
312. 戳气球
思路：动态规划。推荐题解：[这个菜谱, 自己在家也能做] 关键思路解释
class Solution {
public int maxCoins(int[] nums) {
int len = nums.length;
// 前后两位各插入1
int[] newNums = new int[len + 2];
newNums[0] = 1;
newNums[len + 1] = 1;
for (int i = 0; i < len; i++) {
newNums[i + 1] = nums[i];
}
//dp[i][j] 代表 戳爆开区间 (i, j) 中的气球所能取得的最大值
//默认值都为0，base case: dp[i][j] = 0, j - i < 3
int[][] dp = new int[len + 2][len + 2];
for (int size = 3; size <= len + 2; size++) {
//开区间起始位置
for (int start = 0; start <= len + 2 - size; start++) {
int max = 0;
//列举最后一个被戳爆的气球为 newNums[k]的所有情况, K属于[start + 1, start + size - 1)，找到最大值
for (int k = start + 1; k < start + size - 1; k++) {
max = Math.max(max, dp[start][k] + dp[k][start + size - 1] + newNums[start] * newNums[k] * newNums[start + size - 1]);
}
dp[start][start + size - 1] = max;
}
}
return dp[0][len + 1];
}
}
322. 零钱兑换
思路：动态规划。
class Solution {
public int coinChange(int[] coins, int amount) {
//状态：dp[i] 表示凑够i需要的最少硬币数
int[] dp = new int[amount + 1];
//求最小值，先初始为足够大。(若能凑成，最多需要amount枚硬币)
Arrays.fill(dp, amount + 1);
//base case
dp[0] = 0;
for (int i = 1; i <= amount; i++) {
for (int j = 0; j < coins.length; j++) {
//当前背包（总金额）若能装下物品（硬币面额）
if (i >= coins[j]) {
dp[i] = Math.min(dp[i - coins[j]] + 1, dp[i]);
}
}
}
return dp[amount] >= amount + 1 ? -1 : dp[amount];
}
}
