诚实嘚偷包贼拯救世界
- 42,720 次阅读 - 38,041 次阅读 - 37,639 次阅读 - 27,112 次阅读 - 12,305 次阅读 - 7,202 次阅读 - 7,134 次阅读 - 6,282 次阅读 - 5,979 次阅读 - 5,818 次阅读
2017年三月
2016年十一月
2016年一月
2015年十二月
2014年十二月
2014年九月
2014年八月
2014年六月
2014年五月
2014年四月
2014年三月
2013年十二月
2013年十一月
2013年十月
2013年八月
2013年七月
2013年六月
2013年五月
2013年四月题主含泪刷完第一次，精神可嘉！我来给点经验，如何高效地继续刷下去。&br&&br&刷leetcode是为了培养良好的算法题技巧，良好的算法题技巧是什么？&br&&u&0. 正确性&/u&&br&正确性，就是Accepted，是最最基础的。题主“用了一个半月，完全人肉debug，接受率不到20%”的第一次之旅，我想关注的也只有正确性了。&br&&br&那么除了正确性，题主还要注重什么？&br&&u&1. 良好的代码风格&/u&&br&代码简洁明了，变量命名规范，模块之间疏落有致。整体让人舒服，就叫风格良好。&br&&u&2. 合适的时间空间复杂度&/u&&br&很多题目，都不只有唯一解。好的解法，时间空间复杂度通常更低。刷第一次，可能只关注了容易实现的解法，有没有考虑过can we do better？&br&当然，时间空间复杂度“合适”就好，为了压缩它们而让代码无比复杂，也是没必要的。&br&&u&3. 对边界数据和海量数据的关注&/u&&br&测试数据无非三种：1) 常规，用来检查算法基本正确，2) 边界，用来检查是否细心不掉边界坑，3) 海量，用来检查代码的时间空间复杂度有没有超出限制。&br&题主写代码的时候，有没有总结出2)和3)有哪些常见的case？&br&&u&4. 小技巧&/u&&br&诸如能用位运算就不要用乘除法，之类的。小技巧能给你的代码，增添一点逼格。&br&&br&那么问题来了，这些是理论，最佳实践在哪里？&br&对于C++程序员，我会强烈推荐：&a href=&///?target=https%3A///soulmachine/leetcode& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&soulmachine/leetcode · GitHub&i class=&icon-external&&&/i&&/a&&br&看看人家写的代码，无比精简，连全局变量都基本不用（facebook面试官该点赞了~）。对比一下自己的代码，思考不足之处。soulmachine同学的这份题解，大部分代码堪称完美，有些背下来都是应该的。&br&对于Java程序员，因为本人刷题主要用C++，所以也不知道有什么Java题解。不过呢，思路是相通的，上面的题解，参考价值还是很大。&br&&br&第二第三次刷过后，题主应该能做到我的1234要求了。这时候就要：&br&1. 学会巩固&br&巩固的最好方法，就是把题目按照类别，分成小的list。一个list大概七八道题，每天没事复习两个list，&b&记住要敲代码复习，看是没用的&/b&。高端一点，借鉴下艾宾浩斯遗忘曲线，来巩固list&br&2. 进阶&br&算法题进阶，请参考我的这个回答：&a href=&/question//answer/& class=&internal&&大公司笔试面试有哪些经典算法题目? - Zack 的回答&/a&&br&&br&上一张我的进度，上半年前刷完的，现在又出了好多新题：&br&&img src=&/3f26a38a153adfaed959e_b.png& data-rawwidth=&1174& data-rawheight=&355& class=&origin_image zh-lightbox-thumb& width=&1174& data-original=&/3f26a38a153adfaed959e_r.png&&&br&&b&题主加油！你不是一个人在战斗！gogogo！&/b&
题主含泪刷完第一次，精神可嘉！我来给点经验，如何高效地继续刷下去。 刷leetcode是为了培养良好的算法题技巧，良好的算法题技巧是什么？ 0. 正确性 正确性，就是Accepted，是最最基础的。题主“用了一个半月，完全人肉debug，接受率不到20%”的第一次之旅…
我刚做Leetcode的时候，一道 easy 都要想半天，现在除了大多数的hard，一般都能通过。。。&br&大多数的 hard 都是特定领域的问题，如TCP的滑动窗口，编辑距离等。这些如果之前没有做过， 是很难独立完成的。我遇到问题的时候一般到 &a href=&///?target=http%3A///& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&水中的鱼&i class=&icon-external&&&/i&&/a& 找答案。这个博主是 facebook 的工程的，但有些题目他也没法立即想到答案或者最优解。所以别太灰心，好好做，会有收获的。&br&建议一次只针对一种题型进行训练，如数组、链表、二叉树、回溯、动态规划，这样效果会更好。&br&上个图说明我刷得很艰难。。&br&&img src=&/422ca09a09faf_b.jpg& data-rawwidth=&1211& data-rawheight=&471& class=&origin_image zh-lightbox-thumb& width=&1211& data-original=&/422ca09a09faf_r.jpg&&&br&书籍方面《STL 源码剖析》 和 《算法技术手册》会帮你理解最常见的数据结构，查找和排序算法。&br&&a href=&///?target=https%3A///book/siddontang/leetcode-solution/details& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&LeetCode题解&i class=&icon-external&&&/i&&/a&&br&&a href=&///?target=http%3A//blog.csdn.net/linhuanmars/article/details/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&blog.csdn.net/linhuanma&/span&&span class=&invisible&&rs/article/details/&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&
我刚做Leetcode的时候，一道 easy 都要想半天，现在除了大多数的hard，一般都能通过。。。 大多数的 hard 都是特定领域的问题，如TCP的滑动窗口，编辑距离等。这些如果之前没有做过， 是很难独立完成的。我遇到问题的时候一般到
找答案。这个博主…
作为leetcode已通关的少年，我见识过许多优秀的解法，有效地提高了自己的姿势水平。&br&这些解法，典型特征就是精简，很多到了“减无可减”的地步。即使是没学过cs的同学，或许都能感受到，那种简洁洗练的魅力。&br&个人认为，有些太优秀的解法，不用想别的，直接背下来吧，没有比这更好的方法了。&br&Talk is cheap. 下面分知识点，来看看“别人家的代码”：&br&&br&&b&一. 树&/b&&br&&br&&br&1）求二叉树的高度（Maximum Depth of Binary Tree）&br&&div class=&highlight&&&pre&&code class=&language-cpp&&&span class=&c1&&// LeetCode, Maximum Depth of Binary Tree&/span&
&span class=&c1&&// 时间复杂度O(n)，空间复杂度O(logn)&/span&
&span class=&k&&class&/span& &span class=&nc&&Solution&/span& &span class=&p&&{&/span&
&span class=&k&&public&/span&&span class=&o&&:&/span&
&span class=&kt&&int&/span& &span class=&n&&maxDepth&/span&&span class=&p&&(&/span&&span class=&n&&TreeNode&/span& &span class=&o&&*&/span&&span class=&n&&root&/span&&span class=&p&&)&/span& &span class=&p&&{&/span&
&span class=&k&&if&/span& &span class=&p&&(&/span&&span class=&n&&root&/span& &span class=&o&&==&/span& &span class=&k&&nullptr&/span&&span class=&p&&)&/span& &span class=&k&&return&/span& &span class=&mi&&0&/span&&span class=&p&&;&/span&
&span class=&k&&return&/span& &span class=&n&&max&/span&&span class=&p&&(&/span&&span class=&n&&maxDepth&/span&&span class=&p&&(&/span&&span class=&n&&root&/span&&span class=&o&&-&&/span&&span class=&n&&left&/span&&span class=&p&&),&/span& &span class=&n&&maxDepth&/span&&span class=&p&&(&/span&&span class=&n&&root&/span&&span class=&o&&-&&/span&&span class=&n&&right&/span&&span class=&p&&))&/span& &span class=&o&&+&/span& &span class=&mi&&1&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&span class=&p&&};&/span&
&/code&&/pre&&/div&&br&2）判断二叉树是否对称（Symmetric Tree）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Symmetric Tree
// 递归版，时间复杂度O(n)，空间复杂度O(logn)
class Solution {
bool isSymmetric(TreeNode *root) {
return root ? isSymmetric(root-&left, root-&right) :
bool isSymmetric(TreeNode *left, TreeNode *right) {
if (!left && !right) // 终止条件
if (!left || !right) // 终止条件
return left-&val == right-&val // 三方合并
&& isSymmetric(left-&left, right-&right)
&& isSymmetric(left-&right, right-&left);
&/code&&/pre&&/div&&br&3）二叉树-& 链表（Flatten Binary Tree to Linked List）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Flatten Binary Tree to Linked List
// 递归版2
// @author 王顺达(/u/)
// 时间复杂度O(n)，空间复杂度O(logn)
class Solution {
void flatten(TreeNode *root) {
flatten(root, NULL);
// 把root 所代表树变成链表后，tail 跟在该链表后面
TreeNode *flatten(TreeNode *root, TreeNode *tail) {
if (NULL == root)
root-&right = flatten(root-&left, flatten(root-&right, tail));
root-&left = NULL;
&/code&&/pre&&/div&&br&&br&&b&二. 字符串&/b&&br&&br&1）最长无重复字符子串（Longest Substring Without Repeating Characters）&br&&div class=&highlight&&&pre&&code class=&language-text&&class Solution {
int lengthOfLongestSubstring(string s) {
int ans = 0;
int dic[256];
memset(dic,-1,sizeof(dic));
int len = s.size();
int idx = -1;
for (int i=0;i&i++)
char c = s[i];
if (dic[c]&idx)
idx = dic[c];
ans = max(ans,i-idx);
&/code&&/pre&&/div&&br&&br&&b&三. 数组&/b&&br&&br&&br&1）数组中所有数字出现两次，只有一个出现一次，求出它（Single Number）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Single Number
// 时间复杂度O(n)，空间复杂度O(1)
class Solution {
int singleNumber(int A[], int n) {
int x = 0;
for (size_t i = 0; i & ++i)
x ^= A[i];
&/code&&/pre&&/div&&br&2）顺时针旋转二维数组90度（Rotate Image）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Rotate Image
// 思路1，时间复杂度O(n^2)，空间复杂度O(1)
class Solution {
void rotate(vector&vector&int&&& matrix) {
const int n = matrix.size();
for (int i = 0; i & ++i) // 沿着副对角线反转
for (int j = 0; j & n - ++j)
swap(matrix[i][j], matrix[n - 1 - j][n - 1 - i]);
for (int i = 0; i & n / 2; ++i) // 沿着水平中线反转
for (int j = 0; j & ++j)
swap(matrix[i][j], matrix[n - 1 - i][j]);
&/code&&/pre&&/div&&br&&br&3）排序数组去重（Remove Duplicates from Sorted Array）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Remove Duplicates from Sorted Array
// 时间复杂度O(n)，空间复杂度O(1)
class Solution {
int removeDuplicates(int A[], int n) {
if (n == 0) return 0;
int index = 0;
for (int i = 1; i & i++) {
if (A[index] != A[i])
A[++index] = A[i];
return index + 1;
&/code&&/pre&&/div&&br&4）两个排序数组，求中位数（Median of Two Sorted Arrays）&br&&div class=&highlight&&&pre&&code class=&language-text&&// LeetCode, Median of Two Sorted Arrays
// 时间复杂度O(log(m+n))，空间复杂度O(log(m+n))
class Solution {
double findMedianSortedArrays(int A[], int m, int B[], int n) {
int total = m +
if (total & 0x1)
return find_kth(A, m, B, n, total / 2 + 1);
return (find_kth(A, m, B, n, total / 2)
+ find_kth(A, m, B, n, total / 2 + 1)) / 2.0;
static int find_kth(int A[], int m, int B[], int n, int k) {
//always assume that m is equal or smaller than n
if (m & n) return find_kth(B, n, A, m, k);
if (m == 0) return B[k - 1];
if (k == 1) return min(A[0], B[0]);
//divide k into two parts
int ia = min(k / 2, m), ib = k -
if (A[ia - 1] & B[ib - 1])
return find_kth(A + ia, m - ia, B, n, k - ia);
else if (A[ia - 1] & B[ib - 1])
return find_kth(A, m, B + ib, n - ib, k - ib);
return A[ia - 1];
&/code&&/pre&&/div&&br&&br&这些解法，真的是“减无可减”了。&b&（咳咳， 感谢&a data-hash=&d11f4c8b85d8b8e66b5cae& href=&///people/d11f4c8b85d8b8e66b5cae& class=&member_mention& data-editable=&true& data-title=&@宋方睿& data-hovercard=&p$b$d11f4c8b85d8b8e66b5cae&&@宋方睿&/a& 同学给出了一些改进意见，详情见评论。他提到的&a href=&///?target=https%3A///MaskRay/LeetCode/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&MaskRay/LeetCode · GitHub&i class=&icon-external&&&/i&&/a&，请大家和我之后要提到的&a href=&///?target=https%3A///soulmachine/leetcode& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&soulmachine/leetcode · GitHub&i class=&icon-external&&&/i&&/a&进行交叉参考，谢谢~）&/b&多说无益，大家可以对比一下自己的实现。假如觉得有更好的方法，也可以提。&br&至于链表、动态规划、深搜广搜、贪心那些题的解法，可以说道道都有门道。漂亮的解法，就是代码最简单，效率最高。&br&&br&那么——我是从哪儿找到这些解法的？&br&哈哈哈，当然是我深居简出、闭关十年、冥思苦想、绞尽脑汁、两行三年得、一吟双泪流、究天人之际、通古今之变……突然一日醍醐灌顶，打开全球最大的某同性交友网站，找到的啦：&br&&a href=&///?target=https%3A///soulmachine/leetcode& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&soulmachine/leetcode · GitHub&i class=&icon-external&&&/i&&/a&&br&欢迎大家一起来膜拜soulmachine的代码！&br&这份题解，曾经给了我很多帮助，这里推荐给大家，希望更多的同学能得到帮助。同时，大家要记得感谢原作者soulmachine同学的辛勤付出哦~&br&&br&&br&&br&我的其他关于leetcode的回答：&br&&a href=&/question//answer/& class=&internal&&Leetcode刷完了第一次，用了一个半月，完全人肉debug，接受率不到20%，第二次该如何刷？ - Zack 的回答&/a&
作为leetcode已通关的少年，我见识过许多优秀的解法，有效地提高了自己的姿势水平。 这些解法，典型特征就是精简，很多到了“减无可减”的地步。即使是没学过cs的同学，或许都能感受到，那种简洁洗练的魅力。 个人认为，有些太优秀的解法，不用想别的，直接…
&img src=&/v2-49b49f206f17709aa43bddfca6c2f0c4_b.png& data-rawwidth=&638& data-rawheight=&324& class=&origin_image zh-lightbox-thumb& width=&638& data-original=&/v2-49b49f206f17709aa43bddfca6c2f0c4_r.png&&因为之前有在FCC上刷算法题，觉得很有意思。最近在准备面试，所以跑到leetcode练习算法。不料这里的要求不是一般的高，尤其是时间复杂度。好了废话少说，进入正题。&br&&p&&b&一丶&/b&Two Sum&/p&&p&Given an array of integers, return indices of the two numbers such that they add up to a specific target.&/p&&p&You may assume that each input would have &i&exactly&/i& one solution.&/p&&p&Example:&br&&/p&&p&Given nums = [2, 7, 11, 15], target = 9,&br&Because nums[0] + nums[1] = 2 + 7 = 9,&br&return [0, 1].&br&&br&题目的意思：给定任意一个数组，和一个固定值，要求你在数组中找出满足a+b = target的情况，并返回这两个值的索引。当然数组里的元素并非成线性排布。&/p&&p&这是leetcode上的第一题，我当时觉得非常简单，而且和FCC有道题类似。先分析下思路，先固定数组里的一个值，去收索另外一个值，代码也很简单。&/p&&div class=&highlight&&&pre&&code class=&language-js&&&span&&/span&&span class=&kd&&var&/span& &span class=&nx&&twoSum&/span& &span class=&o&&=&/span& &span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&numbers&/span&&span class=&p&&,&/span&&span class=&nx&&target&/span&&span class=&p&&){&/span&
&span class=&kd&&var&/span& &span class=&nx&&len&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span&&span class=&p&&,&/span&
&span class=&nx&&res&/span& &span class=&o&&=&/span& &span class=&p&&[];&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&kd&&var&/span& &span class=&nx&&i&/span& &span class=&o&&=&/span& &span class=&mi&&0&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span& &span class=&o&&&&/span& &span class=&nx&&len&/span&&span class=&p&&;&/span& &span class=&o&&++&/span&&span class=&nx&&i&/span&&span class=&p&&){&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&kd&&var&/span& &span class=&nx&&j&/span& &span class=&o&&=&/span& &span class=&nx&&i&/span&&span class=&o&&+&/span&&span class=&mi&&1&/span&&span class=&p&&;&/span& &span class=&nx&&j&/span& &span class=&o&&&&/span& &span class=&nx&&len&/span&&span class=&p&&;&/span& &span class=&o&&++&/span&&span class=&nx&&j&/span&&span class=&p&&){&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&numbers&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span& &span class=&o&&+&/span& &span class=&nx&&numbers&/span&&span class=&p&&[&/span&&span class=&nx&&j&/span&&span class=&p&&]&/span& &span class=&o&&===&/span& &span class=&nx&&target&/span&&span class=&p&&){&/span&
&span class=&nx&&res&/span&&span class=&p&&.&/span&&span class=&nx&&push&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span&&span class=&p&&,&/span&&span class=&nx&&j&/span&&span class=&p&&);&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&k&&return&/span& &span class=&nx&&res&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&&p&这样的代码是能够AC的，但是速度非常慢，最坏的情况就是索引值在最后两位的情况。只打败了&b&9.10%&/b&的对手。（这里只和JavaScript一门语言比较）。&/p&&p&如果想得到锻炼和提升，肯定不能就此满足，得想办法优化。这里题目有一点瑕疵，没有考虑一个数组中有多组符合条件（a,b），所以后面的优化也只考虑解的唯一性。&/p&&p&下面思考一下，target这个值，如果存在满足a+b = target，即target的值必定大于整个数组的最小值，那么这样就必定存在这样的情况a,b中至少有一个数小于target/2,另外一个数必定大于target/2。那么数组中就有可能存在一个值刚好等于target/2,或者最接近且不大于target/2。那样我们在循环的时候就不用再从头开始遍历了。改进后的代码如下 ：&/p&&div class=&highlight&&&pre&&code class=&language-js&&&span&&/span&&span class=&kd&&var&/span& &span class=&nx&&twoSum&/span& &span class=&o&&=&/span& &span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&numbers&/span&&span class=&p&&,&/span& &span class=&nx&&target&/span&&span class=&p&&)&/span& &span class=&p&&{&/span&
&span class=&kd&&var&/span& &span class=&nx&&i&/span&&span class=&p&&,&/span&
&span class=&nx&&j&/span&&span class=&p&&,&/span&
&span class=&nx&&mid&/span&&span class=&p&&,&/span&
&span class=&nx&&len&/span&
&span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span&&span class=&p&&,&/span&
&span class=&nx&&temp&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&map&/span&&span class=&p&&(&/span&&span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&item&/span&&span class=&p&&){&/span&&span class=&k&&return&/span& &span class=&nx&&item&/span&&span class=&p&&});&/span&
&span class=&nx&&temp&/span&&span class=&p&&.&/span&&span class=&nx&&sort&/span&&span class=&p&&(&/span&&span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&a&/span&&span class=&p&&,&/span&&span class=&nx&&b&/span&&span class=&p&&){&/span&
&span class=&k&&return&/span& &span class=&nx&&a&/span&&span class=&o&&-&/span&&span class=&nx&&b&/span&&span class=&p&&;&/span&
&span class=&p&&});&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span&&span class=&o&&=&/span&&span class=&mi&&0&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span&&span class=&o&&&&/span&&span class=&nx&&len&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span&&span class=&o&&++&/span&&span class=&p&&){&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span&&span class=&o&&===&/span&&span class=&nx&&target&/span&&span class=&o&&/&/span&&span class=&mi&&2&/span&&span class=&p&&){&/span&
&span class=&nx&&mid&/span& &span class=&o&&=&/span& &span class=&nx&&i&/span&&span class=&p&&;&/span&
&span class=&k&&break&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span&&span class=&o&&&&/span&&span class=&nx&&target&/span&&span class=&o&&/&/span&&span class=&mi&&2&/span&&span class=&p&&){&/span&
&span class=&nx&&mid&/span& &span class=&o&&=&/span& &span class=&nx&&i&/span&&span class=&o&&-&/span&&span class=&mi&&1&/span&&span class=&p&&;&/span&
&span class=&k&&break&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span&&span class=&o&&=&/span&&span class=&mi&&0&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span&&span class=&o&&&=&/span&&span class=&nx&&mid&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span&&span class=&o&&++&/span&&span class=&p&&){&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&nx&&j&/span&&span class=&o&&=&/span&&span class=&nx&&mid&/span&&span class=&o&&+&/span&&span class=&mi&&1&/span&&span class=&p&&;&/span& &span class=&nx&&j&/span&&span class=&o&&&&/span&&span class=&nx&&len&/span&&span class=&p&&;&/span& &span class=&nx&&j&/span&&span class=&o&&++&/span&&span class=&p&&){&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span& &span class=&o&&+&/span& &span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&j&/span&&span class=&p&&]&/span&&span class=&o&&===&/span&&span class=&nx&&target&/span&&span class=&p&&){&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span&&span class=&o&&===&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&j&/span&&span class=&p&&]){&/span&
&span class=&nx&&i&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&indexOf&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]);&/span&
&span class=&nx&&j&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&indexOf&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&j&/span&&span class=&p&&],&/span&&span class=&nx&&i&/span&&span class=&o&&+&/span&&span class=&mi&&1&/span&&span class=&p&&);&/span&
&span class=&p&&}&/span&
&span class=&k&&else&/span&&span class=&p&&{&/span&
&span class=&nx&&i&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&indexOf&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]);&/span&
&span class=&nx&&j&/span& &span class=&o&&=&/span& &span class=&nx&&numbers&/span&&span class=&p&&.&/span&&span class=&nx&&indexOf&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&[&/span&&span class=&nx&&j&/span&&span class=&p&&]);&/span&
&span class=&p&&}&/span&
&span class=&k&&return&/span& &span class=&p&&[&/span&&span class=&nb&&Math&/span&&span class=&p&&.&/span&&span class=&nx&&min&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span&&span class=&p&&,&/span&&span class=&nx&&j&/span&&span class=&p&&),&/span& &span class=&nb&&Math&/span&&span class=&p&&.&/span&&span class=&nx&&max&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span&&span class=&p&&,&/span&&span class=&nx&&j&/span&&span class=&p&&)];&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&p&&};&/span&
&/code&&/pre&&/div&&p&这里是按照题目的意思，返回索引先返回较小值。细心的朋友可能注意到这样的一段代码&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&temp = numbers.map(function(item){return item});
&/code&&/pre&&/div&&p&因为JavaScript中数组是引用类型，如果“浅复制”---直接var temp = numbers,后面我们所求的索引就会是排序之后的索引。所以我们这里需要注意下。再次提交看看run time.--&b&71.51%.&/b&比直接快了接近6倍。&/p&&p&再来我们继续优化，看到上面的代码确实速度提升了不少，但是代码量也上去了啊，有没有既满足时间复杂度，又很简洁的代码呢？答案肯定是有的！接着上面的思路，想到了“夹逼定理”，这个定理还在在高中，解决压轴题，我的数学老师给我讲的，一晃这么多年过去了。当时这个定理是为了解决一下很复杂的不等式证明。没想到过今日它还能派上用场。我们设定两个指针i丶j.一个指向数组头部，一个指向尾部。sum = nums[i] + nums[j]。这样我们只需要比较sum 与 target的情况，来移动指针，就可以快速求解。代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&var twoSum = function(nums, target) {
var temp = nums.slice(0);
//等效于上面的nums.map()......
nums = nums.sort(function(a,b){return a-b;});
var i = 0;
var j = nums.length - 1;
while(nums[i] + nums[j] != target){
if(nums[i] + nums[j] & target){
i = temp.indexOf(nums[i]);
j = temp.lastIndexOf(nums[j]);
var index = new Array(i, j);
index = index.sort(function(a,b){return a-b;});
&/code&&/pre&&/div&&p&因为two sum 整个题的唯一性，所以不用看考虑去重已经多个解的问题，这里我重点在于建立思维.我们来看看它的运行速度，结果是75.8%。相比第二种方法，没有多少提升。但是代码却是减少很多。&/p&&p&二丶3Sum&/p&&p&Given an array &i&S&/i& of &i&n&/i& integers, are there elements &i&a&/i&, &i&b&/i&, &i&c&/i& in &i&S&/i& such that &i&a&/i& + &i&b&/i& + &i&c&/i& = 0? Find all unique triplets in the array which gives the sum of zero.&/p&&p&Note: The solution set must not contain duplicate triplets.&/p&&p&For example, given array S = [-1, 0, 1, 2, -1, -4],&br&&br&A solution set is:&br&[&br&
[-1, 0, 1],&br&
[-1, -1, 2]&br&]&br&这里是直接将target的值设为0，而且我们看到，解不在是唯一性，所以要考虑去重。而且leetcode有严格的time控制，不能采用暴力穷举的方式解题。题目中值给了一个例子，但是我在提交的过程中，发现还应该考虑到的一些特殊情况，比如[0,0,0,0],[0,0,0]...等等。&/p&&p&这里我先说下思路：首先我们还是要做排序处理，然后我们固定最小的那个数，剩下的2个数采用和2sum一样的解法，采用夹逼定理求解。但是不同点在于，这里我要去重。因为返回的不在是索引值，而是具体的数值，所以不用考虑“深拷贝”，但是要留意temp[i] = temp[i-1](i!=0),的情况，就跳过下一次迭代 。代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&var threeSum = function(nums) {
var len = nums.
if(len === 3 && nums[0] + nums[1] + nums[2] ===0) return [nums];
var ret = [];
var temp = nums.sort(function(a,b){
return a-b;
for(var i = 0; i & i++){
if (i != 0 && temp[i] == temp[i-1])
var j = i+1,k = len -1;
while(j & k){
var sum = temp[i] + temp[j] + temp[k];
if(sum === 0){
var arr = [temp[i] , temp[j] , temp[k]]
ret.push(arr);
while (++j & k && temp[j-1] === temp[j]) {}
while (--k & j && temp[k+1] === temp[k]) {}
else if(sum & 0){
&/code&&/pre&&/div&那么这个算法究竟有多快呢？标题中的图片已经告诉你答案beats 97.97%.可以说在JavaScript运算中已经极限了！下面我进入第三个问题。&br&&br&三丶3Sum Closest&p&Given an array &i&S&/i& of &i&n&/i& integers, find three integers in &i&S&/i& such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&
For example, given array S = {-1 2 1 -4}, and target = 1.
The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
&/code&&/pre&&/div&&p&这题有点乱入，从题目的意思就是最近 target的值。分析一下，何为最接近的值呢？a+b+c=target.就是最接近。那如果没有这个情况我们要怎么办。这里我们就需要把他转换是成上面那个问题，也就是数学中的化归&b&思想。&/b&何为化归？-----&/p&&p&我记得高中老师这样给我举例。给你一个空壶，一个水缸，一个燃气台。教你烧一壶热水。你会先把空壶装满水，放上去，打开火。然后烧开。接着给你第二个问题。已经有一个壶冷水，叫你烧开。我该怎么做，化归思想就是，先把水倒干净，就得到了一个空壶，我们就回到了第一个问题&/p&&p&那么这里其实也是一个思路，上面的target是固定值0，这里target是任意值，怎么办呢？不如令sum = a + b + c, 用diff = Math.abs(sum - target),和0 做比较。不就回到了3sum的问题了吗？所以代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&var threeSum = function(nums,target) {
var len = nums.
var temp = nums.sort(function(a,b){
return a-b;
var min = Math.pow(2,31)-1;
for(var i = 0; i & i++){
var j = i+1,k = len -1;
while(j & k){
var sum = temp[i] + temp[j] + temp[k];
var diff = Math.abs(sum-target);
if(diff & min){
else if(sum &= target){
&/code&&/pre&&/div&&p&这里说下运算速度，只打败了&b&40.28%&/b&的对手，感觉很意外,我以为会达到60%左右，所以应该有其他办法来优化。这里我暂时还没有想到。&/p&&p&好了，看到这里，你是否有自己的理解了？数学中的有一个重要的方法--“数学归纳法”，既然我们能求2sum,3sum.那么4sum,5sum,nSum...我们有没有办法了？&br&四丶4Sum&/p&&p&Given an array &i&S&/i& of &i&n&/i& integers, are there elements &i&a&/i&, &i&b&/i&, &i&c&/i&, and &i&d&/i& in &i&S&/i& such that &i&a&/i& + &i&b&/i& + &i&c&/i& + &i&d&/i& = target? Find all unique quadruplets in the array which gives the sum of target.&/p&&p&Note: The solution set must not contain duplicate quadruplets.&/p&&p&For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.&br&&br&A solution set is:&br&[&br&
0, 0, 1],&br&
[-2, -1, 1, 2],&br&
0, 0, 2]&br&]&br&第一次我提交的代码严重超时了，因为忽略一个问题，递归其实很费时间，循环次数太多。只是代码很整洁。所以还是把这个不是很好的算法讲讲，当一个错误的案例。分析下思路：先创一个用于递归的help函数，帮我们添加符合条件的子数组到ret里。还会涉及一个临时数组path用于存储目标元素，temp用于复制path,核心代码就是每一次都push一个元素到path里，同时用一个变量表示4个元素的和。以及下一次的索引值，再次带入这个helper函数。所以他需要6个参数，helper（nums, index, path, cursum, target, res）。代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-js&&&span&&/span&&span class=&kd&&function&/span& &span class=&nx&&helper&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&,&/span& &span class=&nx&&index&/span&&span class=&p&&,&/span& &span class=&nx&&path&/span&&span class=&p&&,&/span& &span class=&nx&&cursum&/span&&span class=&p&&,&/span& &span class=&nx&&target&/span&&span class=&p&&,&/span& &span class=&nx&&res&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span& &span class=&o&&&=&/span&&span class=&mi&&4&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span& &span class=&o&&===&/span& &span class=&mi&&4&/span& &span class=&o&&&&&/span& &span class=&nx&&cursum&/span& &span class=&o&&===&/span& &span class=&nx&&target&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&kd&&var&/span& &span class=&nx&&temp&/span& &span class=&o&&=&/span& &span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&map&/span&&span class=&p&&(&/span&&span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&item&/span&&span class=&p&&){&/span&&span class=&k&&return&/span& &span class=&nx&&item&/span&&span class=&p&&});&/span&
&span class=&nx&&res&/span&&span class=&p&&.&/span&&span class=&nx&&push&/span&&span class=&p&&(&/span&&span class=&nx&&temp&/span&&span class=&p&&);&/span&
&span class=&k&&return&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&&span class=&k&&else&/span&
&span class=&k&&return&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&span class=&k&&for&/span&&span class=&p&&(&/span&&span class=&kd&&var&/span& &span class=&nx&&i&/span& &span class=&o&&=&/span& &span class=&nx&&index&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span& &span class=&o&&&&/span& &span class=&nx&&nums&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span&&span class=&p&&;&/span& &span class=&nx&&i&/span&&span class=&o&&++&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&push&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]);&/span&
&span class=&nx&&cursum&/span& &span class=&o&&+=&/span& &span class=&nx&&nums&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&];&/span&
&span class=&nx&&helper&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&,&/span&&span class=&nx&&i&/span&&span class=&o&&+&/span&&span class=&mi&&1&/span&&span class=&p&&,&/span&&span class=&nx&&path&/span&&span class=&p&&,&/span&&span class=&nx&&cursum&/span&&span class=&p&&,&/span&&span class=&nx&&target&/span&&span class=&p&&,&/span&&span class=&nx&&res&/span&&span class=&p&&);&/span&
&span class=&kd&&var&/span& &span class=&nx&&idx&/span& &span class=&o&&=&/span& &span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span& &span class=&o&&-&/span&&span class=&mi&&1&/span&&span class=&p&&;&/span&
&span class=&nx&&path&/span&&span class=&p&&.&/span&&span class=&nx&&splice&/span&&span class=&p&&(&/span&&span class=&nx&&idx&/span&&span class=&p&&,&/span&&span class=&mi&&1&/span&&span class=&p&&);&/span&
&span class=&nx&&cursum&/span& &span class=&o&&-=&/span& &span class=&nx&&nums&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&];&/span&
&span class=&k&&while&/span&&span class=&p&&(&/span&&span class=&nx&&i&/span& &span class=&o&&&&/span& &span class=&nx&&nums&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span&&span class=&o&&-&/span&&span class=&mi&&1&/span& &span class=&o&&&&&/span& &span class=&nx&&nums&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&p&&]&/span& &span class=&o&&==&/span& &span class=&nx&&nums&/span&&span class=&p&&[&/span&&span class=&nx&&i&/span&&span class=&o&&+&/span&&span class=&mi&&1&/span&&span class=&p&&])&/span&
&span class=&p&&{&/span&&span class=&nx&&i&/span&&span class=&o&&++&/span&&span class=&p&&};&/span&
&span class=&p&&}&/span&
&span class=&p&&}&/span&
&span class=&kd&&function&/span& &span class=&nx&&fourSum&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&,&/span& &span class=&nx&&target&/span&&span class=&p&&)&/span& &span class=&p&&{&/span&
&span class=&kd&&var&/span& &span class=&nx&&res&/span& &span class=&o&&=&/span& &span class=&nx&&res&/span& &span class=&o&&||&/span& &span class=&p&&[];&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&.&/span&&span class=&nx&&length&/span& &span class=&o&&&&/span& &span class=&mi&&4&/span&&span class=&p&&)&/span&&span class=&k&&return&/span& &span class=&nx&&res&/span&&span class=&p&&;&/span&
&span class=&nx&&nums&/span&&span class=&p&&.&/span&&span class=&nx&&sort&/span&&span class=&p&&(&/span&&span class=&kd&&function&/span&&span class=&p&&(&/span&&span class=&nx&&a&/span&&span class=&p&&,&/span&&span class=&nx&&b&/span&&span class=&p&&){&/span&
&span class=&k&&return&/span& &span class=&nx&&a&/span&&span class=&o&&-&/span&&span class=&nx&&b&/span&&span class=&p&&;&/span&
&span class=&p&&});&/span&
&span class=&kd&&var&/span& &span class=&nx&&path&/span& &span class=&o&&=&/span& &span class=&nx&&path&/span& &span class=&o&&||&/span& &span class=&p&&[];&/span&
&span class=&nx&&helper&/span&&span class=&p&&(&/span&&span class=&nx&&nums&/span&&span class=&p&&,&/span&&span class=&mi&&0&/span&&span class=&p&&,&/span&&span class=&nx&&path&/span&&span class=&p&&,&/span&&span class=&mi&&0&/span&&span class=&p&&,&/span&&span class=&nx&&target&/span&&span class=&p&&,&/span&&span class=&nx&&res&/span&&span class=&p&&);&/span&
&span class=&k&&return&/span& &span class=&nx&&res&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&&p&代码看起来还是不多，思路也比较容易想，可是AC的时候报超时了。所以需要新的算法来解决这个问题&/p&&p&这里我只提一种解法，也就最后通过了测试的算法。继续延用2sum,3sum的思路，还是先做排序处理，然后固定2个两个数，求出他们的和，用sum = target-a-b来表示剩余2个元素的c,d要满足&target &，即tmp = c + d,这里用tmp和sum来比较差异，再次利用&b&夹逼定理&/b&找到满足的子数组mid,然后创建用于复制的数组ret,。如果只是做了这些工作还远远不够，因为4sum为0的情况要比3sum复杂的多，譬如给定数组[-3,-1,0,0,1,3]那么他的正确结果就是[-3,0,0,3]丶[-3,-1,1,3]丶[-1,0,0,1]。而[-3,-1,0,0,0,1,3]的结果和上面是一样的，所以我们避免这样的情况发生。由于我求解mid数组肯定是按非递减排布的，这里JavaScript应该是没有直接比较两个数组是否相等的办法，而用indexOf也是异常麻烦，既然顺序是一致的那么-1001必定是和-1001想等的，所以我们利用字符串来检查是否存在这样的一个组合，如果不存在，才能push到最后的result中，否则跳过这次循环。代码如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&var fourSum = function(nums,target){
var len = nums.
var result = result || [];
if (len & 4)
nums.sort(function(a,b){
return a-b;
var mid = new Array(4);
var isExit = [];
for (var i = 0; i &len - 3; ++i)
mid[0] = nums[i];
for (var j = i + 1; j & len - 2; ++j)
mid[1] = nums[j];
var l = j + 1;
var r = len - 1;
var sum = target - nums[i] - nums[j];
while(l & r)
var tmp = nums[l] + nums[r];
if (sum == tmp)
var str = &&;
str += nums[i];
str += nums[j];
str += nums[l];
str += nums[r];
itr = isExit.indexOf(str);
if (itr == -1)
isExit.push(str);
mid[2] = nums[l];
mid[3] = nums[r];
var ret = mid.map(function(item){return item});
result.push(ret);
else if(sum & tmp)
&/code&&/pre&&/div&&p&至此leetcode关于Nsum的问题就结束了，觉得写的还可以的朋友点个赞吧，另外也虚心请教有没有更好算法？后续会继续更新有关算法的问题，另外FCC中级，高级算法解析在&a href=&/?target=http%3A///skylin0909/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&成都梁朝伟 - 博客园&i class=&icon-external&&&/i&&/a&&/p&
因为之前有在FCC上刷算法题，觉得很有意思。最近在准备面试，所以跑到leetcode练习算法。不料这里的要求不是一般的高，尤其是时间复杂度。好了废话少说，进入正题。 一丶Two SumGiven an array of integers, return indices of the two numbers such that t…
工作党，没工夫天天刷 LeetCode. 所以每天做一道提提神。&br&&br&1. 早上起来出门前，迅速看一道题。&br&2. 北京地铁不是挤么，它挤它的，你想你的题。&br&3. 太简单，手机上就提交了，联通的 3G 信号要好一点，反正地铁上只能空出一只手，耐心等就好了。&br&4. 如果有难度，那就一直放在脑子里面想，到了公司，一开电脑基本就有答案了。&br&5. 把解决方案放到 Github，答案不是主要的，记录思路，留作日后的总结。&br&6. 晚上睡觉前，反思一下是不是最优解法，有时间的话看看discuss，没时间，把自己的解法理顺了，涉及的知识点再过一遍脑子，就行了。&br&&br&这些步骤，都是被逼出来的，没那么多时间，高效不高效，正确不正确，也只能这样了。&br&分享给诸君，博大家一乐。&br&&br&--------------------------------------------------------------------------------------------------------------------------------------------&br&&b&Update:&/b&&br&目前以这样的方式刷了一半了，每道题都记录了思路，真的感觉基础扎实了不少。&br&另外，如果有时间的话，给自己设计几个测试用例，还是挺锻炼思维的。我用的 &a href=&///?target=https%3A///philsquared/Catch& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Catch 框架&i class=&icon-external&&&/i&&/a&，也推荐给大家。&br&&br&&a href=&///?target=https%3A///pezy/LeetCode& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&pezy/LeetCode · GitHub&i class=&icon-external&&&/i&&/a&
工作党，没工夫天天刷 LeetCode. 所以每天做一道提提神。 1. 早上起来出门前，迅速看一道题。 2. 北京地铁不是挤么，它挤它的，你想你的题。 3. 太简单，手机上就提交了，联通的 3G 信号要好一点，反正地铁上只能空出一只手，耐心等就好了。 4. 如果有难度…
按照下面的tag刷起来挺好的。&br&&br&举个例子：比如复习链表的内容，就选Linked List这部分的23个题目。&br&刷完之后可以再总结一下常用的方法和数据结构构造方式。&br&&br&总之不是为了刷题而刷题啊，是为了弥补一部分的知识去做。&br&希望对题主有帮助。&br&&br&&img src=&/defd2b595cd017d_b.png& data-rawwidth=&226& data-rawheight=&933& class=&content_image& width=&226&&
按照下面的tag刷起来挺好的。 举个例子：比如复习链表的内容，就选Linked List这部分的23个题目。 刷完之后可以再总结一下常用的方法和数据结构构造方式。 总之不是为了刷题而刷题啊，是为了弥补一部分的知识去做。 希望对题主有帮助。
leetcode刷过7次的抢答。&br&当年leetcode才153道题，现在题目数量好像突破200大关了。&br&刷第一次的时候花了两三个星期，简直是全身心的按摩爽到爆炸。&br&刷第二次的时候感觉就不一样了，思路比刷第一次的时候清晰很多。&br&刷完之后感觉还没有参透其中的奥妙，于是乎刷了第三次、第四次、第五次。&br&刷第六次第七次的时候，一天能刷70+道题。&br&刷到后边，感觉这些题目已经倒背如流了。&br&然后歇菜了半年，现在看起来还能记得起其中一部分题目的思路。&br&&br&刷完之后最大的感受就是：&br&&b&practice makes perfect&/b&
leetcode刷过7次的抢答。 当年leetcode才153道题，现在题目数量好像突破200大关了。 刷第一次的时候花了两三个星期，简直是全身心的按摩爽到爆炸。 刷第二次的时候感觉就不一样了，思路比刷第一次的时候清晰很多。 刷完之后感觉还没有参透其中的奥妙，于是…
已有帐号？
无法登录？
社交帐号登录
30242 人关注
1981 条内容
8161 人关注
619 条内容
281 人关注
140 条内容
44220 人关注
2407 条内容
2545 人关注
1120 条内容