leetcode面试100道题

时间 2020-05-09 标签 leetcode 面试

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

done 表示写代码完成了 undone 表示看了思路可是没敲代码 predone 是以前作过了，这一次只看没作 neverdone 表示没作也没看node

Easy:

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

predone （20）有效的括号——用栈实现正则表达式

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

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

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

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

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<n。

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

先把intervals按照start从小到大排序。
创建一个最小堆，堆顶是end最小的interval。
遍历interval，把当前interval的start和堆顶的end对比，若是交叉，说明要从新开一个房间，把该interval加入到最小堆中。
若是不交叉，说明以前的房间用完了我能够接着用，因此将堆顶弹出，将该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.除法求值
本身博客有
http://www.javashuo.com/article/p-cpcwfbbk-dk.html

406.根据身高重建队列
本身博客有
http://www.javashuo.com/article/p-gnqfvave-kz.html

416.分割等和子集
本身博客有
http://www.javashuo.com/article/p-rtyfhczx-kw.html