leetcode面试100道题

地址：
https://leetcode.com/problemset/top-100-liked-questions/?difficulty=Easy

done 表示写代码完成了 undone 表示看了思路但是没敲代码 predone 是之前做过了，这一次只看没做 neverdone 表示没做也没看

Easy:

predone （1）两数之和——用哈希表做，键存数字，值存位置

predone （20）有效的括号——用栈实现

undone （21）合并两个有序链表——递归，非递归

done （53）最大子序和——简单的动态规划

undone（70）爬楼梯——简单动态规划（用非递归求解）

undone（101）对称二叉树——递归（左右都为空，左右中有一个为空，左右不为空但是值不相等），非递归（类似层序遍历，用两个队列实现，分别存左右孩子）

undone（104）二叉树的最大深度——递归（深度搜索），广度搜索

predone（121）买卖股票的最佳时机——以f(i)表示以第i天结尾卖出的最大收益，用一个值pre记录第i天之前的最低价格，则f(i)=d[i]-res d[i]表示第i天的价格，最后求所有f(i)的最大值即为所求

done（136）只出现一次的数字——异或求解（^）

undone（141）环形链表——判断链表是否有环，快慢指针做

。。。（没看完）

Medium

undone（2）两数相加——链表加法

done（3）无重复字符的最长子串——动态规划

