LeetCode Hot 100
LeetCode Hot 100 link
198. 打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：
偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：
偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
提示：
1 <= nums.length <= 100
0 <= nums[i] <= 400
典型的动态规划
class Solution {
//dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1])
class Solution {
public int rob(int[] nums) {
int[] dp = new int[nums.length];
dp[0] = nums[0];
if(nums.length == 1) return dp[0];
dp[1] = Math.max(nums[0], nums[1]);
for(int i = 2; i<nums.length; i++)
dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
return dp[nums.length-1];
}
}
// dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 3] + nums[i-1]);
public int rob1(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
int length = nums.length;
if (length == 1) {
return nums[0];
}
int[] dp = new int[length];
dp[0] = nums[0];
dp[1] = Math.max(nums[0], nums[1]);
if(length == 2) return dp[1];
dp[2] = Math.max(nums[0]+nums[2], nums[1]);
for (int i = 3; i < length; i++) {
dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 3] + nums[i-1]);
}
return dp[length - 1];
}
}
打家劫舍 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 = [1,2,3]
输出：3
提示：
1 <= nums.length <= 100
0 <= nums[i] <= 1000
class Solution {
private int[] numsI;
public int rob(int[] nums) {
if(nums.length == 1) return nums[0];
numsI = nums;
return Math.max(rob(0, nums.length-2), rob(1, nums.length-1));
}
public int rob(int start, int end){
if(start==end) return numsI[start];
int[] dp = new int[end-start+1];
dp[0] = numsI[start];
dp[1] = Math.max(numsI[start], numsI[start+1]);
for(int i = 2; i < end-start+1; i++){
dp[i] = Math.max(dp[i-2] + numsI[start + i], dp[i-1]);
}
return dp[end-start];
}
}
打家劫舍 III
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。
给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
示例 1:
输入:root = [3,2,3,null,3,null,1]
输出:7
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7
示例 2:
输入:root = [3,4,5,1,3,null,1]
输出:9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9
提示：
树的节点数在 [1, 104] 范围内
0 <= Node.val <= 10^4
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] status = dfs(root);
return Math.max(status[0], status[1]);
}
private int[] dfs(TreeNode node){
if(node == null) return new int[]{0,0};
//用二维数组l表示左节点两种情况下的子树的最大值: l[0]表示左子节点被选择时的该子节点下的子树的最大值, l[1]表示左子节点不选择时的该子节点下的子树的最大值
int[] l = dfs(node.left);
//用二维数组r表示左节点两种情况下的子树的最大值: r[0]表示左子节点被选择时的该子节点下的子树的最大值, r[1]表示左子节点不选择时的该子节点下的子树的最大值
int[] r = dfs(node.right);
//当前节点选择，则当前节点的左右子节点皆不可选， 因此当前子节点下的子树最大值为本子节点值 + 左子节点不选的值l[1] + 右子节点不选的值r[1]
int selected = node.val + l[1] + r[1];
//当前节点不选择，则当前节点的左右子节点可选可不选， 因此当前子节点下的最大值 = Math.max(左子节点选择时左子树的最大值l[0], 左子节点不选择时左子树的最大值l[1]) + Math.max(右子节点选择时右子树的最大值r[0], 右子节点不选择时右子树的最大值r[1])
int notSelected = Math.max(l[0], l[1]) + Math.max(r[0], r[1]);
return new int[]{selected, notSelected};
}
}
买卖股票的最佳时机
给定一个数组
prices，它的第i个元素prices[i]表示一支给定股票第i天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第2天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
提示：
1 <= prices.length <= 105
0 <= prices[i] <= 104
我们来假设自己来购买股票。随着时间的推移，每天我们都可以选择出售股票与否。那么，假设在第
i天，如果我们要在今天卖股票，那么我们能赚多少钱呢？显然，如果我们真的在买卖股票，我们肯定会想：如果我是在历史最低点买的股票就好了！太好了，在题目中，我们只要用一个变量记录一个历史最低价格minprice，我们就可以假设自己的股票是在那天买的。那么我们在第 i 天卖出股票能得到的利润就是prices[i] - minprice。因此，我们只需要遍历价格数组一遍，记录历史最低点，然后在每一天考虑这么一个问题：如果我是在历史最低点买进的，那么我今天卖出能赚多少钱？当考虑完所有天数之时，我们就得到了最好的答案.
class Solution {
public int maxProfit(int[] prices) {
int minPrice=prices[0];
int maxProfit = 0;
for(int p: prices){
maxProfit = Math.max(maxProfit, p-minPrice);
minPrice = Math.min(minPrice, p);
}
return maxProfit;
}
}
买卖股票的最佳时机 II
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。
示例 2：
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
总利润为 4 。
示例 3：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。
提示：
1 <= prices.length <= 3 * 10^4
0 <= prices[i] <= 10^4
简单贪心，假设今天买明天卖能赚就执行操作
官方题解讲得不错
public int maxProfit(int[] prices) {
int profit = 0;
int left = 0, right = 0;
while (right < prices.length) {
if (prices[right] > prices[left]) {
profit += prices[right] - prices[left];
}
left = right;
right++;
}
return profit;
}
买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2：
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。
示例 4：
输入：prices = [1]
输出：0
提示：
1 <= prices.length <= 10^5
0 <= prices[i] <= 10^5
买卖股票的最佳时机 IV
给定一个整数数组
prices，它的第i个元素prices[i]是一支给定的股票在第i天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：
输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
提示：
0 <= k <= 100
0 <= prices.length <= 1000
0 <= prices[i] <= 1000
最佳买卖股票时机含冷冻期
给定一个整数数组
prices，其中第prices[i]表示第i天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入:prices = [1,2,3,0,2]
输出:3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
示例 2:
输入:prices = [1]
输出: 0
提示：
1 <= prices.length <= 5000
0 <= prices[i] <= 1000
买卖股票的最佳时机含手续费
给定一个整数数组
prices，其中prices[i]表示第i天的股票价格 ；整数fee代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
示例 1：
输入：prices = [1, 3, 2, 8, 4, 9],fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入prices[0] = 1
在此处卖出prices[3] = 8
在此处买入prices[4] = 4
在此处卖出prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
示例 2：
输入：prices = [1,3,7,5,10,3],fee = 3
输出：6
提示：
1 <= prices.length <= 5 * 104
1 <= prices[i] < 5 * 104
0 <= fee < 5 * 104
寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1：
输入：nums1 = [1,3],nums2 = [2]
输出：2.00000
解释：合并数组 =[1,2,3]，中位数 2
示例 2：
输入：nums1 = [1,2],nums2 = [3,4]
输出：2.50000
解释：合并数组 =[1,2,3,4]，中位数(2 + 3) / 2 = 2.5
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 10^6
2. 两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
// 注意前导0即可
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode head = new ListNode(0);
ListNode cur = head;
int incr = 0;
while(l1 != null || l2 != null){
int x = l1 == null ? 0 : l1.val;
int y = l2 == null ? 0 : l2.val;
int tmp = x + y + incr;
ListNode tmpNode = new ListNode(tmp % 10);
incr = tmp / 10;
cur.next = tmpNode;
cur = tmpNode;
if(l1!=null) l1 = l1.next;
if(l2!=null) l2 = l2.next;
}
if(incr > 0){
cur.next = new ListNode(1);
}
return head.next;
}
}
无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
提示：
0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成
- 解法1
class Solution {
public int lengthOfLongestSubstring(String s) {
//map保存遍历过程中每个元素出现的最大(右边)的位置
Map<Character, Integer> record = new HashMap<>();
int left = 0;
int max = 0;
for(int idx = 0; idx < s.length(); idx++){
char c = s.charAt(idx);
if(record.containsKey(c)){
//如果当前的元素在之前碰到过，把统计的左边界挪到之前重复元素的位置往后一位(但不回退)
left = Math.max(record.get(c)+1, left);
}
//idx-left+1是以当前元素为右边界的有效不重复区间。
max = Math.max(max, idx - left + 1);
record.put(c, idx);
}
return max;
}
}
- 解法2
用set记录，碰到重复的元素，就把前面的都删掉
class Solution {
public int lengthOfLongestSubstring(String s) {
Set<Character> dups = new HashSet<>();
List<Character> windows = new ArrayList<>();
int res = 0;
for(int i = 0; i < s.length(); i++){
Character tmp = s.charAt(i);
if(dups.add(tmp)){
windows.add(tmp);
}else{
res = Math.max(res, dups.size());
int j = windows.indexOf(tmp);
for(int k = 0; k <= j; k++){
dups.remove(windows.get(0));
windows.remove(0);
}
windows.add(tmp);
dups.add(tmp);
}
}
res = Math.max(res, dups.size());
return res;
}
}
最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
提示：
1 <= s.length <= 1000
s 仅由数字和英文字母组成
- dp
//dp
// cabac 可以从 aba转移而来
public String dp(String s){
int len = s.length();
if(len < 2) return s;
int start = 0;
int max = 1;
boolean[][] dp = new boolean[len][len];
for(int i = 0; i < len; i++){
dp[i][i] = true;
}
//枚举每种长度类型的字符串
for(int l = 2; l <= len; l++){
//从每个左边界开始看长度为l的字符串是不是回文，这个可以通过前序记录的结果转移过来
//因为在之前的循环中计算过每个位置为左边界且长度为l-1的字符串是不是回文，而当前位置i
//为左边界，长度为l是否未回文，可以由 i+1为左边界，长度为l-1的状态转移而来
for(int j = 0; j < len; j++){
int r = j + l -1;
if(r >= len){
break;
}
if(s.charAt(j) != s.charAt(r)){
dp[j][r] = false;
}else{
if(l == 2){
dp[j][r] = true;
}else{
dp[j][r] = dp[j+1][r-1];
}
}
if(dp[j][r] & l > max){
start = j;
max = l;
}
}
}
return s.substring(start, start + max);
}
- 中心扩展
class Solution {
public String longestPalindrome(String s) {
int len = s.length();
if(len < 2) return s;
int start = 0, end = 0;
for(int i = 0; i < len; i++){
int len1 = expandLength(s, i, i);
if(len1 >= end - start + 1){
start = i - len1 / 2;
end = i + len1 / 2;
}
int len2 = expandLength(s, i, i+1);
if(len2 >= end - start + 1){
start = i - (len2-1) / 2;
end = i + 1 + (len2-1) / 2;
}
}
return s.substring(start, end+1);
}
private int expandLength(String s, int left, int right){
while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
--left;
++right;
}
return right - left - 1;
}
}
`
