12.1.2018
[
12.2.2018
[
12.3.2018
[
[
- 写是写出来了，但是要跑很久，估计会超时。用的还是遍历的方法，需要想一下更快的。
12.4.2018
[
12.5.2018
[
[
[
12.6.2018
[
-
一开始没想清楚，后来提交错误以后一个个加if变得很丑，重新想思路没想出来。
-
这里 是类似题目的巧妙解法，条件简单了一些因为提供了ratio。这题还要再想一下。
[
- small test完成了，large test复杂了很多，想十分钟没想出来，之后继续。
12.7.2018
[
- 看了很机智的答案，还有数学证明23333，复杂度是O(N)的。最简单的就暴力O(N^2)。
[
[
12.8.2018
12.10.2018
- 看了自己以前的答案，太机智了！
- 要多熟悉一下链表的用法
[
[
- 果然是hard型的题目，好好想下噢！
12.11.2018
[
[
- 写出来了但是写了半小时，不够熟练。
12.12.2018
[
[
12.13.2018
[
- 自己没写出来，超机智的方法！！
[
[
[
12.14.2018
- 看了答案w
[
- 机智！！
12.15.2018
- 自己写出来啦，但是看到的方法超简单，四行完成！学会用tuple！
[
[
- debug了很久，想清楚边界条件再写。
- 自己写的递归超时了orz。 跪拜的巧妙解法!!!
- 同上解法。
-
不难，学到了自定义规则来sort的写法。
-
3/24 重写了java版本。注意java自定义sort的方法：
-
class Sort_Start implements Comparator<Interval> { public int compare(Interval a, Interval b) { return a.start-b.start; } } ... Collections.sort(intervals, new Sort_Start());
12.17.2018
- 写了半天
- 多种情况的二分查找要多练练
12.18.2018
- 初始想法是对的，但是没想那么深入。
[
- 寻找substring的template，好好学一下！
- 用上述template成功完成！
[
12.19.2018
[
[
[
12.20.2018
12.21.2018
12.23.2018
今天没刷题...在看声入人心和风味人间...检讨...
12.24.2018
今天平安夜和朋友出去玩了，也没刷题...
12.25.2018
今天圣诞刷什么题呀！
12.26.2018
最后一天划水我发誓，明天开始认真！
quq
12.30.2018
quq
01.11.2019
今天是复习tree的一天!
[
[
[
[
01.14.2019
今天同样是复习tree的一天!
[
[
[
[
[
[
[
01.15.2019
[
[
01.16.2019
[
[
[
[
01.18.2019
跳过了难的，TODO:
[
[
[
01.27.2019
[
[
[
[
[
01.28.2019
[
[
[
[
[
01.29.2019
[
[
[
[
[
[
Season 2
第一波刷题在过年的时候中止了，在二月的最后一天拿到了Yale MS，所以被逼着不得不开始找实习，重新刷题。因为旧的题目可能本身也手生了，所以打算把做过的120道重新再来一遍，之后如果还有时间的话就继续做新题。
开始啦！！！
03.01.2019
-
Add Two Numbers.md
- 一开始写的重复代码段很多，有三个while，里面的代码几乎相同。这点看了discussion以后可以改进。
-
Median of Two Sorted Arrays
- 方法没变，double 类型的除法注意一下。基础都忘了。1/2和1/2.0 能一样吗？？？？
-
Longest Palindromic Substring
- 写了很久，边界条件判断了半天，重写。
- 3/2重写完毕。依然需要看了方法才能想起expand函数。
-
ZigZag Conversion
-
写出来了，但很冗长，最好重写。
-
初始化字符串列表的方法：
L = [""] * numRows -
合并字符串列表的方法：Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
"".join(L)
-
-
Reverse Integer
- 不难，注意小字审题就行，溢出归零。不导入math的时候，指数的写法可以用pow(2, 31)这样。
-
String to Integer (atoi)
- 不难。注意
str[0] == '-'和str[0] is '-'的区别。前者比较是不是相同的字符，后者比较内存空间是不是一样。 - 判断当前char是不是数字：
c.isnumeric() - char转成int:
int(c)
- 不难。注意
-
Palindrome Number
- 不难。记得先判断三种情况。负数直接false；0~9直接true；大于9并且以0结尾直接false。
-
Container With Most Water
-
代码会写，要会解释证明
-
3/4 会证明！
-
-
Integer to Roman
-
Roman to Integer
- 简单。
-
Longest Common Prefix
- 不难，但没有做到bug-free。再写一遍。
- 3/2重写完毕，nice。
-
3Sum
- 如何避免重复没写出来，重写。
- 3/1重写完成。
- 3/2重写完成
-
3Sum Closest
- 原理同上，就算不排除重复也能过，所以重写上面的15就行了。
-
4Sum
- 套用之前用过的3Sum，再加一层即可。再加层的时候有比较巧妙的写法：
- 3/2 重写完毕。
def fourSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[List[int]]
"""
nums.sort()
res = []
for idx in range(len(nums)-3):
if idx != 0 and nums[idx] == nums[idx-1]:
continue
for ite in self.threeSum(nums[idx+1:],target-nums[idx]):
res.append([nums[idx]]+ite)
return res- Valid Parentheses
- 简单！
03.02.2019
-
Merge two link list
- 简单
-
Generate Parentheses
-
没想出来，重写。
-
3/3 没想出来，重写。
-
-
Merge k Sorted Lists
-
Swap Nodes in Pairs
- 不难
-
Reverse Nodes in k-Group
- 还行，比较麻烦。思路是对的。进入reverse函数之前要记得把tail.next置None，不然会持续循环。
-
Remove Duplicates from Sorted Array
-
Remove Element
-
Implement strStr()
- 简单，一次过。
- 这都什么傻子要求啊orz
-
Divide Two Integers
-
之前做的思路就挺好的，速度和内存表现都很好
-
其中判断符号的时候：
# 写法复杂但是计算很快 sign = dividend > 0 and divisor > 0 or dividend < 0 and divisor < 0 # 用乘法比较会慢很多很多 # sign = dividend * divisor > 0
-
-
Next Permutation
- 注意range(50,0,-1)，写法是(start, end, step_length)
-
Next Permutation
-
傻子，重写。如何判断下一次的permutation？
-
如果从末尾往前看，数字逐渐变大，到了2时才减小的，然后我们再从后往前找第一个比2大的数字，是3，那么我们交换2和3，再把此时3后面的所有数字转置一下即可
-
nums.sort()和sorted(nums)的区别 -
3/3重写完毕，一次过。
-
-
Longest Valid Parentheses
- 重写。自己想的方法超时了。之前用的是discussion里面的神仙思路。
stack.insert(0,-1)在stack下标0的地方放一个-1.注意写法。- 3/3重写，1.5次过。
-
Search in Rotated Sorted Array
-
重写。二分查找。怎么查的。这个都不能bug-free，你面什么狗？
-
3/3重写。几乎一遍过，冒号等小细节
-
-
Find First and Last Position of Element in Sorted Array
-
和上面一样。 熟练掌握二分就可以。
-
一遍过。
-
-
Search Insert Position
- 简单
-
Valid Sudoku
- 真是简单粗暴的方法呢。
-
Count and Say
- 不难
-
Combination Sum
- 递归版本写得出来。注意要去重（只取当前index的后半部分即可）。
- 迭代的没想出来，discussion也都是递归，先扔着吧。
- 3/3一开始没递归思路。看了一下以后bugfree一次过。之后多看看~！
-
Combination Sum II
- 和39差不多，注意如何去重。
- 最好重新写一次。
- 3/3一次过。
-
First Missing Positive
- 只记得大概的思路，不过还是写出来了。
- 推荐重写。
- 3/3重写没能一遍过，四处的小bug。打死自己
-
Trapping Rain Water
- 虽然是hard，但是过了。耶。
-
Multiply Strings
- 也过啦，不难。还纠正了以前的错误做法。
- 我真棒！（发出王老舞的声音（×
二分法总结：
- 如果左右两方都会向中间主动靠近，那么while可以写 st <= ed
- 如果有一方不会主动靠近，另一方会:
-
- 如果取mid的时候靠近主动的那边，那么while可以写 st < ed
- 如果取mid的时候靠近不主动的那边，那就只能写st < ed - 1
- 如果双方都不会主动靠近，那么甚至就需要写 st < ed - 1
3.3.2019
-
Jump Game II
- 思路是对的，很多细节没弄清楚。
- 重写！
-
Permutations
- 简单
-
Permutations II
- 简单。去重方法，写过很多次了。
-
Rotate Image
- 简单
-
Group Anagrams
- 简单。一开始不知为啥用了set？？
- 直接
"".join(sorted(word))就可以进行分类了。
-
Pow(x, n)
- 简单。
-
Maximum Subarray
- O(n) slide一遍就可以，简单。
- divide and conquer 的复杂度明明是O(nlogn)？？？写法还复杂，还超时了， 给的都是啥tips啊摔。
- 不过divide and conquer复习熟悉一下也好。
-
Spiral Matrix
- 不难，但是麻烦。
- 不想写，先跳过了。
-
Jump Game
- 和45类似， 写出来了！
-
Merge Intervals
-
用的之前的方法，不太熟练，没有bug-free，建议重写。
-
discussion里面有相同的方法，很多行代码都可以简化的，注意一下。
-
关于如何用自定义的方法来对list排序sort:
-
def takeStart(elem):
return elem.start
intervals.sort(key=takeStart)-
Meeting Rooms II
- 和56类似，简单。
-
Non-overlapping Intervals
- 和56类似但不太一样，推荐重写。
-
Insert Interval
- 简单
-
Permutation Sequence
- 写出来了，但建议重写一下。
-
Rotate List
- 简单模式！
-
Unique Paths
-
简单模式。
-
用Cmn和DP都能做。Cmn可能有些简单到犯规。
-
要注意的点是，Cmn关注的是走动的次数而不是格子的边长，所以要m-1，n-1。而DP关注的是边长，所以只需要m和n。
-
Cmn的公式是
def Cmn(m,n): return factor(m) / (factor(m-n) * factor(n))
-
-
Unique Paths II
- 不难。这个用Cmn就不好写了，所以用了DP。
- 这次i==0/j==0的时候不能直接置1，而同样需要判断
-
Minimum Path Sum
- 不难
-
Plus One
- 简单。
-
Add Binary
- 简单
-
Sqrt(x)
- 不难！同样二分查找即可！
-
Climbing Stairs
- 简单。
-
Simplify Path
- 简单
-
Edit Distance
- 牛逼，机智，重写！
-
Set Matrix Zeroes
- 看了之前的code才有思路的。推荐重写。
-
Search a 2D Matrix
- 第一次错了。第二次重写，也没能bug-free
- 重写。挺复杂的，很多坑。
-
Sort Colors
- 不难，但有个坑没逃过，建议重写。
-
Minimum Window Substring
- 是一个hard系列的，掌握模板好好写。
- 3/3非常认真看了算法以后一遍过了。建议过两天重写加深印象。
3/4/2019
-
Minimum Window Substring
- 写了这题的衍生maxWindow_NoRepeatChar，一遍过，耶！
-
Combinations
- 有一些小bug，重写一下。
- java写了两节课才
-
Subsets
- 逻辑不对，重写。
- 3/7用java写完了，过了终于。java还是不太熟emm。
-
Word Search
- 一个小时，没搞出来，先跳过了。
- 想看table的最后一个维度是不能这样写的！！
table [ : ] [ : ] [idx]。这样写的idx是作用在第一个维度上的！摔！
-
Remove Duplicates from Sorted Array II
- 有个坑和之前的排列00011112222很相似。要注意一下。
- 3/7重写。妈的discussion里面的一个方法简直了，是人吗？？？重写重写！！！
- java遍历数组的方法可以是
for (int n : nums)其中nums是int[]
-
Search in Rotated Sorted Array II
- 很经典的题，有空可以重写。
- python跑出来没过但是我以为我过了，ed初始化的时候要注意是
len(nums)-1 - 3/7重写，第五次终于过了，重写重写重写我靠！ed和st移动的时候怎么移好好考虑好吗傻子！
-
Remove Duplicates from Sorted List II
- 不用重写。同理三个指针依此往后移。
if second.val == third.val or second.val == pre:
-
Remove Duplicates from Sorted List
- 82的easy模式，一次过。
-
Largest Rectangle in Histogram
- 太难了太难了太难了。酌情重写吧。
- 除了O(n)以外的时间复杂度，都超时了。
-
Partition List
- 简单一次过
-
Gray Code
-
找到规律就很简单
-
注意
tmp = [1,2,3] tmp.append([4,5]) # [1,2,3,[4,5]] tmp += [4,5] # [1,2,3,4,5]
-
-
Subsets II
-
自己写的那个有点慢，__ contains __复杂度有点高所以最好不要用
-
有很好的递归方法，看懂之后重写。
-
🔆 java如何sort int[] nums:Arrays.sort(nums); -
java还没写出来
-
-
Decode Ways
- 动态规划，一次过。
-
Reverse Linked List II
- 链表，一次过。
-
Binary Tree Inorder Traversal
- 树的遍历。前序+后序+中序+层次，递归和迭代，都要能写！
- 3/8 java过了
-
Unique Binary Search Trees II
-
自己写出来的。不过推荐重写一下。
-
3/8 写了个java 有点艰难 不过还是写出来了
-
-
Unique Binary Search Trees
- 和95差不多，不过只需要返回个数就行了。如果直接改95的代码会超时。
- 可以用一个list保存当前n个节点的树可能的个数，这样就不用重复计算了。
-
Interleaving String
- 有了DP的思路之后就不难做了。
- 开始逐渐用java和python一起写。
- 冒号分号分不清楚，要习惯！
- 关于java里面的length()和length
// length can be used for int[], double[], String[]
// to know the length of the arrays.
// length() can be used for String, StringBuilder, etc
// String class related Objects to know the length of the String
3/5/2019
- Validate Binary Search Tree
- 中序遍历可以做，但是比较慢
👈 一次过 - discussion的递归比较好用
👈 重写（python & java） - 3/8重写一次过。注意这里要用Long.MAX_VALUE
- 中序遍历可以做，但是比较慢
// java 里面的最大最小值
Long.MIN_VALUE,Long.MAX_VALUE
Integer.MIN_VALUE, Integer.MAX_VALUE- Recover Binary Search Tree
- 太难了，discussion有很好的方法。
- 想清楚，重写。
- 3/8 果然是hard模式emm。看了思路才一遍过。重写重写。
# python里面的最大最小值可以这么写
self.preNode = TreeNode(float('-inf'))
# swap是引用指针，所以要修改val才有效，不然就只改了指向
swap[0].val, swap[1].val = swap[1].val, swap[0].val-
Same Tree
- 一遍过
-
Symmetric Tree
- 递归和stack都能做，一遍过。
-
Binary Tree Level Order Traversal
- 简单一遍过
-
Binary Tree Zigzag Level Order Traversal
- 简单模式 一遍过
-
Maximum Depth of Binary Tree
-
递归只用一行哈哈哈哈哈哈一次过。不过在公司这么写会被打吧哈哈哈哈哈哈。
-
return max(self.maxDepth(root.left),self.maxDepth(root.right)) + 1 if root else 0 -
3/8写了个java一行操作，注意java的max需要用Math.max(int a, int b)。然后a和b需要是同类型。
-
return root==null ? 0:1+Math.max(maxDepth(root.left),maxDepth(root.right));
-
-
Construct Binary Tree from Preorder and Inorder Traversal
- 递归 一遍过（python
- java的递归写了一百遍，重写。
- 3/8 java的递归再次写了一百遍。我靠st和ed好好算会死吗？？？
-
Construct Binary Tree from Inorder and Postorder Traversal
- 和105一毛一样的思路
- java写了一遍，稳。
-
Binary Tree Level Order Traversal II
-
思路继续一样。然后从后面往前数，append或者+= 的时候有几种写法都可以，注意一下。
res[len(res)-idx].append(node.val) res[len(res)-idx] += [node.val] res[-idx] += [node.val]
- string是没法用append/insert的，只能用加号。
- list是可以用append/insert的，同时加号也能用，但是注意加号左右都应该是list。
tmp = '123' tmp.append('456') # ❌ tmp.insert('456') # ❌ tmp += '456' # ✅ tmp2 = range(10) tmp2.append(11) # ✅ tmp2 += [11] # ✅ tmp2 += 11 # ❌
-
-
Convert Sorted Array to Binary Search Tree
- 一次过。
-
Convert Sorted List to Binary Search Tree
-
对于链表没法直接得到最中间的元素。那么用fast和slow方法就非常有效了！discussion太机智了！
-
重写重写，搞了半天，反思。
-
3/8重写，几乎一遍过。一些小细节。
-
-
Balanced Binary Tree
-
第一次没想出来。重写。想清楚helper实现的功能是什么？
-
3/8 一次过。
-
-
Minimum Depth of Binary Tree
- 重写。min-depth的定义好好看看？？
- 3/8 java重写完。几乎一次过。
-
Path Sum
-
差点一次过。题目判断空树的和没法为0.
-
if的数量最少3个就够了。
-
java比python不知道快到哪里去了。
-
3/8 一次过
-
-
Path Sum II
- 一遍过 不难
-
Flatten Binary Tree to Linked List
-
一遍过，用了两个stack，一个用来preorder遍历，一个用来存node。
-
然后遍历第二个，构造类似linked list的结构即可。
-
discussion里面有间接版本的，但是我没看懂，嗯。
-
-
Distinct Subsequences
- 想法是对的，用DP。如何构造table的时候要想清楚各自的含义！
- 重写！
- 3/8 java一次过！
-
Populating Next Right Pointers in Each Node
-
自己写的，层次遍历之后算出每层的个数然后指过去（因为是完全二叉树)。空间复杂度O(n)了。
-
discussion里面有超简单的方法！重写！
-
3/8 一次过
-
3.7.2019
-
Populating Next Right Pointers in Each Node II
-
没看懂discussion
-
想一下以后写。
-
3.8.2019
把之前标记要重写的题重写了。继续往下啦！
-
Pascal's Triangle
-
java一遍过。
-
List<List<Integer>> res 获取某个元素的方法是 res.get(0).get(0)
-
-
Triangle
-
曾经想出来过，不过也不难。可以重写。
-
java里面 整数类型（byte、short、int、long）的基本类型变量的默认值为0
-
3/20 一遍过，但是第一遍没有用最简单的方法，第二遍才。
-
-
Best Time to Buy and Sell Stock
- 没思路，有了就很简单。重写。
- 遍历一次就好了。
- 3/20 一次过
-
Best Time to Buy and Sell Stock II
-
五行就行，重写一下。
-
3/20 一遍过
-
-
Binary Tree Maximum Path Sum
- 有点tricky，重写。
-
Valid Palindrome
- 我靠java对char的操作太tm麻烦了
- 当然可以先对s进行变换之后再在char的单位上来比较，会简短一点。
- 3/20 几乎一次过 忽略了数字也应该要比较这件事儿
Character.isLetter(ch) //判断是不是字母
Character.isLetterOrDigit(s.charAt(ed)) //判断是不是数字或者字母
Character.toLowerCase(s.charAt(st)) //大小写转换
//然后因为char是一个primitive而不是object，所以他没有任何的属性，所以不能用ch.isLetter()，只能用Character.isLetter(ch)3.11.2019
-
Longest Consecutive Sequence
-
看了思路之后python一遍过，重写。
-
3/20 重写一遍过
-
-
Sum Root to Leaf Numbers
- java一遍过。
-
Surrounded Regions
-
先跳过，感冒了脑子不转了，之后做。
-
3/20依然不想做 什么傻子题目...
-
-
Palindrome Partitioning
-
java操作string不够熟练，两次过，重写。
java的s.substring(1)相当于python的s[1:]。
java的s.substring(0,1)相当于python的s[0:1]。
如果s的长度是len，那么s.substring(len)是合法的。
3/20 重写 一次过。
-
-
Palindrome Partitioning II
- DP即可，有坑注意。3/20几乎一次过。
-
Clone Graph
- 图论里面经典的算法，要掌握的。
- 3/20没能一次过 我的锅
-
Gas Station
-
java几乎一遍过。但是很慢。
-
discussion里面是什么神仙方法啊 看不太懂但是直觉告诉我是可以的
-
3/20 一次过
-
-
Candy
- 我记得当时也是有非常tricky的方法，想不起来了。
-
Single Number
-
java 异或 一遍过
-
java用map的基本语法还不太熟，多看看。重写。
-
3/20一遍过
-
-
Single Number II
- 一遍过
- 3/20 ↑什么一遍过，效率极低的一遍过orz。discussion里面有正统的写法，暂时没懂。要再看看。
-
Copy List with Random Pointer
- 竟然java一次过了我简直！！
- 3/20 递归和迭代都行了，迭代会麻烦一点。
-
Word Break
- 看了discussion里面动态规划的方法，重写重写。
- 但是复杂度是O(n^2)，击败了48%感觉有点慢？
-
Linked List Cycle
- 一次过。fast和slow果然非常好用啊！
-
Linked List Cycle II
- 看了原理之后一次过。看过之后会证明了，但是第一次没想出来。
- 3/21 一次过
-
Reorder List
- 比较麻烦，不过一次过啦开心！
以上都是之前做过的题，这样就算过过两遍了！
以后是新的题目，第一次做!
[
- 树的遍历，简单一次过
[
- 树的后序遍历，一次过。
[
- 自己写出来的，但是初次逻辑不太对。
- 需要挺多变量的，弄清楚。
- 3/20一次过 没啥问题...
[
- 不难，小麻烦，熟练了就行。
- 3/20 重写一次过。
[
- 奇怪的题目，先跳过。
[
- 思路是对的，但是没能一次过，重写。
- java的String没法直接比较是不是数字，除非转成char一个一个比，或者用正则表达。
- java里面String的比较，应该用s1.equals(s2)。== compares object references in Java, and that is no exception for String objects. For comparing the actual contents of objects (including String ), one must use the equals method.
- 如何把string转num：
Integer.parseInt(c) - 3/20重写，还挺好写的啊明明。注意使用stack还是queue就行了（显然是stack的。
3.12.2019
[
- 自己写的，但是没能bug-free。
- 3/20 依然没能bugfree 不过换用了stringbuilder的方法
[
- 看了discussion，DP非常好用！
- 3/21 一次过
[
- 没啥难度，一次过。
[
- 移动时候的条件判断要注意，写了很多次才通过的。重写。
- 3/21 重写。bugfree失败。重写
- [2,2,2,2,0,1,2] 和 [2,0,1,2,2,2,2,2]
[
- 自己写的一次过但是慢，空间复杂度还是O(n)。discussion的方法无敌好了。
- 3/20 还记得做法 一次过 耶
[
- 自己写的O(n)，discussion里面的O(logn)
- 3/21 重写，还是没想出来。傻子。
[
- 太难了 跳过先
[
- 题没啥难度。注意java的s.split("//.")里面跟的是正则表达，服了。
- 3/22 差不多一次过。注意1.1.0和1.1被认为是一样的。
[
- 简单一次过。
[
- 对26取余的时候如何保证得到[0,25]之间的值？
- StringBuilder这么好用为什么不学？？同文件夹下有个java_3150103638_hw1的pdf，里面是当时java的作业，分析了String+StringBuilder+StringBuffer的区别。
- 3/22重写 还是不太明白 不够intuitive
The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the
StringBuilder(orStringBuffer) class and itsappendmethod. String conversions are implemented through the methodtoString, defined byObjectand inherited by all classes in Java.
[
-
思路简单，为了熟悉map操作可以重写。
-
3/22 用类似抵消原理重写了 有一个小地方失误 然后一遍过
-
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>(); if(map.get(i)!=null) map.replace(i,map.get(i)+1); else map.put(i,1); ... for(int i : map.keySet()) ...
3.13.2019
[
[
怎么回事中间有一堆SQL的题目...跳过了先。
[
- 想不出，没太想，先跳过。
3.14.2019
[
- 自己也能写，但是时空复杂度没法同时达到最优。有了想法就很简单了。
- 3/22 一次过!
[
- 3/22 一次过!
[
192~197都是bash或者SQL的，跳过。
[
[
- 3/22 偷瞟了上次的过程才写出来的dbp.再重写吧
[
3.15.2019
[
- 重写重写，想清楚先。
- 3/28 一次过
[
[
[
- 3/28 偷瞟了一眼之前的答案之后过了（fine
[
- 3/28 一次过!
[
-
新建一个空int[]的方法包括：
res = new int[]{}; res = new int[0];
3.16.2019
[
-
要好好写。graph的基本知识，重写重写。
-
3/20 基本的数据结构一开始有点懵逼要怎么写
ArrayList[] graph = new ArrayList[numCourses];真是奇妙的存在。偷瞄了数据结构之后就会写了！
[
- 没搞懂，啥玩意儿。感冒没心思看，跳过了先。
[
- 是之前做过的 max substring类型的题目
- 3/28 小的边界条件要多注意下
[
[
- 3/29写还行？java的切片不熟就直接传入st和ed好吧。
3.17.2019
[
- 自己写的但是bug挺多，重写
- 3/29 自己重写 还是没能一次过emm
- string是没有reverse方法的，需要根据string构造stringbuilder然后reverse然后转回string
- 在UCB群里看到的KMP算法用于匹配字符串
[
-
基本数据结构！算复杂度！好好想！java的priorityqueue。
-
3/29 一次过
[
[
java如何sort int[] : Arrays.sort(nums);
[
- hard题先跳过了
[
[
- 太机智了我靠
- 3/29 到处踩坑我靠，重写重写重写。要用long。map映射的应该是什么？？k和t的含义分清。remove的时机。
[
- DP 原创太难了
- 3/29 一次过
[
层次遍历的时候要用的堆可以直接Queue<TreeNode> queue = new LinkedList<>();
其中包括的操作有
queue.peek()//返回第一个元素
queue.poll()//返回第一个元素并删除
queue.offer(2)//放入新的元素具体请戳文档!
[
- 自己写的太慢（O(n)），重写(O((log(n))^2))。
- 3/22 一次过！
[
- 自己写的太慢，其实可以公式直接算。
- 3/22 记得公式了，没写。五行的事儿写啥啊。
[
3.18.2019
[
-
写出来的，再次熟悉一下queue的用法。
-
3/29 不难一次过，还只用一个queue，节约了空间
-
queue = new LinkedList<Integer>(); queue.offer(x); res = queue.poll(); while(!queue2.isEmpty()) while(queue.size()>1)
[
- 递归迭代要都能写。
[
[
- 摩尔投票法了解一下
- 3/29 没一次过 想清楚啊啊啊
[
- 普通做法
✅ ，机智做法⭐ - 3/29 普通和机智做法都一次过啦√
[
-
stack的基本操作(peek pop push)了解一下，和225几乎一样。
-
3/29 一次过
-
Stack<Integer> stack2 = new Stack<>(); while(!stack.isEmpty()) stack2.push(stack.pop()); int res = (int)stack2.pop(); int res = (int)stack2.peek();
[
- hard不想做 跳过
[
- 应该可以bugfree的题目，注意reverse的时候一开始的指针要置null啊多少次了！！
- 3/30 指针没问题了，空链表的情况注意
[
[
- 啥子题目哟
[
- 要多考虑考虑嗷
- 3/30 用了division的方法一次过，note里面不用division的方法，看了discussion以想通了也一次过。
3.19.2019
[
- 超机智的做法！！重写！！
- 行吧3/31 自己想了半天还是没太想通，看代码才勉强弄懂。晚上写一下。
[
[
- 3/31 看了一下之前的tips之后写出来的 还是没记住唔quq
[
- 一个长度为len的数组，里面存的是乱序的[0, len-1]。要求sort，但是只能调用函数SwapWithZero，功能是交换数字n和数字0的位置。
- 想了一会儿，一次过。
[
- 如何把int变成string：
Integer.toString(root.val)
[
- 如何把int变成string：
Integer.toString(root.val) - 如何把string变成int：
Integer.parseInt("2333")
[
[
- 不难，注意边缘条件（1和0）即可。
- 3/31 轻松一次过！
[
- discussion里面的机智方法，好吧~
- 3/31 如何防止重复没想出来，重写重写。
[
[
- 还没看和整理
3.23.2019
[
- 自己写的，但是写了太久了...
3.24.2019
[
-
放个星星买教训orz 佛了
-
int mid = st+(ed-st)/2; //这个正常 int mid = (st+ed)/2; //这个如果是两个大数的话会越界
- small过了，large没过
[
- small过了，large没过
- small没过，large更没过
- 你菜死算了
3.27.2019
- 检查了复杂度O(N)的方法，想得到的话也不太难emm
4.1.2019
[
4.3.2019
[
[
[
-
自己想了挺久才写出来的。但是没有满足不修改nums的要求。
-
discussion里面的方法简直牛逼。重写！
[
- 挺straight的方法，不难。
- 如何用已有数据初始化数组
int[][] dir ={{1,-1},{1,0},{1,1},{0,-1},{0,1},{-1,-1},{-1,0},{-1,1}};
[
- 老样子万用的map，两次过。条件判断的时候稍微注意下顺序就行。
[
[
- 想不通为啥这是hard，每次二分查找后插入不就好了。
- list在指定的下标插入数据用list.add(idx,num);
4.3.2019
[
-
写的用null填满list的方法超时了emm，重写！！
-
如何把int[] 变成ArrayList:
-
Deque<String> nodes = new LinkedList<>(); nodes.addAll(Arrays.asList(data.split(spliter)));
[
4.4.2019
[
- 自己写的是DP，复杂度是n平方。
- discussion里面是nlogn，这个可以重写。
- 4/20 没想出来 看了之前的过程才写出来哭
4.8.2019
[
- 想不出来，还没看答案
[
[
[
- 自己写的，挺有趣的一道题，坑比较多，注意一下。重写。
[
- 太难了又太机智了，想想清楚！重写！
4.9.2019
[
-
图的遍历，自己写的超时了orz，但是思路是对的。不超时的方法要重写！
-
// 关于map如何遍历value和key： for(int root : map.keySet()) for(int dist : map.values()) // 关于如何复制int[] int[] tmp = res.clone();
[
[
[
- 我几乎和这道题磕了一天，死。
4.10.2019
[
- 贪心算法行不通，哭。要再想想。
[
[
- 思路一样，数据存储方式的差别会导致速度50%和90的差别%。
- （我写的当然是50%了（理直气壮
- 所以重写。
4.11.2019
[
- 昨天只写出来了数字不重复的版本，重复的测试没过，要再想想。
- 今天看了discussion终于弄出来了，不容易啊quq。
4.12.2019
[
- 没想出来，重写。
4.14.2019
[
- 理解了应该不难，还没看解释。
[
- 这么简单还没能一遍过，菜
- 用不用循环两种方法都写下
[
- 暂时还是只有O(n^2)的方法，行吧
4.15.2019
[
- 简单模式
[
-
DP!!写！！
-
// 如何初始化final高维数组 private static final int[][] dirs = {{0,1},{0,-1},{1,0},{-1,0}};
[
- 自己写了个但是超时了嗯
- 后来认真寻思了一下题目！！！写出来了！！！！我牛逼！！
[
- 自己写出来的耶！一些边界情况注意一下，别的就没啦！
4.16.2019
[
- 拓扑遍历图的方法，完全忘了，重写。
[
- 非常机智的方法！本来应该想得出来的！重写！等号的边界条件要注意。
4.17.2019
[
- 太难了这题我真的，看discussion的算法和trie tree的结构看了半天。
- trie tree了解一下大概就行了quq。
[
- 递归过了，但是比较慢，有很多重复计算。
- 如何避免重复计算。
[
- 自己想的，两遍过。边界条件注意下。
4.18.2019
[
[
[
[
- 思路是对的一遍过， 不过用stringbuilder不如用char[]。
- 关于String的valueOf函数用法戳这里。
//如何初始化set
String[] SET_VALUES = new String[] { "a", "b" }
Set<String> MY_SET = new HashSet<String>(Arrays.asList(SET_VALUES));
// string 2 char[]
String s = "hello";
char[] list=s.toCharArray();
// char[] 2 string
return String.valueOf(list);[
-
hashmap是put，hashset是add，arraylist是add
-
如何自定义comparator来写priorityqueue！！！
-
java也有map default的写法：
-
map.put(nums[i],map.getOrDefault(nums[i],0)+1);
[
-
算法待改进
-
复杂度O(n)还改进啥啊，题目太菜了。
[
4.20.2019
[
- 太难了真的，完全想不到...
[
- 数学题。
[
- 傻子暴力搜索算法
4.21.2019
[
- 一道数论的数学题，fine。
//寻找最大公因数的辗转相除法
private int GCD(int x, int y)
{
while(y!=0)
{
int tmp = y;
y = x % y;
x = tmp;
}
return x;
}[
- 简单题，有三种做法，可以想想
[
- 难题，还tricky，多想想。
[
- 指数可以super super大噢，好好想下。
4.23.2019
[
5.6.2019
[
- O(n^2)不难，O(n)的方法想通了也不难
[
- dp大法好
[
[
- 还是PriorityQueue Comparator写的不熟。
5.7.2019
[
[
[
[
第二波刷题在找到五月实习入职前中止，实习实在太太太太太忙了暂时不刷了。
下次刷题时间段在暑假离职之后到找到全职之前，大概八月份开始，不知道啥时候结束。
机灵 2019.5.24
我回来了！
2019.7.27
7.27
[
根据map的提示，思路顺，一次过。
[
思路顺，一次过。
[
更新max_len的位置欠考虑，三次过。
7.27
[
O(n+m)的两次过，边界条件第一次没考虑好。
O(lg(n+m))也两次过，同边界条件。
[
一次过。
7.28
[
一开始在纸上写了下，想着用queue可行，但坑太多了。三次没过。
后来还是生成numRows个字符串然后拼接起来更快。两次过。
拼接: ''.join(res)
[
思路对，一次过。
奇怪的题目，因为下标越界的错，两次过。
[
思路对，一行的写法是 return str(x) == str(x)[::-1]。
不然就reverse int之后比较数字，特殊情况是<0, [0, 9], x % 10 == 0的时候。
python int→string是str(134)
[
方法思路对，一次过。
证明方法没想出来。
7.29
[
方法思路对，一次过。
[
第一次把TwoSum作为函数，写的有点乱，改了几次才过。当有一串重复数字的时候，前面的直接加入map不判断，只判断最后一位即可。倒过来就不行。要构造n次map所以一定很慢了... 用三个指针就能解决，注意重复问题就可。
7.30
[
递归遍历即可，思路对，两次过。
迭代也不难。
[
借ThreeSum，思路对，两次过。
[
输入head是第一个node，习惯性自建一个dummy指向head，不要搞混就好。
思路对一次过。
[
思路是对的但是小问题有点多。
python的False首字母大写。
[]可以实现堆栈先进后出的append()和pop()功能
要用先进先出的queue的话，需要
from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")
queue.popleft()[
轻松！
7.31
[
迭代有点小难，改了几次才过。
我猜我之前是递归做的，明天看下！
我回来了。递归不会写，重写！
[
不看效率的话是easy题，遍历合并即可，复杂度是node总数*list个数。
要提升效率的话，每次做两两合并，复杂度是list长度*log(list个数)。
[
没有难度，注意指针后移的时候需要按照交换后的顺序即可。
[
思路对，一次过。
[
思路对，一次过。
[
不太懂26和27的意义和难点在哪儿...
8.1
[
我还是不懂难点在哪儿...
[
思路对，一次过
[
这题挺好的，很多坑。怎么选取要交换的下标，怎么替换。
[
猜到了会出怎样的用例来测超时（但还是超时了，fine
写了最原始的暴力搜索，和带一些DP的暴力搜索，但都超时了。
看了看记录之前也是看答案的，答案的解法真的amazing!
8.2
[
在公司刷题还是有点虚，全是错，这里错那里错，回去重写。
[
没难度，两次过。注意下二分查找的边际条件即可。
[
easy题，一次过。
[
easy题，一次过。
8.3
[
递归，自己没写出来。同一个元素可以用多次的情况下， 如何避免重复？
[
39能写40就能写。
[
我记得之前的方法，就很绝，感觉无法超越。
[
hard，思路对一次过。
[
思路对，逐位乘，一次过。
[
想了一个DP的解法，但是超时了。
解法在这里，今天不想动脑子，明天看。
[
可以，hard题一次过，我要飘了。
[
想了一会儿递归的方法，然后过的。和39一毛一样。
[
同46
[
8.4
[
字符串按照字母顺序重新排序的方法是 "".join(sorted(str))
[
思路对一次过。节约时间的方法。
[
[
思路对一次过。注意需要选择至少一个元素。
[
思路对一次过！状态机，好用！
[
方法不难。自定义python排序的方法写法：
def getStart(interval):
return interval[0]
intervals.sort(key = getStart)[
有个问题是，string结尾有空格的情况下，split的最后一项会有一个长度为零、打印不出的符号（换行符）
需要用一下strip()处理。
[
和54一样的题，思路对一次过。
[
思路对，但是有点绕，不过写出来的。
看了一眼之前的解法，可以不用map实现，每一位逐步计算就可。
[
简单。
[
用cmn函数就能实现，没有难度...
DP也可，但有公式可以直接算就没必要浪费空间了。
[
用DP，没难度。
[
没难度++
8.5
[
简单题，没难度。用了两种方法。
[
简单题，考虑好边界条件，一次过。
[
DP，甚至不用建表，因为只依赖前两个状态。
[
done。
[
很绝的DP，导致我记到现在。一次过。
[
Space O(m+n)的很好写。
Space O(1)的也能写，但有点取巧了。
不管，过了反正。
[
思路对，写的时候return -1 还是return True有点绕。别的问题不大。
两次过。
[
两次过，出了个bug。想一想。
8.6
[
啊思路对但是没写出来。十点了下班了明天再说。
重写了两次才过。重写重写。
[
思路对，两次过。
[
思路不对，两次过。这里使用了递归就不需要在外层遍历了。
8.8
[
写出来了但是有点绕，并且超时了。
看了dis里面的递归，很绝，但也超时了。
[
要考虑在原数组被改变的情况下怎么保持判断个数的正确性。两次过。
[
[
看看这提交记录是什么绝世没有长进的傻子。
不要锁死在二分查找上> <
| Time Submitted | Status | Runtime | Memory | Language |
|---|---|---|---|---|
| a few seconds ago | Accepted | 40 ms | 12 MB | python |
| 2 minutes ago | Wrong Answer | N/A | N/A | python |
| 7 minutes ago | Wrong Answer | N/A | N/A | python |
| 12 minutes ago | Wrong Answer | N/A | N/A | python |
| 15 minutes ago | Wrong Answer | N/A | N/A | python |
| 16 minutes ago | Wrong Answer | N/A | N/A | python |
| 5 months ago | Accepted | 0 ms | 37.8 MB | java |
| 5 months ago | Wrong Answer | N/A | N/A | java |
| 5 months ago | Wrong Answer | N/A | N/A | java |
| 5 months ago | Wrong Answer | N/A | N/A | java |
| 5 months ago | Runtime Error | N/A | N/A | java |
| 5 months ago | Runtime Error | N/A | N/A | python |
[
思路对两次过，有点麻烦。最后注意指向None即可。
[
easy版本的83
[
8.13
[
[
两种方法，另外开数组和原地挪动都可，后者空间要求更小。反过来遍历即可。一次过。
[
方法还挺微妙的，想的时候想起来了之前自己的做法，一次过。
[
没写出来！看了之前的过程！
8.17
[
自己写出来，但是卡bug了几次。需要考虑valid的两位数不能是0开头。以及可以优化DP的过程（空间复杂度减到O(1)
[
木有难度
[
[
[
树的遍历系列！
8.18
[
递归我可以，但是两次过。考虑一下空树要怎么写。
[
第一遍用了95里面的递归，返回类型改成了int，超时。
第二遍依然用的递归，只是开了一个表记录了之前计算过的值，超时。
第三遍放弃模拟树的生成过程，DP不好吗！？
[
是我自己想出来的hard题呜呜呜感动。
写的比较久，[[]]来表示矩阵还是不够熟练，DP大法好。
[
巧妙!
8.23
[
[
[
[
以上都是树的简单题，递归一次过。
8.24
[
递归不难两次过，注意一下判断的边界条件。
[
和105一样的做法
[
递归一次过
[
[
为什么今天的题都毫无难度。
8.26
[
[
有个递归时候变量生命周期的问题。
[
[
DP好用，一开始想错了 table[h][l] = table[h-1][l-1] + table[h][l-1]
[
[
和116类似，另外维护一个stack即可。116两次过，117两次过
8.28
都一次过
[
[
[
这个有点难，我想不到。
[
8.29
一题一题做进度有点慢，从之前打星的题开始了。
[
转成set很机智的做法了...看了解析
[
[
DP做，超时了；dfs做，也超时了。
[
重温了一下graph相关的遍历...
[
[
[
[
[
[
真是毫无挑战呢。
[
下一题就打脸哈哈哈哈哈哈哈哈哈哈哈。改了三次才过。
[
我又可以了
我能写，但是要口述原理的话要想想
为什么二分查找大的那一半一定会有峰值呢？（即nums[mid]<nums[mid+1]时，mid+1~N一定存在峰值） 我的理解是，首先已知 nums[mid+1]>nums[mid]，那么mid+2只有两种可能，一个是大于mid+1，一个是小于mid+1，小于mid+1的情况，那么mid+1就是峰值，大于mid+1的情况，继续向右推，如果一直到数组的末尾都是大于的，那么可以肯定最后一个元素是峰值，因为nums[nums.length]=负无穷
[
思路都对，就python做char的计算的时候需要(chr)(ord('A')+num)
8.30
碰撞法，好用
[
一开始思路不对，后来改正了。
看了之前的才写出来><
[
想了一会儿但还是写出来了w
啊啊我傻了，空间换时间之后完全用不到isPrime函数，重写重写
写了两次，对应关系没搞清楚。
8.31
graph又忘完了！好不好意思！？？
[
太难了，bucket写一次忘一次
9.1
还是没自己想出来> <
[
[
[
应该可以bugfree的题目，注意reverse的时候一开始的指针要置null啊多少次了！！
[
普通方法过了，有个机智方法空间复杂度最低的，可重写下。
[
太难了我看了半个小时，淦。
[
[
思路对，看了小提示写出来的
9.2
[
基础方法一次过，用链表成环的方法可太机智了。
[
写了挺久，但一次过。
[
写了很久，很麻烦，但思路不难。
[
看了之前的做法没看懂，然后发现三月份的自己给现在的我写了一段话：
行吧我为discussion里面的神仙解法，以及一步一步继续简化变量和方法的算法折服，深深地折服。
我之后一定会看不懂代码的，戳这里重新看讲解吧。
佛了，我属于我自己！
懒，不想做。
[
这题真的太难了...原理其实不太难，但很麻烦，踩坑无数。改天重新写下练习。
[
想了10min没思路，看了discussion，这方法绝了。
[
9.3
[
递归和迭代两种做法，都没写出来，傻的吗。
[
超时了，之后要看下nlogn的解法。
[
自己写的DP内存爆了，discussion里面的方法真是绝了。
[
拓扑图遍历又忘了，我真是要完了。
[
如何做效率比较高的dfs。
[
9.4
[
方法绝了。就算方法想不出，寻找最长递增子列总要会写吧orz傻子。
[
[
太难了，不想动脑子，先跳过。
9.5
[
啊啊终于做出来了，论数学的重要性
[
[
[
啊这题用递归真是太机智了！佛了！
[
看了discussion，绝了。
[
[
两次过哈哈哈没难度。字符串匹配的时候注意下\t转义的问题。
9.6
为什么大佬总能想到位操作，或许这就是差距吗orz。
数学题！
不会做！
简单题，一次过
有点麻烦，不过还是几次过了，一开始没考虑到嵌套，后来用了递归就可了。
[
哈哈哈哈自己写的递归，过了，打败了90%。
自己写的O(n^2)，用个的简单的公式就可以O(n)。
递归三行。
这个随机采样方法绝了，虽然看起来是很经典的算法，记一下。
9.7
[
是简单题但两次才过。第一次欠考虑了位数*个数的问题。不难。
这题也太好笑了。空间换时间可，暴力搜索也可。
# 统计二进制数i中1的个数的写法：
bin(i).count('1')==n
# 一行解法
return ["%d:%02d"%(i,j) for j in range(60) for i in range(12) if bin(i).count('1')+bin(j).count('1')==num]有小坑，题不难，两种方法均可，从删bit的思路和加bit的思路考虑都可。
[
两种方法，递归和DP。
递归一次过。
[
除法取余可以，但负数的处理需要考虑下。用移位更方便。
9.8
[
有空重写下，关于排序的问题。
9.9
[
[
[
递归会写，但超时了。
[
[
思路没问题，考虑下abc和abc2的情况
[
目的何在 什么傻子题目
[
写的有点麻烦，但本身题不难
9.10
[
不难，按流程来就行
[
python预定义最小值的时候可以 float('-inf'),int 不行，必须float
[
[
[
递归可但超时，DP好用。
9.11
[
[
现场我一定想不出，我看discussion都看半天才看懂
[
是真的看不懂，哭
[
自己写出来了，不过注意之前有很好用的模板，有一丢丢忘了。
[
9.12
[
哈哈哈哈哈自己写出来的97%和100%。早上写的，出了个门回来再看有点看不懂，之后再熟悉下。
[
做法和我思路是一致的，觉得麻烦一开始就没做下去。重写。
[
[
[
自己写的，但挪之后判断和判断之后挪，会影响边际条件。
[
我尽力了...
[
二分能提速很多。不难。
[
[
[
看了dis。
[
看了dis。方法和446挺类似。
9.13
[
一分钟的题
[
麻烦但中规中矩的题
[
递归好用，一开始思路不对
9.14
[
精华在这儿：
table.sort(key = lambda x: x[1], reverse = True)
return ''.join(map(lambda x: x[0] * x[1], table))以下一串都是类似的题，注意下区别：
[
[
[
[
[
这啥题啊 佛了
[
[
这题绝了，完全想不到。
[
简单题，做了点避免重复计算的优化
[
一行，是真的一行。
[
快排都不会了我完了。
[
用快排。以及中位数的作用在于找到全局/平均最近距离点（了解一下
# Python heap 操作
>>> h=[] #定义一个list
>>> from heapq import * #引入heapq模块
>>> a=[3,6,1]
>>> heapify(a) #将a变成堆之后，可以对其操作
>>> heappush(h,5) #向堆中依次增加数值
>>> heappush(h,2)
>>> heappush(h,3)
>>> heappush(h,9)
>>> h #h的值
[2, 5, 3, 9]
>>> heappop(h) #从h中删除最小的，并返回该值
2
>>> h
[3, 5, 9]
>>> h.append(1) #注意，如果不是压入堆中，而是通过append追加一个数值
>>> h #堆的函数并不能操作这个增加的数值，或者说它堆对来讲是不存在的
[3, 5, 9, 1]
>>> heappop(h) #从h中能够找到的最小值是3,而不是1
3
>>> heappush(h,2) #这时，不仅将2压入到堆内，而且1也进入了堆。
>>> h
[1, 2, 9, 5]
>>> heappop(h) #操作对象已经包含了1
1[
[
没法一步步递推，用递归即可。
[
9.15
[
[
以上两道是思路明确的。
[
递归可。
[
背包问题熟悉一下需要，递归可以但是会超时，DP要会写。
9.16
[
思路对。
[
[
啊哈有个很机智位运算的思路
[
注意分布不均匀的问题，以及要怎么证明
[
[
[
9.17
[
[
[
一道思路竟被我想到的hard题，写了半小时，后来发现会有负数orz。再想想。
[
递归相当于遍历2^n，用和背包问题类似的DP更好。
[
猪吗
[
[
[
机智的all用法！
[
自己写的空间O(n)一次过；要求的空间O(1)比较复杂，自己重写了一个。
9.18
[
递归和map剪枝
[
方法一递归，O(2^n)
方法二DP，O(n)
方法三
[
[
[
[
quicksort这么多bug好意思吗你....
[
[
9.19
[
[
[
9.20
[
[
从map中删东西用record.pop(key)
[
[
[
[
[
9.21
[
如何避免重复组合的？？？
[
[
nums[st:ed].sort()这种方式没法给sublist排序。
d.sort(key = lambda x: (-len(x),x))可以首先按照字符串的长度降序排，长度相同的时候按照字典升序排！
[
机智
[
递归
9.22
[
random.randint(1,3)中取随机数的时候，1，2，3都能取到，前后是闭的。
[
[
打星熟悉一下counter的用法。
[
unicode可以用isnumeric()，普通的只能用isdigit()
括号brackets，异或Exclusive or，
五除以三的余数 The remainder of five divided by three
[
[
[
[
[
麻烦但不难的，图的遍历还是要熟悉的。
[
[
思路对，但写的不熟练，错了好多次。
9.23
[
在干嘛？
[
chrs[st:ed] = reversed(chrs[st:ed])[
[
[
二分法，很多坑，很好用，想一下。
[
9.24
[
[
[
[
[
太难了，真的不会。。。
[
[
就一个点不对！最后的一截要记得加上！
[
啊哈O(n2)就超时了
9.25
[
思路大概是有的，但是没想到这么简洁的方法。
[
[
机智。
[
很久前做过，这次有思路但是还是有点没想到。
[
[
头尾边界注意一下，别的没有问题。
[
[
9.26
[
不同步传输的版本写出来了，同步的是不对的。
[
9.27
facebook的题
[
[
9.28
[
用括号的方法重新写了一遍，可！
[
认真想能想到。
[
佛了，思路太绝了。
[
[
[
9.29
[
[
[
trie node了解一下咯！
[
一开始是 没想到topological sort的思路转换，想到之后可写，但仍然没能bugfree。
[
简单！
[
[
[
不难但tricky！想下left and right is negative的情况怎么处理比较简洁（且不bug！）
[
自己有思路，但是不太对也不够好，要优化。
[
写过，有思路，不难。
[
我靠其实这么简单的题，东拼西补错误提交了6次，别干了...
[
[
简单题
[
框架和思路都对，template也记得，有一点是更新res的句子放在哪里比较合适？？？
[
看了之前的解法。三个指针，注意避免重复就可以。
[
[
[
[
[
heap用法注意下。
h = []
for num in nums:
if len(h) < k:
heappush(h,num)
# print(h[0])
elif h[0] < num:
heappushpop(h,num)
return h[0]9.30
[
也太难了吧orz，一步步慢慢写，很多很多坑。
[
dfs递归容易写，但需要多次修改值，TLE。看了discussion之后改用bfs迭代，麻烦些但是很快。都要会。
[
start的timestamp表示当前秒的开始，end的timestamp表示当前秒的结束，神奇。
[
绝了
[
[
维护一个最小堆就很飞速了。以及如果要让heap按照listnode的value排序，还是需要一个tuple，输入(node.val, node)的形式。
[
[
倒也不难，一次过。
[
iteration一次过，recursion想了一下。都需。
[
[
10.1
[
[
[
[
这啥傻子题目啊我靠
[
[
一行，行。
[
只要找到存在的一个下标即可，所以更改st和ed的条件比较宽松。
[
毫无难度，层次遍历一次即可。
[
intuitive很容易过，但可以想下怎么提速（5%
[
满分标准答案，double linked list
[
这个dfs用的很绝，思路有方向，但是具体想半天没想到。
[
10.2
[
太难了看了半个小时没看懂，先跳过...
[
[
easy但没bugfree，看清题目请。
[
写了递归和迭代，但这种是我想不到的方法。
[
链表可能是我唯一比较有把握写出来的hard题了。
[
题不难，可熟悉下counter的操作和用法。
[
[
[
[
有点繁琐，但也不难，DFS一次过。
10.3
[
[
[
ed更新时机注意一下，别的没啥。
[
三种插入情况，少了一种于是死循环了。
[
基础数据结构
[
一次过，做太多次了
[
10.5
[
方法绝了
[
[
[
[
有点绕，但不难。关于如何减少重复计算。
[
这题看一次懵一次。每次都想不到这个解法，放弃辽。
[
[
经典的随机采样方法，绝了。
randint(0,count)的取样空间是[0, count]，左右都闭。
[
[
[
[
以上四道是leetcode周竞赛，题都不难，40min完成。
[
[
[
[
以上四道是twitter OA，题都不难，50min完成。
10.6
[
dfs也能做但比较慢，太机智了这方法。
[
[
[
[
[
[
[
不想做
[
[
啊哈两指针一次过（intersection看起来比union容易很多）
[
三次了还是不会，哭
[
[
DP！！
[
思路对，有几处小失误没bug free。
[
没有难度
[
做了十几次类似题了再错了说不过去了
10.7
[
数字可能是一位以上的。别的没问题。
[
[
[
啊有坑！停止的条件！
[
[
写了一半网断了。重写。
[
[
[
这题有毒？？
10.8
[
重写了版。方法挺巧妙的。注意除法取整的时候往0的地方取，所以正负数取整方法不同。
[
经典图问题
[
[
[
会写level order stack的方法，但空间是O(n)。新写了discussion里面空间O(1)的方法，绝。
10.9
[
简单的hard题，三遍过的，反思一下？
[
[
还是有点复杂的一道题，注意下。
[
不太聪明的方法（好像discussion里面也是这么写的，妥！）
10.10
[
[
mergesort的链表版本
[
set和list一起用，很机智。
[
打扰了，两百行我不信面试会出
[
[
[
能用table[list]的方法，通常用二维数组也能解决
[
DP好用！nice！
[
[
10.11
[
暴力遍历可以，但很慢。BFS很好用，注意下visited = True的时机就可。
[
用个stack很方便。注意需要child置None，然后prev也要维护。
以上是facebook的题目，结果先接到了Amazon的OA，ok先换个题库继续。
[
有了思路就很简单
[
[
[
[
星星一下，要返回下标所以sort的时候要连着index一起。
[
递归也太神仙了。
[
很简单的题，和Quora面试几乎一个意思。注意下保持树的连续性。
[
就，写了nlog(n)的方法，和log(n)log(n)比较了一下，速度也差不多。nlog(n)遍历到中间如果发现nums的开头已经比target大了，直接break了return false就可以。
10.12
[
硬背一下，没太看懂Tarjan那个方法。
[
这个没啥难度，就注意一下不是所有歌都有genre的，多一个if判断。以及最后找maxvalue的时候也需要判断一下是不是空。
[
[
[
是要计数而不是找最长，不能用two pointers的方法。
[
DP并不难，同时可以在input处直接修改，这样空间复杂度就是O(1)了
[
做过很多次。
[
counter好用，以及正则替换：
paragraph = re.sub(r'[^a-zA-z]',' ', paragraph)[
很多技巧，tree的插入，node距离的计算
[
minheap做，不难。以及如果要节约空间的话，正确写法是heappushpop，先push，再pop。
[
又是连通图问题，太难了我脑子转不动了。
[
找循环的规律。
[
很妙的一道题。
[
# import sys
# sys.setrecursionlimit(10 ** 6)10.13
做了Amazon 的 OA3和Mathworks的OA。
[
[
很强的做法
[
没学会，也懒，跳过。
[
10.14
以下是Microsoft的题。
[
python两行
[
[
[
双向链表，没有一次过。
[
以前写的版本这次超时了，然后做了下优化。
[
[
两种方法最好都会（一种是st和ed存两个数组然后双指针法（另一种是维护一个不同房间end time的数组
[
[
[
为什么bst的递归还不能一次过...
[
[
[
除了走一遍中序遍历的流程之外，还可以用递归或者迭代的方法。空间复杂度更低一些。
10.15
[
用hashmap的原理实现。
10.16
[
[
10.17
[
以下是Facebook的题目
[
[
两次才bug free。考虑初始列表的长度不够k的情况，不是每次都需要pop的。
[
可以用没用过的bisect，或者二分查找。
然后二分查找后插入是有坑的，想一下。
[
机智
10.18
[
one pass的方法绝了。两端连通找max = 整段 - 最小
[
[
[
10.19
[
做过 一次过
[
做过 一次过
[
和之前换了做法，不构造array存node了。
[
照样没写出来的hard，但经常问，背一背。
[
一开始没绕过来 两次过（移位更快
[
find the first element larger than or equal to the generated random number
[
level order traverse的时候手滑了一次，题也比较复杂，注意下都。
[
思路清晰一次过。和meeting room类似的题目
[
tip在于用[-map[num], num]实现max heap
[
[
题不难，题后面的follow up比较难，要考虑下。
[
思路清楚bugfree一次过。从一开始到现在做了可能有四五次了...
[
关于python怎么读文件，太久没写了记一记。
with open(path, 'r') as f:
line = f.readline()
line = f.readline()
while line:
tmp = line.split(",")[
Keep origin sequence很重要。所以。
[
这题很奇怪emmm，先跳一跳。
10.20
[
[
超时了， 还没解决。
[
步骤小麻烦，但解题思路和之前next permutation几乎一样
[
[
[
[
当时没想出来，现在也没想出来空间复杂度O(1)的方法。
[
[
方法绝了。
[
结构的初定义方法熟悉一下，Trie的结构懂。
[
[
写出来了但改了三次才通过，比较麻烦注意下。
[
BFS好用。
[
改了三次，反思。
[
[
脑子不转了，放一放
10.23
下周on campus，以下是Uber的题。
[
[
自己写的dp和bfs都超时了，discussion的方法很绝。
[
hard题orz，太难了吧... 10/28看了一眼之前的方法然后写出来的。
[
能用set转换的话其实不难，但是不知有没有别的限制。如果不用set的话还需要考虑挺多情况的。
排序之后，重复的数字怎么操作。res需要每次都更新。
[
O(N)可以解决的题不懂为什么一定要用又复杂又O(NlgN)的分治。
不过都能写。
[
批了马甲的128，但是要记录个路径。写出来了但是磕磕绊绊的，面试估计就挂了orz（
[
递归迭代都可。
[
方法太绝了吧。是递归，想下具体怎么写。
递归想清楚了就不难，然后避免重复计算很重要，不然会超时。
[
[
为什么这题会是hard？难度到了吗？
[
可以，方法很机智。做过一次下次就会了（大概）。
10.24
[
[
[
[
[
[
这么常见的题还错是想怎样...
然后quick sort和quick select也都熟悉一下
10.25
[
[
[
很经典的trie用法。这边可以定义一个Trie Class，也可以直接用嵌套的map。速度的话后者快，但是前者更正规一些。
过两天再写一次。
10.26
[
很久没练这类型的题了orz。
[
太难了...还好OA没遇到...
[
[
非常公式化的过程，建graph，找通路
[
[
第一次做到的时候感觉太复杂就跳过了，今天看面经有问到这题就做了一下，倒也不难...
[
[
DFS这几天写吐了o(TヘTo)
[
[
[
10.27
[
[
是之前matlab的OA题，听说他们面试可能会复盘所以...!!
这不就是最基础的BF+BFS吗我之前为什么看不懂....
[
10.28
[
难度没有，注意下最后return的时候，如果当前所有数字都小于k，那需要另外+1
这个corner case很多题我都不记得
[
不是bst，遍历一下就可
[
[
[
[
minheap或者quick select都行. quick select还是有点不太熟，反思。
[
DP就行。我一开始想着如果amount很大的话开不了那么大的数组，要不试试bfs。后来发现是多虑了，行。
[
[
10.29
[
Amazon VO的问题。
[
很绝的方法，是亚麻高频。
[
也是hard题
10.30
[
[
[
10.31
[
[
11.1
感谢贾凡凡的头像，找到实习了。
和Leetcode挥手告别。
11.2
[
1.30
[
2.4
[
不是我写的，但是贡献了一丢丢思路
[
[
[