undone（5）最长回文子串——动态规划，P[i][j]表示第i到第j组成的序列是回文串（是为true,不是为false），P[i,i]=true:当且仅当P[i+1,j-1] = true && (s[i]==s[j]），矩阵填充方式可以学习一下

undone（11）盛水最多的容器——双指针法，每次将较短的那根线段向内侧移动

predone（15）三数之和——先排序，然后固定一个数，另外两个数用双指针法找

undone（17）电话号码的字母组合——从每个桶里取一个元素的全部组合（递归和非递归）

undone（19）删除链表的倒数第N个节点——快慢指针

undone（22）括号生成——递归方式，当时没太看明白

predone（31）下一个排列——如： 8 4 7 6 5 3 1。从后往前找第一个不是升序排列的数字4（因为从高位到低位如果是按照递减排列，那么该数就是最大的数了），那么下一个比他大的数字在该位置上的数字应该大于4，故从后往前找第一个比他大的数5并交换位置，交换位置后，该位置的5已经保证了他要比之前的数字大了（即保证了交换位置后7 6 4 3 1是递减的），因此将其后的升序序列反序（反序后将原来递增的变成了递减的，即该序列对应的数字是最小的了），变成8 5 1 3 4 6 7。

neverdone（33）搜索旋转排序数组——二分查找（剑指offer上有类似的）

neverdone（34）在排序数组中查找元素的第一个和最后一个位置——二分查找

predone（39）组合总数——回溯法，深度优先搜索，递归。找和为target的序列，对于节点i来说，下一步是找和为target-i的序列

done（46）全排列——回溯法，递归。先将序列的每个元素和第一个元素交换，求除第一个元素外的全排列，最后将交换的元素换回去。

neverdone（48）旋转图像——找规律。先按照从左上角到右下角的斜对角线为对称线换元素。然后根据中线换元素

neverdone（49）字母异位词分组——将异位词分成一组，异位词是指字母相同但是顺序不同的词。先对每个词进行排序，那么所有异位词排序后都相同。然后用unordered_map实现，键是排序后的词，值是保存原词的vector

predone（55）跳跃游戏——贪心算法。对于每个点，求出可到达的最远距离。

predone（56）合并区间——按照区间的开头进行排序，每次合并相邻区间

done（62）不同路径——简单的动态规划

done（64）最小路径和——简单动态规划，和62类似。主要看答案中对动态规划空间复杂度的优化

predone（75）颜色分类——双指针做，分别指向第一个1和最后一个1.

neverdone（78）子集——回溯法，分支为取当前数字和不取当前数字；将元素依次加入，每次的新元素加入原来所有的组合里

done（79）单词搜索——回溯法，DFS。1从空节点开始的分支要写在主函数里，之后的分支在递归函数里。2由于最终不用输出具体结果字符串，因此没保存路径。3每次搜索的下一个分支有4种，分别为上，下，左，右。4需要标记矩阵中已经走过的点，避免重复走

predone（94）二叉树的中序遍历——栈实现。口诀：不为空，压栈指左，为空，弹栈指右

neverdone（96）不同的二叉搜索树——递归，以i为根节点的二叉搜索树总和，而以i为根节点的二叉树数目为左子树的数目*右子树的数目。卡塔兰数。

neverdone（98）验证二叉搜索树——递归。递归函数规定了下一个节点的数值范围，左子树节点应该小于当前节点，右子树节点应该大于当前节点。（代码还是和自己想的不一样，还需要看一看）

done（102）二叉树的层次遍历——一个队列实现，还需要一个数值保存当前层有多少个节点

done（105）从前序和中序遍历序列构造二叉树——递归

neverdone（114）二叉树展开为链表——递归，非递归，前序遍历三种方法

done（139）单词拆分——动态规划，二维。以i结尾的词是否可以被拆分由i之前的某个以j结尾的序列是否可拆分成功和j-i这段序列是否在字典中来确定。

done（142）环形链表——快慢指针看是否有环，一个从头走，一个从相遇点走，步幅都为1，相遇点就是环的入口

done（148）合并排序链表——归并排序链表，时间复杂度nlogn，常数空间复杂度，因为是链表，合并时不需要开辟额外空间。思路：找中间节点断开，各自排序，然后合并两个有序链表。

neverdone（152）乘积最大子序列——动态规划。需要保存以每个点结尾的最大乘积和最小乘积，因为之后的负数有可能让最小的（负数）变成最大的。因此需要两个数组。优化，可以用两个变量来替代数组。

neverdone（200）岛屿数量——回溯，没看明白

done（207）课程表——图判断是否有环（拓扑排序），两种方式，深度优先和广度优先（当时照着答案敲了一边代码，但是未单独敲过）

done（208）前缀树——节点的孩子存在unordered_map里（vector里也行，下标为字母，值为指针），节点还需要一个表明是否是单词结尾的属性（照着答案敲了一遍）

predone（215）数组中的第k个最大元素——优先队列或者partition来做

neverdone（221）最大正方形——动态规划（二维数组动态规划）。第（i,j）位置的正方形边长等于(i-1,j), (i,j-1), (i-1,j-1)位置处边长最小值+1。

neverdone（236）二叉树的最低公共祖先——没看懂

neverdone（238）除自身以外数组的乘积（不能用除法）——第i位除自身以外的乘积等于左边所有数的乘积*右边所有数的乘积，用两个数组分别保存第i位左边和右边数的乘积即可

neverdone（240）搜索二维矩阵——从右上方开始搜索，每次排除一行或者一列的元素

neverdone（253）Meeting Rooms II（付费题目）——给定会议开始和结束的时间，求最少需要多少个房间使得会议不冲突。先将会议按照开始时间排序，用一个堆保存会议（堆按照会议的结束时间进行排序，结束时间早的在堆顶）然后对于每一个新会议，如果开始时间和堆顶结束时间冲突了就将其入堆，并将房间数目加1，如果不冲突，则将堆顶元素抛出，将新会议入堆。

neverdone（279）完全平方数——动态规划。一个数n要么自己是完全平方数，要么是j*j和n-j*j组成的完全平方数，其中j*j

neverdone（287）寻找重复数——1.二分查找（对范围进行二分而不是对数组进行二分）；2.快慢指针——将有重复数字的数组根据下标信息变成有环的，环的起点就是重复的数组

done（300）最长上升子序列——动态规划。优化：动态规划+二分

neverdone（309）最佳买卖股票时机含冷冻期——动态规划，用一个示意图推导的，三种状态。（没理解透彻，应该背下来）

done（322）零钱兑换。——动态规划。

neverdone（337）打家劫舍 III. ——树的DFS+动态规划，博客解释有部分没看懂

neverdone（338）比特位计数——找规律题目。（1）res[i] 表示数字 i 含有1的个数。如果 i 是奇数，则res[i] = res[i/2]+1, 如果 i 是偶数，res[i] = i. （2）i里1的个数比 i&(i-1)里1的个数多1

predone（347）前k个高频元素——优先队列或者桶排序

neverdone（394）字符串解码——栈和递归两种方法（递归不太明白）,之后需要敲一下代码

neverdone（399）除法求值——图中寻找两个点之间的路径问题，DFS，BFS，并查集

neverdone（406）根据身高重排队列——先按照身高降序排序，如果身高相等按照人数升序排序

neverdone（416）分割等和子集——将数组分成两份，使得每一份的和为总和的一半。动态规划，对于每个元素i可以选择取或者不取。如果取，那么在第i位能够凑成和为j的条件由前i-1为是否能凑成j-nums[i]决定；如果不取，那么在第i位能够凑成和为j的条件由前i-1位能否凑成j决定

neverdone（494）目标和——动态规划，将数组分成两份，一份为正，一份为负，使得两者和等于target。可以将其转换成416的情况。

neverdone（560）和为K的子数组——数组是未排序的。（1）第i为记录从0-i的数字和，然后双重循环找两个点，使得两个点的值之差为k。（2）哈希表，键为从0开始到当前位置的和sum，值为从0开始和为sum的区间个数，对于当前位置找之前值为sum-k的个数。

neverdone（621）任务调度器——保证相同字母间隔不小于给定值，求最短长度。数学公式推导，按照出现次数最多的字母先按给定间隔排，然后考虑剩下元素。

neverdone（647）回文子串——动态规划，i->j的序列是否是回文串由i+1->j-1的序列决定

neverdone（739）每日温度——找自己之后第一个比自己大的元素位置，用栈实现，将元素依次入栈，保证栈内元素从栈顶到栈底是递增的（可以通过出栈保证这一点）

Hard

neverdone（4）寻找两个有序数组的中位数——选一个划分，使得左半部分个数等于右半部分个数，同时左边最大值小于右边最小值。通过第一个条件可知取一个数组的划分，另一个数组的划分位置也就确定了，对那个数组采用二分进行划分。

neverdone（10）正则表达式匹配——没做

neverdone（23）合并K个排序链表——优先队列和归并排序两种方法

neverdone（32）最长有效括号——栈或者动态规划

neverdone（42）接雨水——遍历两次数组，分别记录当前值左边和右边的最大值,当前值只有比左右最大值都小才会有积水

neverdone（72）编辑距离——动态规划（二维）。按照两个最后一个元素是否相等分成两种情况，相等则取左上角值，不相等则取左上角，左边，上边的最小值在加1。

neverdone（76）最小覆盖子串——双指针维护一个滑动窗口。先找一个窗口覆盖目标的所有字母，然后如果左边界的字母不是目标里的字母或者该字母是多余的字母则向右滑动左边界。

neverdone（84）柱状图中最大的矩形——单调栈

neverdone（85）最大矩形——将矩形每一行转化成直方图然后按照84的方法做

neverdone（124）二叉树中的最大路径和——递归，返回以当前节点为根节点的不分叉路径（只包含该节点，或者该节点+左子树或者该节点加右子树）最大和

neverdone（128）最长连续序列——哈希表，键为元素，值为元素所在序列的最大长度

neverdone（146）LRU缓存机制——双向链表+哈希表。双向链表存元素，实现快速移动添加与删除，将常用元素移到链表头，不常用移动到链表尾部。哈希表用于实现快速查找，值为指向链表对应元素的指针（迭代器）

neverdone（239）滑动窗口最大值——单调队列做（从队头到队尾递减），队列保存元素下标（而不是元素本身）用于判断队头是否在窗口之外

neverdone（297）二叉树序列化与反序列化——先跟序列化和层序序列化

Easy：

21.合并两个有序链表
递归：https://leetcode.com/problems/merge-two-sorted-lists/discuss/9713/A-recursive-solution
非递归：（新加一个节点作为头结点）https://leetcode.com/problems/merge-two-sorted-lists/discuss/9714/14-line-clean-C%2B%2B-Solution

70.爬楼梯
https://leetcode.com/problems/climbing-stairs/discuss/25299/Basically-it’s-a-fibonacci.

101.对称二叉树
递归：https://leetcode.com/problems/symmetric-tree/discuss/33056/15-lines-of-c%2B%2B-solution-8-ms
非递归：https://leetcode.com/problems/symmetric-tree/discuss/33089/My-C%2B%2B-Accepted-code-in-16ms-with-iteration-solution

104.二叉树的最大深度
https://leetcode.com/problems/maximum-depth-of-binary-tree/discuss/34207/My-code-of-C%2B%2B-Depth-first-search-and-Breadth-first-search

141.环形链表
https://leetcode.com/problems/linked-list-cycle/discuss/44604/My-faster-and-slower-runner-solution

medium

3.无重复字符的最长子串
自己博客有
https://blog.csdn.net/aikudexue/article/details/87819580

5.最长回文子串
自己博客中有
https://leetcode.com/problems/longest-palindromic-substring/discuss/147548/Direct-c%2B%2B-DP

https://www.cnblogs.com/leavescy/p/5878336.html

11.盛水最多的容器
两线段之间形成的区域总是会受到其中较短那条长度的限制。此外，两线段距离越远，得到的面积就越大。我们在由线段长度构成的数组中使用两个指针，一个放在开始，一个置于末尾。 此外，我们会使用变量 maxareamaxarea 来持续存储到目前为止所获得的最大面积。 在每一步中，我们会找出指针所指向的两条线段形成的区域，更新 maxareamaxarea，并将指向较短线段的指针向较长线段那端移动一步。（来源于leetcode官方解析）

15.三数之和
自己博客中有
https://blog.csdn.net/aikudexue/article/details/85486665

17.电话号码的字母组合
自己博客有
https://blog.csdn.net/aikudexue/article/details/89111420

19.删除链表的倒数第N个节点
https://leetcode.com/problems/remove-nth-node-from-end-of-list/discuss/8843/C%2B%2B-solution-easy-to-understand-with-explanations.

22.括号生成
https://www.cnblogs.com/ariel-dreamland/p/9133613.html

31.下一个排列
自己博客有
https://blog.csdn.net/aikudexue/article/details/85546507

34.在排序数组中查找元素的第一个和最后一个位置
自己博客有二分及变形的总结
https://blog.csdn.net/aikudexue/article/details/88831913

39.组合总数
自己博客有
https://blog.csdn.net/aikudexue/article/details/85720100

46.全排列
回溯法的博客里有
https://leetcode.com/problems/permutations/discuss/18247/My-elegant-recursive-C%2B%2B-solution-with-inline-explanation

48.旋转图像
https://www.cnblogs.com/jimmycheng/p/7199624.html

49.字母异位词分组
https://blog.csdn.net/hua111hua/article/details/87921568

55.跳跃游戏
自己博客有
https://blog.csdn.net/aikudexue/article/details/86699778

56.区间合并
自己博客有
https://blog.csdn.net/aikudexue/article/details/87360439

62.不同路径
https://leetcode.com/problems/unique-paths/discuss/22954/C%2B%2B-DP

64.最小路径和
https://leetcode.com/problems/minimum-path-sum/discuss/23457/C%2B%2B-DP
答案中有对空间复杂度的优化。二维矩阵；两个一维矩阵；一个一维矩阵。

75.颜色分类
自己博客有
https://blog.csdn.net/aikudexue/article/details/87365439

78.子集
https://blog.csdn.net/camellhf/article/details/73551410

class Solution {
public:
    void dfs(vector<vector<int>> &res, vector<int> &nums, vector<int> temp, int i) {//将nums中i位以后的序列求子集，用tmp保存一条路径的结果，当走到叶节点时，将结果保存到res中
        if (i == nums.size()) {
            res.push_back(temp);
            return ;
        }

        dfs(res, nums, temp, i + 1); //不选当前数字
        temp.push_back(nums[i]);
        dfs(res, nums, temp, i + 1);//选当前数字
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> temp;

        dfs(res, nums, temp, 0);

        return res;
    }
};

79.单词搜索
自己博客有
https://blog.csdn.net/aikudexue/article/details/89460336

94.二叉树的中序遍历
自己博客有
https://blog.csdn.net/aikudexue/article/details/87791734

96不同的二叉搜索数
https://blog.csdn.net/qq874455953/article/details/82811832
使用两个状态来记录：
G(n)：长度为n的序列的所有唯一的二叉树。
F(i,n)，1<=i<=n：以i作为根节点的二叉树的数量。
G(n)就是我们要求解的答案，G(n)可以由F(i,n)计算而来。
G(n)=F(1,n)+F(2,n)+…+F(n,n) (1)
G(0)=1,G(1)=1
对于给定的一个序列1…n，我们取i作为它的根节点，那么以i作为根节点的二叉树的数量F(i)可以由下面的公式计算而来：
F(i,n)=G(i-1)*G(n-i) 1<=i<=n (2)
综合公式（1）和公式（2），可以看出：
G(n) = G(0) * G(n-1) + G(1) * G(n-2) + … + G(n-1) * G(0)

98.验证二叉搜索树
https://blog.csdn.net/hlk09/article/details/81320283

class Solution {
public:
    bool isValidBST(TreeNode * root) {
        return isValidBSTHelper(root, INT64_MIN, INT64_MAX);
    }
    
    bool isValidBSTHelper(TreeNode *root, long lower, long upper){
        if(root == NULL)    return true;
        if(root->val>=upper || root->val<=lower)    return false; //当前节点范围不对
        return isValidBSTHelper(root->left,lower,root->val)&&isValidBSTHelper(root->right,root->val,upper);//左节点应该小于当前节点，即upper为root->val.右节点应该大于当前节点
    }
};

102.二叉树的层次遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        int count=1;
        while (!q.empty())
        {
            vector<int> cur_val; //保存当前层的节点值
            for(int i=0;i<count;++i) //count为当前层的节点数目，如果没有count则不知道当前层应该对队列pop几次
            {
                TreeNode* tmp=q.front();
                if(tmp->left) q.push(tmp->left); //左不为空入左
                if(tmp->right) q.push(tmp->right); //右不为空入右
                q.pop();
                cur_val.push_back(tmp->val);
            }
            res.push_back(cur_val);
            count=q.size(); //由于上一层的节点全部pop了，因此队列的大小就是当前层的节点数目
        }
        return res;

    }
};

