::leetcode{url="https://leetcode.cn/problems/single-number/submissions/701096338/?envType=study-plan-v2&envId=top-100-liked" title="136. 只出现一次的数字" difficulty="Easy"}
利用异或运算的自反性（a^a=0）和恒等性（a^0=a）特性，将所有元素异或后成对元素抵消，剩余即为唯一元素。
该方法正确的原因是异或运算满足交换律和结合律。设数组为{a1,a1,a2,a2,...,an,an,x}，则异或结果为(a1^a1)^(a2^a2)^...^(an^an)^x = 0^0^...^0^x = x。无论元素顺序如何，该数学性质保证结果必然是唯一元素。
class Solution {
public:
int singleNumber(vector<int>& nums) {
int ans = 0;
for(int i = 0;i<nums.size();i++){
ans ^= nums[i];
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/majority-element/submissions/701116907/?envType=study-plan-v2&envId=top-100-liked" title="169. 多数元素" difficulty="Easy"}
Boyer-Moore 投票算法，通过抵消不同的元素来找到多数元素。
该算法的正确性基于抵消思想：将多数元素记为 +1，其他元素记为 -1，总和必然大于 0。遍历数组时，维护当前候选元素及其计数。当计数归零时，说明之前的元素中候选元素与其他元素数量相等，相互抵消。由于多数元素总数超过一半，它最终一定会成为最后的候选元素。
class Solution {
public:
int majorityElement(vector<int>& nums) {
int now ;
int cot = 0;
for(auto i:nums){
if(cot == 0){
now = i;
cot = 1;
}
else{
cot += i==now?1:-1;
}
}
return now;
}
};
::leetcode{url="https://leetcode.cn/problems/sort-colors/submissions/703223021/?envType=study-plan-v2&envId=top-100-liked" title="75. 颜色分类" difficulty="Medium"}
第一段：使用三指针（low、mid、high）一次遍历完成排序，是经典的荷兰国旗问题解法。
第二段：算法维护四个区间的不变性：[0,low-1]全为0，[low,mid-1]全为1，[mid,high]未处理，[high+1,n-1]全为2。当mid遇到0时与low交换并前移双指针，确保0归位；遇到1时直接跳过；遇到2时与high交换并后移high指针，但不前移mid，因为交换后的元素可能仍是0或1需要再次处理。这种策略保证了每个元素最多被交换两次，且不会错过任何可能的正确位置。
第三段：
class Solution {
public:
void sortColors(vector<int>& nums) {
int low = 0;
int mid = 0;
int high = nums.size() - 1;
while(mid <= high){
if(nums[mid] == 0){
swap(nums[low], nums[mid]);
low++;
mid++;
}
else if(nums[mid] == 1){
mid++;
}
else{
swap(nums[mid], nums[high]);
high--;
}
}
}
};
::leetcode{url="https://leetcode.cn/problems/next-permutation/submissions/703229175/?envType=study-plan-v2&envId=top-100-liked" title="31. 下一个排列" difficulty="Medium"}
核心思想是从数组末尾向前寻找第一个满足 nums[i] < nums[i+1] 的位置 i，然后交换 nums[i] 与后面大于它的最小元素，并反转后缀以获得下一个排列。
该方法正确是因为：若整个数组降序，则无更大排列，反转得最小；否则，i 是最后一个可增大的位置，后缀为降序。交换 nums[i] 与大于它的最小元素（从后往前找第一个大于的）确保增大最小幅度，反转后缀使其升序得到最小后缀，从而整体为紧挨着的下一个排列。
class Solution {
public:
void nextPermutation(vector<int>& nums) {
for(int i = nums.size() - 2; i >= 0; i--){
if(nums[i] < nums[i + 1]){
int j = nums.size() - 1;
while(nums[j] <= nums[i]) j--;
swap(nums[i],nums[j]);
reverse(nums.begin() + i + 1, nums.end());
return;
}
}
reverse(nums.begin(), nums.end());
}
};
::leetcode{url="https://leetcode.cn/problems/find-the-duplicate-number/submissions/703237122/?envType=study-plan-v2&envId=top-100-liked" title="287. 寻找重复数" difficulty="Medium"}
将数组视为链表，利用 Floyd 判圈算法（龟兔赛跑）寻找环入口。数组索引作为节点，值作为指向下一节点的指针，由于必存在重复，因此会形成环，环入口即为重复数字。
该方法正确性基于鸽巢原理：n+1 个元素映射到 n 个取值范围必然产生环。设起点到环入口距离为 a，相遇点到入口距离为 b，环长为 L。快指针速度是慢指针两倍，相遇时满足 a + b = nL。重置一指针至起点后，两指针同步移动，当各走 a 步时必在环入口相遇，此时即为重复值。
class Solution {
public:
int findDuplicate(vector<int>& nums) {
int slow = nums[0];
int fast = nums[0];
do{
slow = nums[slow];
fast = nums[nums[fast]];
}while(slow != fast);
int ptr = nums[0];
while(ptr != slow){
ptr = nums[ptr];
slow = nums[slow];
}
return ptr;
}
};
::leetcode{url="https://leetcode.cn/problems/edit-distance/submissions/703246580/?envType=study-plan-v2&envId=top-100-liked" title="72. 编辑距离" difficulty="Medium"}
核心思想是动态规划，定义 dp[i][j] 表示 word1 前 i 个字符转换为 word2 前 j 个字符的最少操作数，通过状态转移方程递推求解。
正确性基于最优子结构和无后效性。对于任意位置 (i,j)，若字符相等则无需操作，直接继承 dp[i-1][j-1]；若不相等，则三种操作中取最小值：删除（dp[i-1][j]+1）、插入（dp[i][j-1]+1）、替换（dp[i-1][j-1]+1）。这种自底向上的方式确保每个子问题最优，从而保证全局最优。
class Solution {
public:
int minDistance(string word1, string word2) {
int m = word1.size();
int n = word2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
for(int i = 1; i <= m; i++){
dp[i][0] = i;
}
for(int i = 1; i <= n; i++){
dp[0][i] = i;
}
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++){
if(word1[i-1] == word2[j-1]){
dp[i][j] = dp[i-1][j-1];
}
else{
dp[i][j] = min( min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]) + 1;
}
}
}
return dp[m][n];
}
};
::leetcode{url="https://leetcode.cn/problems/longest-common-subsequence/submissions/703247808/?envType=study-plan-v2&envId=top-100-liked" title="1143. 最长公共子序列" difficulty="Medium"}
核心思想是动态规划，通过构建二维DP表存储所有前缀子串的最优解。
正确性基于最优子结构：每个状态 dp[i][j] 都表示 text1 前 i 个字符与 text2 前 j 个字符的最长公共子序列长度。当字符匹配时，问题可分解为子问题 dp[i-1][j-1] 加1；不匹配时，最优解必然包含于跳过 text1[i-1] 或 text2[j-1] 的两种情况之一，因此取最大值可保证不遗漏最优解。
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int m = text1.size();
int n = text2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++){
if(text1[i-1] == text2[j-1]){
dp[i][j] = dp[i-1][j-1] + 1;
}
else{
dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
}
}
}
return dp[m][n];
}
};
::leetcode{url="https://leetcode.cn/problems/longest-palindromic-substring/submissions/700956919/?envType=study-plan-v2&envId=top-100-liked" title="5. 最长回文子串" difficulty="Medium"}
使用 Manacher 算法，通过预处理字符串和中心扩展法来线性求解最长回文子串。
算法的正确性基于回文串的对称性。通过插入特殊字符（#）统一处理奇偶长度回文，利用已计算的回文半径 p[i] 来避免重复计算。当 i 在右边界内时，p[i] 的值可以通过其关于中心点的对称点 p[mirror] 推导而来，因为回文具有对称性。如果对称点的回文范围超出了当前左边界，则 p[i] 只能取到右边界的值，否则可以直接使用对称点的值。然后继续中心扩展。这种方法确保每个字符只被扩展常数次，总体时间复杂度为 O(n)。
class Solution {
public:
string longestPalindrome(string s) {
if(s.size() < 2) return s;
string ss = "@";
for(auto c:s){
ss += "#";
ss += c;
}
ss += "#%";
vector<int>p(ss.size(),0);
int center = 0;int right = 0;
int maxLen = 0;
int maxCenter = 0;
for(int i = 1; i < ss.size() - 1; i++){
p[i] = i<right?min(right - i,p[2*center - i]):0;
while(ss[i+p[i]+1] == ss[i-p[i]-1])
p[i]++;
if(i + p[i] > right){
center = i;
right = i + p[i];
}
if(p[i] > maxLen){
maxLen = p[i];
maxCenter = i;
}
}
return s.substr((maxCenter - maxLen)/2,maxLen);
}
};
::leetcode{url="https://leetcode.cn/problems/minimum-path-sum/submissions/703253189/?envType=study-plan-v2&envId=top-100-liked" title="64. 最小路径和" difficulty="Medium"}
动态规划，每个格子的最小路径和等于其上方或左方格子的最小路径和加上当前格子的值。
因为只能向下或向右移动，到达每个格子的路径只能来自上方或左方，所以当前格子的最优解必然由上方或左方的最优解决定，这满足最优子结构性质。
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
int m = grid.size();
int n = grid[0].size();
vector<vector<int>> dp(m, vector<int>(n));
dp[0][0] = grid[0][0];
for(int i = 1; i < m; i++)
dp[i][0] = dp[i-1][0] + grid[i][0];
for(int j = 1; j < n; j++)
dp[0][j] = dp[0][j-1] + grid[0][j];
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
}
}
return dp[m-1][n-1];
}
};
::leetcode{url="https://leetcode.cn/problems/unique-paths/submissions/703204867/?envType=study-plan-v2&envId=top-100-liked" title="62. 不同路径" difficulty="Medium"}
动态规划：到达每个格子的路径数等于从上方和左方到达的路径数之和。
该方法正确性基于数学归纳法：基础情况是第一行和第一列只有1条路径；递推关系成立是因为机器人只能从上方或左方到达当前格子，因此总路径数是这两个方向路径数的和。通过填充DP表，每个格子的值都正确表示了到达该位置的路径总数。
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n, 0));
for(int i = 0; i < m; i++) dp[i][0] = 1;
for(int i = 0; i < n; i++) dp[0][i] = 1;
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
}
};
::leetcode{url="https://leetcode.cn/problems/longest-valid-parentheses/submissions/703517766/?envType=study-plan-v2&envId=top-100-liked" title="32. 最长有效括号" difficulty="Hard"}
动态规划，定义 dp[i] 表示以位置 i 结尾的最长有效括号子串的长度。
当 s[i] == ')' 时，有两种情况：若 s[i-1]=='('，则形成 "()"，dp[i] = dp[i-2] + 2；若 s[i-1]==')'，则检查 s[i-dp[i-1]-1] 是否为 '('，若是则可扩展前面的有效串。这种方法能正确计算所有可能的有效括号子串长度，因为每个位置的状态都依赖于前面已计算的状态，通过状态转移覆盖了所有可能的匹配情况。
class Solution {
public:
int longestValidParentheses(string s) {
int n = s.size();
vector<int> dp(n, 0);
int ans = 0;
for (int i = 1; i < n; i++) {
if (s[i] == ')') {
if (s[i - 1] == '(') {
dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
} else {
int j = i - dp[i - 1] - 1;
if (j >= 0 && s[j] == '(') {
dp[i] = dp[i - 1] + 2 + (j >= 1 ? dp[j - 1] : 0);
}
}
}
ans = max(ans, dp[i]);
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/partition-equal-subset-sum/submissions/703510338/?envType=study-plan-v2&envId=top-100-liked" title="416. 分割等和子集" difficulty="Medium"}
核心思想是将问题转化为子集和问题，使用 bitset 优化的动态规划。第一段：将数组分割成两个等和子集的问题等价于判断是否存在一个子集，其元素和等于数组总和的一半。使用 bitset 进行状态压缩的动态规划，通过位运算高效地计算所有可达的和。第二段：正确性基于 0/1 背包问题的状态转移。dp[i] 为 true 表示可以从前 k 个元素中选出若干个数使其和为 i。对于每个数字 num，dp << num 表示所有已可达的和加上 num 后变为新的可达和，dp |= (dp << num) 将新可达的和合并到状态中。由于正整数不会导致和回退，这种更新方式不会遗漏任何可能解。第三段：
class Solution {
public:
bool canPartition(vector<int>& nums) {
int sum = 0;
for(int x: nums) sum += x;
if(sum % 2) return false;
int target = sum/2;
bitset<10001> dp;
dp[0] = 1;
for(int num: nums){
dp |= (dp << num);
}
return dp[target];
}
};
::leetcode{url="https://leetcode.cn/problems/maximum-product-subarray/submissions/703498352/?envType=study-plan-v2&envId=top-100-liked" title="152. 乘积最大子数组" difficulty="Medium"}
维护以当前位置结尾的子数组的最大和最小乘积，通过动态规划处理负数符号翻转的情况。
由于负数的存在，当前的最大乘积可能在乘以负数后变成最小乘积，而最小乘积可能变成最大乘积。因此需要同时维护最大和最小两个状态。每一步我们考虑当前元素本身，或当前元素与之前最大/最小乘积的乘积，确保不会遗漏任何可能的子数组情况。这种动态规划方法保证了每个位置我们都掌握了最优解，最终答案就是所有位置最大乘积中的最大值。
class Solution {
public:
int maxProduct(vector<int>& nums) {
int maxp = nums[0];
int minp = nums[0];
int ans = nums[0];
for(int i = 1; i < nums.size(); i++){
if(nums[i] < 0){
swap(maxp, minp);
}
maxp = max(nums[i], maxp * nums[i]);
minp = min(nums[i], minp * nums[i]);
ans = max(ans, maxp);
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/longest-increasing-subsequence/submissions/703270525/?envType=study-plan-v2&envId=top-100-liked" title="300. 最长递增子序列" difficulty="Medium"}
动态规划，定义 dp[i] 为以 nums[i] 结尾的最长递增子序列长度。
该方法的正确性基于最优子结构。对于任意位置 i，若存在 j < i 且 nums[j] < nums[i]，则所有以 j 结尾的递增子序列都可以通过添加 nums[i] 扩展为以 i 结尾的子序列。dp[i] 取所有可扩展情况的最大值，因此必然记录了以 i 结尾的最长递增子序列长度。最终答案取所有 dp[i] 的最大值，因为全局最长递增子序列必然以某个元素结尾。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
vector<int> dp(n,1);
for(int i = 0; i < n; i++){
for(int j = 0; j < i; j++){
if(nums[i] > nums[j]){
dp[i] = max(dp[i],dp[j]+1);
}
}
}
return *max_element(dp.begin(),dp.end());
}
};
::leetcode{url="https://leetcode.cn/problems/word-break/submissions/703271258/?envType=study-plan-v2&envId=top-100-liked" title="139. 单词拆分" difficulty="Medium"}
核心思想是动态规划，定义 dp[i] 表示前 i 个字符能否被拼接。
正确性基于最优子结构：若 s[0:i] 可被拼接，则必存在分割点 j，使得 s[0:j] 可被拼接且 s[j:i] 是字典单词；反之亦然。这保证了状态转移的完备性。
class Solution {
public:
bool wordBreak(string s, vector<string>& wordDict) {
unordered_set<string> dict(wordDict.begin(), wordDict.end());
int n = s.size();
vector<bool> dp(n + 1, false);
dp[0] = true;
for(int i = 1; i <= n; i++){
for(int j = 0; j < i; j++){
if(dp[j] && dict.count(s.substr(j, i-j))){
dp[i] = true;
break;
}
}
}
return dp[n];
}
};
::leetcode{url="https://leetcode.cn/problems/coin-change/submissions/703200026/?envType=study-plan-v2&envId=top-100-liked" title="322. 零钱兑换" difficulty="Medium"}
核心思想是动态规划，通过构建DP数组记录每个金额所需的最少硬币数。
该方法正确是因为每个金额的最优解都依赖于更小金额的最优解，具有最优子结构。通过自底向上计算，确保每个状态都是最优的，且不会遗漏任何可能的硬币组合。
class Solution {
public:
int coinChange(vector<int>& coins, int amount) {
vector<int> dp(amount + 1, amount + 1);
dp[0] = 0;
for(int i = 1; i <= amount; i++){
for(int j = 0; j < coins.size(); j++){
if(i-coins[j] >= 0)
dp[i] = min(dp[i],dp[i-coins[j]]+1);
}
}
return dp[amount] == amount+1 ? -1 : dp[amount];
}
};
::leetcode{url="https://leetcode.cn/problems/perfect-squares/submissions/703271856/?envType=study-plan-v2&envId=top-100-liked" title="279. 完全平方数" difficulty="Medium"}
第一段：使用动态规划，定义 dp[i] 表示凑出数值 i 所需的最少完全平方数个数，通过枚举所有可能的平方数进行状态转移。
第二段：该方法正确性的核心在于最优子结构性质。对于任意数值 i，若选择使用一个完全平方数 j²，则剩余部分 i-j² 的最优解加上当前这一个数，就构成了 i 的一个可行解。由于我们枚举了所有可能的 j² 并取最小值，因此 dp[i] 必然保存了全局最优解。dp[0]=0 作为基础边界条件，保证了递推链条的正确启动。
第三段：
class Solution {
public:
int numSquares(int n) {
vector<int> dp(n + 1, INT_MAX);
dp[0] = 0;
for(int i = 1; i <= n; i++){
for(int j = 1; j * j <= i; j++){
dp[i] = min(dp[i], dp[i - j*j] + 1);
}
}
return dp[n];
}
};
::leetcode{url="https://leetcode.cn/problems/house-robber/submissions/703193777/?envType=study-plan-v2&envId=top-100-liked" title="198. 打家劫舍" difficulty="Medium"}
动态规划，定义 dp[i][0/1] 表示前 i 个房屋在偷或不偷第 i 个房屋时的最大收益。
该问题的最优子结构性质体现在：对于第 i 个房屋，如果选择不偷，则最大收益为前 i-1 个房屋的最大收益（dp[i-1][0] 和 dp[i-1][1] 的较大值）；如果选择偷，则前一个房屋必须不偷，收益为 dp[i-1][0] + nums[i]。由于每个决策只依赖于前一个状态，且我们枚举了所有可能的选择，因此该动态规划方法能够得到全局最优解。
class Solution {
public:
int rob(vector<int>& nums) {
int dp[nums.size()][2];
memset(dp,0,sizeof(dp));
dp[0][0] = 0;
dp[0][1] = nums[0];
for(int i = 1; i < nums.size(); i++){
dp[i][0] = max(dp[i-1][0],dp[i-1][1]);
dp[i][1] = dp[i-1][0]+nums[i];
}
return max(dp[nums.size()-1][0],dp[nums.size()-1][1]);
}
};
::leetcode{url="https://leetcode.cn/problems/pascals-triangle/?envType=study-plan-v2&envId=top-100-liked" title="118. 杨辉三角" difficulty="Easy"}
第一段：采用动态规划思想，逐行递推构造，每行的每个元素依赖于前一行相邻两个元素的和。
第二段：正确性基于数学归纳法。基础情况第0行[1]符合定义。假设前i-1行已正确生成，则第i行的首尾元素恒为1，中间元素通过ans[i-1][j-1] + ans[i-1][j]计算，这恰好满足杨辉三角的组合数学性质C(i,j) = C(i-1,j-1) + C(i-1,j)，因此每行都能被准确构造，不会遗漏任何正确结果。
第三段：
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>>ans;
for(int i = 0;i < numRows;i++){
if(i == 0){
ans.push_back({1});
}
else{
vector<int>tmp;
for(int j=0;j <= i;j++){
if(j > 0){
if(j == i){
tmp.push_back(ans[i-1][i-1]);
}
else{
tmp.push_back(ans[i-1][j-1] + ans[i-1][j]);
}
}
else{
tmp.push_back(1);
}
}
ans.push_back(tmp);
}
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/climbing-stairs/?envType=study-plan-v2&envId=top-100-liked" title="70. 爬楼梯" difficulty="Easy"}
核心思想是动态规划，发现到达每阶楼梯的方法数遵循斐波那契数列递推规律。
正确性基于分类加法计数原理：对于第i阶，最后一步只能是1阶或2阶。若最后一步为1阶，则有dp[i-1]种方法；若为2阶，则有dp[i-2]种方法。这两种情况互斥且穷尽所有可能，因此dp[i] = dp[i-1] + dp[i-2]成立。初始条件dp[1]=1和dp[2]=2可通过枚举验证，递推关系保证了所有子问题解的正确性。
实现步骤：
class Solution {
public:
int climbStairs(int n) {
int dp[n+2];
dp[1] = 1;
dp[2] = 2;
for(int i = 3;i<=n;i++){
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
};
::leetcode{url="https://leetcode.cn/problems/partition-labels/?envType=study-plan-v2&envId=top-100-liked" title="763. 划分字母区间" difficulty="Medium"}
核心思想是贪心策略：先统计每个字母的最后出现位置，再遍历字符串时维护当前片段的结束边界，当遍历到边界时立即切割。
正确性证明：对于任意片段，必须包含其中所有字母的最后出现位置，否则该字母会跨越片段。贪心策略选择当前已遍历字母的最后位置的最大值作为边界，确保边界内所有字母不会在后续出现，此时切割能得到最多片段数。若延迟切割只会减少片段数量，因此该策略是最优的。
last，记录每个字母在字符串中最后出现的下标last数组start=0、end=0，用于标记当前片段的起止位置end = max(end, last[s[i]-'a'])i == end时，说明当前片段结束，记录长度并更新start = end + 1class Solution {
public:
vector<int> partitionLabels(string s) {
int last[26] = {0};
for(int i = 0; i < s.size(); i++){
last[s[i]-'a'] = i;
}
vector<int> ans;
int start = 0;
int end = 0;
for(int i = 0; i < s.size(); i++){
end = max(end,last[s[i]-'a']);
if(i == end){
ans.push_back(end - start + 1);
start = end + 1;
}
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/jump-game-ii/description/?envType=study-plan-v2&envId=top-100-liked" title="跳跃游戏 II" difficulty="Medium"}
使用广度优先搜索（BFS）按层遍历所有可达位置，首次到达终点时的层数即为最小跳跃次数。
BFS的正确性基于其按层扩展的特性：第k层的所有位置都恰好通过k次跳跃到达。由于每次跳跃可以到达任意可达位置，BFS能确保第一次访问到终点时，所用的跳跃次数是最小的。visited数组防止重复访问，保证每个位置只被处理一次，不会遗漏最优解。
class Solution {
public:
int jump(vector<int>& nums) {
int n = nums.size();
queue<int> q;
vector<bool> visited(n,false);
q.push(0);
visited[0] = true;
int step = 0;
while(!q.empty()){
int size = q.size();
for(int i = 0; i < size; i++){
int cur = q.front();
q.pop();
if(cur == n-1)
return step;
for(int j = 1; j <= nums[cur]; j++){
int next = cur + j;
if(next < n && !visited[next]){
visited[next] = true;
q.push(next);
}
}
}
step++;
}
return -1;
}
};
::leetcode{url="https://leetcode.cn/problems/jump-game/submissions/703204343/?envType=study-plan-v2&envId=top-100-liked" title="跳跃游戏" difficulty="Medium"}
贪心算法，维护当前能到达的最远位置。
该方法正确性的核心在于贪心选择策略：在每一步都尽可能跳得最远。维护的不变量是'所有小于等于 i 的位置都是可达的'。如果 i > max_reach，说明位置 i 不可达，那么 i 之后的所有位置也无法到达，因为无法跳过这个断点。反之，只要能够遍历到数组末尾，就说明每个位置都是可达的，因此可以到达最后一个下标。
class Solution {
public:
bool canJump(vector<int>& nums) {
int n = nums.size();
int max_reach = 0;
for(int i = 0; i < n; i++){
if(i > max_reach) return false;
max_reach = max(max_reach,i+nums[i]);
}
return true;
}
};
::leetcode{url="https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/submissions/701124268/?envType=study-plan-v2&envId=top-100-liked" title="买卖股票的最佳时机" difficulty="Easy"}
核心思想是在一次遍历中动态维护历史最低买入价，并计算每日卖出可获最大利润。
正确性证明：对于任意第 i 天，最优买入点必然是 i 之前（含 i）价格最低的那天。通过维护 mincost 可保证始终以最优价格买入，ans 记录所有卖出时机中的最大利润，故不会遗漏全局最优解。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int mincost = prices[0];
int ans = 0;
for(auto i:prices){
mincost = min(mincost,i);
ans = max(ans,i-mincost);
}
return ans;
}
};
::leetcode{url="https://leetcode.cn/problems/find-median-from-data-stream/submissions/703604378/?envType=study-plan-v2&envId=top-100-liked" title="数据流的中位数" difficulty="Hard"}
使用两个堆（最大堆和最小堆）分别存储较小和较大的一半数，通过堆顶元素快速获取中位数。
该方法通过两个堆维护中位数：最大堆 lo 存储较小的一半数，最小堆 hi 存储较大的一半数。插入时先将元素放入 lo，再将 lo 的堆顶移到 hi 确保 lo 的所有元素 <= hi 的所有元素；最后如果 lo 的大小小于 hi，则将 hi 的堆顶移回 lo，保证 lo 的大小 >= hi 且两者大小差不超过 1。这样中位数要么是 lo 的堆顶（奇数个元素），要么是两堆堆顶的平均值（偶数个元素）。
class MedianFinder {
public:
priority_queue<int> lo; // max heap
priority_queue<int, vector<int>, greater<int>> hi; // min heap
MedianFinder() {
}
void addNum(int num) {
lo.push(num); // Add to max heap
hi.push(lo.top()); // balancing step
lo.pop();
if (lo.size() < hi.size()) { // maintain size property
lo.push(hi.top());
hi.pop();
}
}
double findMedian() {
return lo.size() > hi.size()
? (double)lo.top()
: (lo.top() + hi.top()) * 0.5;
}
};
/**
* Your MedianFinder object will be instantiated and called as such:
* MedianFinder* obj = new MedianFinder();
* obj->addNum(num);
* double param_2 = obj->findMedian();
*/