qq_29821795的博客

解答动态规划class Solution {public: int minDistance(string word1, string word2) { // 获取字符串 word1 的长度 int m = word1.size(); // 获取字符串 word2 的长度 int n = word2.size(); if(m==0||n==0) return max(m,n); // .

解答动态规划#include <vector>#include <iostream>using namespace std;// @lc code=startclass Solution {public: int minPathSum(vector<vector<int>>& grid) { // m 表示有多少行 int m = grid.size(); .

解答动态规划（树形DP）打劫一个树的最大收益，是 robIncludeRoot 和 robExcludeRoot 中的较大者。即每个子树都有两个状态下的最优解：没打劫 root、和有打劫 root 下的最优解。有两个变量共同决定一个状态：1、代表不同子树的 root 节点、2、是否打劫了 root。没打劫根节点，则左右子树的根节点可打劫可不打劫：dp[0] = 左子树的两个状态的较大值 + 右子树的两个状态的较大值。打劫了根节点，则左右子树的根节点不能打劫：dp[1] = root.val.

解答动态规划#include <vector>using namespace std;class Solution {public: int rob(vector<int>& nums) { // 先获取全部房间的总数 int n = nums.size(); // 如果数组为空，表示没有房间，那么自然偷不到东西，直接返回 0 if(n==0) return 0; // 如.

解答动态规划#include <vector>using namespace std;class Solution {public: int rob(vector<int>& nums) { // 先获取全部房间的总数 int n = nums.size(); // 设置一个数组 dp 用来存放前 n 个房间可以偷取的最大金额 // dp[0] 表示前 0 个房间可以偷取的最大金额 .

解答动态规划#include <vector>using namespace std;// @lc code=startclass Solution {public: int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) { // m 行 int m = obstacleGrid.size(); // n 列 .

解答动态规划#include <vector>using namespace std;class Solution {public: int uniquePaths(int m, int n) { // 设置二维数组 dp 用来储存到达每个位置时不同路径的数量 // dp[0][0] 表示从第 0 行第 0 列到达第 0 行第 0 列时不同路径的数量 // dp[0][i] 表示从第 0 行第 0 列到达第 0 行第 i .

解答#include <algorithm>using namespace std;/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode.

解答动态规划第122题的变形，只需要考虑买入股票时减去手续费即可#include <vector>#include <algorithm>using namespace std;class Solution {public: int maxProfit(vector<int>& prices, int fee) { int n = prices.size(); if(n<2) return 0; .

解答动态规划基于122题的变形第 i - 2 天【不持有】股票，第 i 天买入（考虑冷冻期）前天【不持有】股票，今天买入特殊处理：i<2时，不持有股票时的收益为0，所以代码为：i>=2?dp[i-2][0]:0dp[i][1] = max(dp[i-1][1],(i>=2?dp[i-2][0]:0)-prices[i]);#include <vector>#include <algorithm>using namespace std;clas.

解答动态规划#include <vector>#include <algorithm>using namespace std;class Solution {public: int maxProfit(vector<int>& prices) { int n = prices.size(); //先获取数组的长度 if(n==0) return 0; //特殊处理 // 设置一个三维数组 d.

解答动态规划#include <vector>#include <algorithm>using namespace std;class Solution {public: int maxProfit(vector<int>& prices) { int n = prices.size(); if(n<2) return 0; vector<vector<int>&g.

解答一次遍历如果我是在历史最低点买的股票就好了！太好了，在题目中，我们只要用一个变量记录一个历史最低价格 minprice，我们就可以假设自己的股票是在那天买的。那么我们在第 i 天卖出股票能得到的利润就是 prices[i] - minprice。我们只需要遍历价格数组一遍，记录历史最低点，然后在每一天考虑这么一个问题：如果我是在历史最低点买进的，那么我今天卖出能赚多少钱？当考虑完所有天数之时，我们就得到了最好的答案。#include <vector>#include <ma.

解答#include <vector>#include <algorithm>using namespace std;// @lc code=startclass Solution {public: int maxProfit(int k, vector<int>& prices) { int n = prices.size(); //先获取数组的长度 if(n==0) return 0; //特殊处理 .

将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。插入排序也包含两种操作，一种是元素的比较，一种是元素的移动。当我们需要将一个数据 a 插入到已排序区间时，需要拿 a 与已排序区间的元素依次比较大小，找到合适的插入位置。找到插入点之后，我们还需要将插入点之后的元素顺序往后移动一位，这样才能腾出

选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。#include <vector>#include <stdlib.h>using namespace std;class Solution {public: vector<int> sortArray(vector<int>& nums) { // 执行选择排序操作 selectSort(nums); r

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。#include <vector>#include <stdlib.h>using namespace std;class Solution {public: vector<int> sortArray(vector<int&

快速排序为先分隔在左右排序，归并排序为先左右排序再合并#include <vector>#include <stdlib.h>using namespace std;class Solution {public: //临时数组 vector<int> tempArr; vector<int> sortArray(vector<int>& nums) { //设置临时数组大小

快速排序实现的难点，就是如何将数组切分为左右两部分，可以用快慢指针和对撞指针实现。快慢指针#include <vector>#include <stdlib.h>using namespace std;class Solution {public: vector<int> sortArray(vector<int>& nums) { // 执行快速排序操作 quickSort(nums,0,nums

解答这道题的关键是搞清楚递归结束条件叶子节点的定义是左孩子和右孩子都为 null 时叫做叶子节点当 root 节点左右孩子都为空时，返回 1当 root 节点左右孩子有一个为空时，返回不为空的孩子节点的深度当 root 节点左右孩子都不为空时，返回左右孩子较小深度的节点值#include <algorithm>using namespace std;class Solution {public: int minDepth(TreeNode* root) { .

解答#include <algorithm>class Solution {public: int maxDepth(TreeNode* root) { if(root==nullptr) return 0; //递归终止条件 int maxDepthLeft = maxDepth(root->left); //计算左子树最大深度 int maxDepthRight = maxDepth(root->right); .

解答因为硬币可以重复使用，因此这是一个完全背包问题。dp[i] 表示想要凑齐 i 元需要的最少硬币个数dp[0] 表示想要凑齐 0 元需要的最少硬币个数dp[1] 表示想要凑齐 1 元需要的最少硬币个数dp[14] 表示想要凑齐 14 元需要的最少硬币个数#include <vector>using namespace std;// @lc code=startclass Solution {public: int coinChange(vector<int.

解答双指针1#include <string>#include <vector>#include <algorithm>using namespace std;class Solution {public: string findLongestWord(string s, vector<string>& dictionary) { string longestWord = ""; for (in.

解答方法1：临时数组+双指针#include <vector>using namespace std;class Solution {public: void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) { vector<int> tempArr(m+n); //nums1指针 int i = 0;.

解答回文字符串特点关于中间字符或中间位置对称，就是左右对应字符是相等。我们需要前后两个指针，每次我们只要保证指针指向字符是相等的，那这个字符串就是回文字符串，返回true；当两个指针字符不相等时最多可以删除一个字符后继续比较，删除的字符可能是前面指针所指字符或者后面指针所指字符#include <string>using namespace std;class Solution {public: bool validPalindrome(string s) { .

解答使用双指针，一个指针从头向尾遍历，一个指针从尾到头遍历，当两个指针都遍历到元音字符时，交换这两个元音字符。为了快速判断一个字符是不是元音字符，我们将全部元音字符添加到集合 HashSet 中，从而以 O(1) 的时间复杂度进行该操作。#include <string>#include <unordered_set>using namespace std;class Solution {public: string reverseVowels(strin.

解答排序 + 双指针解题思想：在三数之和的基础上多一层循环即可。#include <vector>#include <algorithm>using namespace std;class Solution {public: vector<vector<int>> fourSum(vector<int>& nums, int target) { vector<vector<int&gt.

解答简单一句话，先排序，然后固定第一个数a，再然后b、c只能从两边向中间靠（在a之后）。细节条件就是去重处理（i，start，end三个索引的去重都要考虑）#include <vector>#include <algorithm>#include <math.h>using namespace std;// @lc code=startclass Solution {public: int threeSumClosest(vector<.

简单一句话，先排序，然后固定第一个数a，再然后b、c只能从两边向中间靠（在a之后）。细节条件就是去重处理解答1、官方代码：#include <vector>#include <algorithm>using namespace std;class Solution {public: vector<vector<int>> threeSum(vector<int>& nums) { if (num.

解答双指针可以看成是在元素为 0~target 的有序数组中查找两个数，使得这两个数的平方和为 target，如果能找到，则返回 true，表示 target 是两个整数的平方和。本题和 167. Two Sum II - Input array is sorted 类似，只有一个明显区别：一个是和为 target，一个是平方和为 target。本题同样可以使用双指针得到两个数，使其平方和为 target。本题的关键是右指针的初始化，实现剪枝，从而降低时间复杂度。设右指针为 x，左指针固定为 0，.

解答使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。如果两个指针指向元素的和 sum == target，那么得到要求的结果；如果 sum > target，移动较大的元素，使 sum 变小一些；如果 sum < target，移动较小的元素，使 sum 变大一些。数组中的元素最多遍历一次，时间复杂度为 O(N)。只使用了两个额外变量，空间复杂度为 O(1)。#include <vector.

#include <vector>#include <algorithm>using namespace std;class Solution {public: int minSubArrayLen(int target, vector<int>& nums) { int result = INT_MAX; bool flag = false; int sum = 0; int l.

解题思路：滑动窗口+哈希表#include <string>#include <unordered_set>#include <algorithm>using namespace std;class Solution {public: int lengthOfLongestSubstring(string s) { unordered_set<char> set; int right = 0; .

递归写法： ListNode* reverseList(ListNode* head) { if (head==nullptr||head->next==nullptr) { return head; } ListNode* node = reverseList(head->next); head->next->next = head; head->n