参考：
https://leetcode.com/problems/binary-tree-level-order-traversal/discuss/33709/Short-8ms-C%2B%2B-solution-with-queue

105.从前序和中序遍历序列构造二叉树

class Solution {
public:
    /* from Preorder and Inorder Traversal */
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return helper(preorder,0,preorder.size(),inorder,0,inorder.size());
    }
    TreeNode* helper(vector<int>& preorder,int ps,int pe,vector<int>& inorder,int is,int ie)
    {
        if(ps>=pe) //注意是大于等于
            return nullptr;
        int root_val = preorder[ps];  //根节点
        auto pos = find(inorder.begin()+is,inorder.begin()+ie,root_val); //在中序遍历序列里找root_val的位置
        int left_num = pos-(inorder.begin()+is); //左子树元素个数
        TreeNode* root = new TreeNode(root_val);
        root->left = helper(preorder,ps+1,ps+left_num+1,inorder,is,is+left_num);//左子树对应序列在中序和后序的起始位置
        root->right = helper(preorder,ps+left_num+1,pe,inorder,is+left_num+1,ie);//右子树对应序列在中序和后序的起始位置
        return root;

    }
};

参考：
https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/discuss/34557/My-neat-C%2B%2B-solution

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/discuss/34555/The-iterative-solution-is-easier-than-you-think!（非递归方法，用栈实现，还没看）

114.二叉树展开为链表
自己博客有
https://blog.csdn.net/aikudexue/article/details/89472322

139.单词拆分
自己博客有
https://blog.csdn.net/aikudexue/article/details/89501616

142.环形链表II
https://leetcode.com/problems/linked-list-cycle-ii/discuss/44781/Concise-O(n)-solution-by-using-C%2B%2B-with-Detailed-Alogrithm-Description

148.排序链表
https://leetcode.com/problems/sort-list/discuss/46720/Share-my-C%2B%2B-concise-solutionseasy-to-understand
主要看双指针找中间点的写法，以及循环合并有序链表的写法

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head== nullptr || head->next== nullptr) //节点为空或者只有一个节点
            return head;
        ListNode* fast = head, *slow = head;
        while (fast->next && fast->next->next) //注意这里都是fast，而不是一个fast,一个slow,因为fast合理slow一定合理。这样写是为了保证循环内的指针一定有效。
        {
            slow=slow->next;  //节点个数为基数时，slow指向中间元素，为偶数时，slow指向中间两个数靠前的那个。比如4个元素，slow最终指向第2个
            fast=fast->next->next;
        }
        fast = slow->next;
        slow->next=nullptr;  //从slow处断开，fast为第二段链表的开头
        ListNode* fir = sortList(head);  //排序第一段链表，因为slow之前断开了，因此此时head包含前半部分链表
        ListNode* sec = sortList(fast);
        return MergeList(fir,sec);
    }
    ListNode* MergeList(ListNode* fir,ListNode* sec) {
        ListNode tmp_node(0); //新建一个头结点
        ListNode *tmp = &tmp_node;
        while (fir!=nullptr && sec!= nullptr)
        {
            if(fir->val<sec->val)
            {
                tmp->next=fir;
                fir=fir->next;
            }
            else
            {
                tmp->next=sec;
                sec=sec->next;
            }
            tmp=tmp->next;
        }
        if(fir!=nullptr) tmp->next=fir;
        if(sec!=nullptr) tmp->next=sec;
        return tmp_node.next;  //注意这里是tmp_node的next，而不是tmp->next
    }
};

152.乘积最大子序列
https://blog.csdn.net/fuxuemingzhu/article/details/83211451
以i结尾的最大乘积为（以i-1结尾的最大乘积当前数，以i-1结尾的最小乘积当前数，当前数）三个数的最大数
以i结尾的最小乘积为（以i-1结尾的最大乘积当前数，以i-1结尾的最小乘积当前数，当前数）三个数的最小数

200.岛屿数量（没看明白）
https://blog.csdn.net/aikudexue/article/details/89672397

207.课程表
自己博客有
https://blog.csdn.net/aikudexue/article/details/89684046

208.前缀树
自己博客有
https://blog.csdn.net/aikudexue/article/details/89712676

215.数组中的第K个最大元素
自己博客有
https://blog.csdn.net/aikudexue/article/details/86602506

221.最大正方形
二维动态规划，可以用二维数组或者两个一维数组或者一个一位数组保存中间结果，后两者在空间复杂度上进行了优化。
参考：https://leetcode.com/problems/maximal-square/discuss/61803/C%2B%2B-space-optimized-DP

状态转移方程：https://blog.csdn.net/u014694994/article/details/80524103
是左边，上边，和右上的变长最小值，因为(i,j)位置上正方形取决于这三个里的最小值，比如左边变长为2，上边变长为3，右上方变长为4，那么（i,j）位置上最大变长只能是3才可以保证该正方形内都是1，如果取变长为3+1=4的话，那么可能正方形内左边部分不是1了

还可以只用三个变量优化为常数空间复杂度，但是会修改原输入矩阵，不用仔细看了 https://leetcode.com/problems/maximal-square/discuss/61811/Clear-C%2B%2B-solution-no-extra-space-12-ms.

236.二叉树的最低公共祖先
自己博客有递归解法，没看懂
https://blog.csdn.net/aikudexue/article/details/89817479

238.除自身以外数组的乘积（不能用除法）
自己博客有
https://blog.csdn.net/aikudexue/article/details/89885036

240.搜索二维矩阵II
自己博客有
https://blog.csdn.net/aikudexue/article/details/89886333

253.Meeting Rooms II

1. 先把intervals按照start从小到大排序。
2. 建立一个最小堆，堆顶是end最小的interval。
3. 遍历interval，把当前interval的start和堆顶的end对比，如果交叉，说明要重新开一个房间，把该interval加入到最小堆中。
4. 如果不交叉，说明之前的房间用完了我可以接着用，所以将堆顶弹出，将该interval弹入最小堆。
   最小堆中的元素数量就是需要的房间个数。
   参考：https://blog.csdn.net/mengmengdajuanjuan/article/details/86289727

279.完全平方数
自己博客有
https://blog.csdn.net/aikudexue/article/details/89889579

287.寻找重复数
自己博客有
https://blog.csdn.net/aikudexue/article/details/89947417

300.最长上升子序列
自己博客有
https://blog.csdn.net/aikudexue/article/details/89950544

309.最佳买卖股票时机含冷冻期
自己博客有股票系列问题的答案
https://blog.csdn.net/aikudexue/article/details/85345481

322.零钱兑换
自己博客有
https://blog.csdn.net/aikudexue/article/details/87825249

337.打家劫舍 III
自己博客有，但是有个部分没看明白
https://blog.csdn.net/aikudexue/article/details/90206956

338.比特位计数
自己博客有
https://blog.csdn.net/aikudexue/article/details/90228934

347.前k个高频元素
自己博客有
https://blog.csdn.net/aikudexue/article/details/86617899

394.字符串解码
自己博客有
https://blog.csdn.net/aikudexue/article/details/90229975

399.除法求值
自己博客有
https://blog.csdn.net/aikudexue/article/details/90378432

406.根据身高重建队列
自己博客有
https://blog.csdn.net/aikudexue/article/details/90601341

416.分割等和子集
自己博客有
https://blog.csdn.net/aikudexue/article/details/90603325

494.目标和
自己博客有
https://blog.csdn.net/aikudexue/article/details/90604010

560.和为K的子数组
自己博客有
https://blog.csdn.net/aikudexue/article/details/90642247

621.任务调度器
自己博客有
https://blog.csdn.net/aikudexue/article/details/90647376

647.回文子串
自己博客有
https://blog.csdn.net/aikudexue/article/details/90669581

739.每日温度
自己博客有
https://blog.csdn.net/aikudexue/article/details/90670884

Hard

4.寻找两个有序数组的中位数
自己博客有

23.合并K个排序链表
自己博客有

32.最长有效括号
自己博客有

42.接雨水
自己博客有

72.编辑距离
自己博客有

76.最小覆盖子串
自己博客有

84.柱状图中最大的矩形
自己博客有

85.最大矩形
自己博客有

124.二叉树中的最大路径和
自己博客有

146.LRU缓存机制
自己博客有
https://blog.csdn.net/aikudexue/article/details/93869657

239.滑动窗口最大值
自己博客有

297.二叉树序列化与反序列化
自己博客有