Code_Ganker-CSDN博客

原创 Max Points on a Line -- LeetCode

原题链接: http://oj.leetcode.com/problems/max-points-on-a-line/ 这道题属于计算几何的题目，要求给定一个点集合，是求出最多点通过一条直线的数量。我的思路是n个点总共构成n*(n-1)/2条直线，然后对每条直线看看是有多少点在直线上，记录下最大的那个，最后返回结果。而判断一个点p_k在p_i, p_j构成的直线上的条件是(p_k.y-p_i.

2014-03-14 00:45:59 10936 9

原创 Evaluate Reverse Polish Notation -- LeetCode

原题链接: http://oj.leetcode.com/problems/evaluate-reverse-polish-notation/ 这道题是逆波兰式的求解，不了解逆波兰式的朋友可以参考一下逆波兰表示法 - wiki。逆波兰式有个优点就是他不需要括号来表示优先级，直接根据式子本身就可以求解。思路是维护一个运算数栈，读到运算数的时候直接进栈，而每得到一个运算符，就从栈顶取出两个运算

2014-03-13 21:56:02 5956

原创 Reverse Words in a String -- LeetCode

原题链接: http://oj.leetcode.com/problems/reverse-words-in-a-string/ 这道题是字符串处理的题目，我们先介绍一种很直接的做法，就是类似于java中String::split函数做的操作，把字符串按空格分开，不过我们把重复的空格直接忽略过去。接下来就是把得到的结果单词反转过来得到结果。因为过程中就是一次扫描得到字符串，然后再一次扫描得出结

2014-03-13 10:55:23 7736 8

原创 Multiply Strings -- LeetCode

原题链接: http://oj.leetcode.com/problems/multiply-strings/ 这道题属于数值操作的题目，其实更多地是考察乘法运算的本质。基本思路是和加法运算还是近似的，只是进位和结果长度复杂一些。我们仍然是从低位到高位对每一位进行计算，假设第一个数长度是n，第二个数长度是m，我们知道结果长度为m+n或者m+n-1（没有进位的情况）。对于某一位i，要计算这个位上

2014-03-13 08:05:15 12734 9

原创 First Missing Positive -- LeetCode

原题链接: http://oj.leetcode.com/problems/first-missing-positive/ 这道题要求用线性时间和常量空间，思想借鉴到了Counting sort中的方法，不了解的朋友可以参见Counting sort - Wikipedia。既然不能用额外空间，那就只有利用数组本身，跟Counting sort一样，利用数组的index来作为数字本身的索引

2014-03-13 04:31:27 14125 14

原创 Combination Sum II -- LeetCode

原题链接: http://oj.leetcode.com/problems/combination-sum-ii/ 这道题跟Combination Sum非常相似，不了解的朋友可以先看看，唯一的区别就是这个题目中单个元素用过就不可以重复使用了。乍一看好像区别比较大，但是其实实现上只需要一点点改动就可以完成了，就是递归的时候传进去的index应该是当前元素的下一个。代码如下： publi

2014-03-13 04:30:39 17040 10

原创 Combination Sum -- LeetCode

原题链接: http://oj.leetcode.com/problems/combination-sum/ 这个题是一个NP问题，方法仍然是N-Queens中介绍的套路。基本思路是先排好序，然后每次递归中把剩下的元素一一加到结果集合中，并且把目标减去加入的元素，然后把剩下元素（包括当前加入的元素）放到下一层递归中解决子问题。算法复杂度因为是NP问题，所以自然是指数量级的。代码如下： pu

2014-03-10 03:57:44 21696 10

原创 Sudoku Solver -- LeetCode

原题链接: http://oj.leetcode.com/problems/sudoku-solver/ 这道题的方法就是用在N-Queens中介绍的常见套路。简单地说思路就是循环处理子问题，对于每个格子，带入不同的9个数，然后判合法，如果成立就递归继续，结束后把数字设回空。大家可以看出代码结构和N-Queens是完全一样的。判合法可以用Valid Sudoku做为subroutine

2014-03-10 03:56:50 22013 20

原创 Valid Sudoku -- LeetCode

原题链接: http://oj.leetcode.com/problems/valid-sudoku/ 这道题是Sudoku Solver的一个子问题，在解数独的时候我们需要验证当前数盘是否合法。其实思路比较简单，也就是用brute force。对于每一行，每一列，每个九宫格进行验证，总共需要27次验证，每次看九个元素。所以时间复杂度就是O(3*n^2), n=9。代码如下： publ

2014-03-10 03:52:16 14585 4

原创 Trapping Rain Water -- LeetCode

原题链接: http://oj.leetcode.com/problems/trapping-rain-water/ 这道题比较直接的做法类似Longest Palindromic Substring中的第一种方法，对于每一个bar往两边扫描，找到它能承受的最大水量，然后累加起来即可。每次往两边扫的复杂度是O(n)，对于每个bar进行处理，所以复杂度是O(n^2)，空间复杂度是O(1)。思

2014-03-10 03:50:31 19504 3

原创 Longest Palindromic Substring -- LeetCode

原题链接: http://oj.leetcode.com/problems/longest-palindromic-substring/ 这道题是比较常考的题目，求回文子串，一般有两种方法。第一种方法比较直接，实现起来比较容易理解。基本思路是对于每个子串的中心（可以是一个字符，或者是两个字符的间隙，比如串abc,中心可以是a,b,c,或者是ab的间隙，bc的间隙）往两边同时进行扫描，直到不是

2014-03-10 03:49:51 22692 11

原创 Count and Say -- LeetCode

原题链接: http://oj.leetcode.com/problems/count-and-say/ 这道题属于字符串操作的类型，算法上提高空间不大，只能是对于某一个数的串，读过去然后得到计数并生成下一个串。时间复杂度是O(n*串的长度)，空间复杂度是O(串的长度)。代码如下：public String countAndSay(int n) { if(n<=0)

2014-03-07 04:43:20 8960 2

原创 N-Queens II -- LeetCode

原题链接: http://oj.leetcode.com/problems/n-queens-ii/ 这道题跟N-Queens算法是完全一样的，只是把输出从原来的结果集变为返回结果数量而已。思路我们就不在赘述了，大家可以参见N-Queens，算法的时间复杂度仍然是指数量级的，空间复杂度是O(n)。代码如下：public int totalNQueens(int n) { A

2014-03-07 00:34:00 10569 3

原创 N-Queens -- LeetCode

原题链接: http://oj.leetcode.com/problems/n-queens/ N皇后问题是非常经典的问题了，记得当时搞竞赛第一道递归的题目就是N皇后。因为这个问题是典型的NP问题，所以在时间复杂度上就不用纠结了，肯定是指数量级的。下面我们来介绍这个题的基本思路。主要思想就是一句话：用一个循环递归处理子问题。这个问题中，在每一层递归函数中，我们用一个循环把一个皇后填入对应行

2014-03-07 00:32:30 28675 18

原创 Search for a Range -- LeetCode

原题链接: http://oj.leetcode.com/problems/search-for-a-range/ 这道题是二分查找Search Insert Position的变体，思路并不复杂，就是先用二分查找找到其中一个target，然后再往左右找到target的边缘。找边缘的方法跟二分查找仍然是一样的，只是切半的条件变成相等，或者不等（往左边找则是小于，往右边找则是大于）。这样下来

2014-03-06 03:48:49 20348 8

原创 Search in Rotated Sorted Array II -- LeetCode

原题链接: http://oj.leetcode.com/problems/search-in-rotated-sorted-array-ii/ 这道题是二分查找Search Insert Position的变体，思路在Search in Rotated Sorted Array中介绍过了，不了解的朋友可以先看看那道题哈。和Search in Rotated Sorted Arra

2014-03-06 02:04:55 21276 7

原创 Search in Rotated Sorted Array -- LeetCode

原题链接: http://oj.leetcode.com/problems/search-in-rotated-sorted-array/ 这道题是二分查找Search Insert Position的变体，看似有点麻烦，其实理清一下还是比较简单的。因为rotate的缘故，当我们切取一半的时候可能会出现误区，所以我们要做进一步的判断。具体来说，假设数组是A，每次左边缘为l，右边缘为r，还有

2014-03-05 09:15:45 24578 15

原创 Largest Rectangle in Histogram -- LeetCode

原题链接: http://oj.leetcode.com/problems/largest-rectangle-in-histogram/ 这道题brute force的方法很直接，就是对于每一个窗口，找到其中最低的高度，然后求面积，去其中最大的矩形面积。总共有n^2个窗口，找最低高度是O(n)的操作，所以复杂度是O(n^3)。接下来我们讨论一种比较容易理解的思路，就是从每一个bar往两边

2014-03-05 08:52:52 17291 11

原创 Longest Valid Parentheses -- LeetCode

原题链接: http://oj.leetcode.com/problems/longest-valid-parentheses/ 这道题是求最长的括号序列，比较容易想到用栈这个数据结构。基本思路就是维护一个栈，遇到左括号就进栈，遇到右括号则出栈，并且判断当前合法序列是否为最长序列。不过这道题看似思路简单，但是有许多比较刁钻的测试集。具体来说，主要问题就是遇到右括号时如何判断当前的合法序列的长度

2014-03-04 07:57:24 12655 3

原创 Next Permutation -- LeetCode

原题链接: http://oj.leetcode.com/problems/next-permutation/ 这道题是给定一个数组和一个排列，求下一个排列。算法上其实没有什么特别的地方，主要的问题是经常不是一见到这个题就能马上理清思路。下面我们用一个例子来说明，比如排列是(2,3,6,5,4,1)，求下一个排列的基本步骤是这样：1) 先从后往前找到第一个不是依次增长的数，记录下位置p。比

2014-03-04 05:52:53 16826 6

原创 Minimum Window Substring -- LeetCode

原题链接: http://oj.leetcode.com/problems/minimum-window-substring/ 这道题是字符串处理的题目，和Substring with Concatenation of All Words思路非常类似，同样是建立一个字典，然后维护一个窗口。区别是在这道题目中，因为可以跳过没在字典里面的字符（也就是这个串不需要包含且仅仅包含字典里面的字符，有

2014-03-03 04:23:50 24670 1

原创 Substring with Concatenation of All Words -- LeetCode

原题链接: http://oj.leetcode.com/problems/substring-with-concatenation-of-all-words/ 这道题看似比较复杂，其实思路和Longest Substring Without Repeating Characters差不多。因为那些单词是定长的，所以本质上和单一个字符一样。和Longest Substring With

2014-03-03 04:00:17 30338 34

原创 Search Insert Position -- LeetCode

原题链接: http://oj.leetcode.com/problems/search-insert-position/ 这道题比较简单，就是二分查找。思路就是每次取中间，如果等于目标即返回，否则根据大小关系切去一半。因此算法复杂度是O(logn)，空间复杂度O(1)。代码如下： public int searchInsert(int[] A, int target) { if(

2014-03-02 07:40:19 16183

原创 Implement strStr() -- LeetCode

原题链接: http://oj.leetcode.com/problems/implement-strstr/ 这是算法中比较经典的问题，判断一个字符串是否是另一个字符串的子串。这个题目最经典的算法应该是KMP算法，不熟悉的朋友可以参见Knuth–Morris–Pratt algorithm。KMP算法是最优的线性算法，复杂度已经达到这个问题的下限。但是KMP算法比较复杂，很难在面试的短时

2014-03-02 06:42:01 22645 18

原创 Add Binary -- LeetCode

原题链接: http://oj.leetcode.com/problems/add-binary/ 这道题跟Add Two Numbers很类似，代码结构很接近。从低位开始，一直相加并且维护进位。和Add Two Numbers的区别是这个题目低位在后面，所以要从string的尾部往前加。时间复杂度是O(m+n)，m和n分别是两个字符串的长度，空间复杂度是结果的长度O(max(m,n)

2014-03-01 06:30:43 14744 20

原创 Binary Tree Inorder Traversal -- LeetCode

原题链接: http://oj.leetcode.com/problems/binary-tree-inorder-traversal/ 通常，实现二叉树的遍历有两个常用的方法：一是用递归，二是使用栈实现的迭代方法。下面分别介绍。递归应该最常用的算法，相信大家都了解，算法的时间复杂度是O(n), 而空间复杂度则是递归栈的大小，即O(logn)。代码如下： public ArrayLis

2014-03-01 05:38:48 19830 8

原创 Pow(x, n) -- LeetCode

原题链接: http://oj.leetcode.com/problems/powx-n/ 这道题是一道数值计算的题目，因为指数是可以使结果变大的运算，所以要注意越界的问题。如同我在Sqrt(x)这道题中提到的，一般来说数值计算的题目可以用两种方法来解，一种是以2为基进行位处理的方法，另一种是用二分法。这道题这两种方法都可以解，下面我们分别介绍。第一种方法在Divide Two Int

2014-02-28 02:05:35 23592 22

原创 Sqrt(x) -- LeetCode

原题链接: http://oj.leetcode.com/problems/sqrtx/ 这是一道数值处理的题目，和Divide Two Integers不同，这道题一般采用数值中经常用的另一种方法：二分法。基本思路是跟二分查找类似，要求是知道结果的范围，取定左界和右界，然后每次砍掉不满足条件的一半，知道左界和右界相遇。算法的时间复杂度是O(logx)，空间复杂度是O(1)。代码如下：pu

2014-02-28 01:06:21 22095 18

原创 Divide Two Integers -- LeetCode

原题链接: http://oj.leetcode.com/problems/divide-two-integers/ 这道题属于数值处理的题目，对于整数处理的问题，在Reverse Integer中我有提到过，比较重要的注意点在于符号和处理越界的问题。对于这道题目，因为不能用乘除法和取余运算，我们只能使用位运算和加减法。比较直接的方法是用被除数一直减去除数，直到为0。这种方法的迭代次数是结

2014-02-27 05:41:54 32091 23

原创 Reverse Integer -- LeetCode

原题链接: http://oj.leetcode.com/problems/reverse-integer/ 这道题思路非常简单，就是按照数字位反转过来就可以，基本数字操作。但是这种题的考察重点并不在于问题本身，越是简单的题目越要注意细节，一般来说整数的处理问题要注意的有两点，一点是符号，另一点是整数越界问题。代码如下： public int reverse(int x) { if

2014-02-27 05:39:30 15634 10

原创 Remove Duplicates from Sorted Array -- LeetCode

原题链接: http://oj.leetcode.com/problems/remove-duplicates-from-sorted-array/ 这道题跟Remove Element类似，也是考察数组的基本操作，属于面试中比较简单的题目。做法是维护两个指针，一个保留当前有效元素的长度，一个从前往后扫，然后跳过那些重复的元素。因为数组是有序的，所以重复元素一定相邻，不需要额外记录。时间复

2014-02-27 05:12:22 12722 5

原创 Remove Element -- LeetCode

原题链接: http://oj.leetcode.com/problems/remove-element/ 这道题是比较简单的数组操作，思路是一个指针从前往后走，如果遇到要删除的元素，就从后面调一个替换它，直到结束。复杂度是O(n)，因为每个元素最多被访问一次。比较简练的实现代码如下：public int removeElement(int[] A, int elem) { if(

2014-02-26 09:53:18 6005 2

原创 Add Two Numbers -- LeetCode

原题链接: http://oj.leetcode.com/problems/add-two-numbers/ 这道题比较简单，是cc150里面的题，思路很明确，就是按照位数读下去，维护当前位和进位，时间复杂度是O(n),空间复杂度是O(1).代码如下： public ListNode addTwoNumbers(ListNode l1, ListNode l2) { int car

2014-02-26 06:46:10 13477 3

原创 Reverse Nodes in k-Group -- LeetCode

原题链接: http://oj.leetcode.com/problems/reverse-nodes-in-k-group/ 这道题是Swap Nodes in Pairs的扩展，Swap Nodes in Pairs其实是这道题k=2的特殊情况，大家可以先练习一下。不过实现起来还是比较不一样的，因为要处理比较general的情形。基本思路是这样的，我们统计目前节点数量，如果到达k，

2014-02-26 06:27:12 12328 5

原创 Longest Substring Without Repeating Characters -- LeetCode

原题链接: http://oj.leetcode.com/problems/longest-substring-without-repeating-characters/ 这道题用的方法是在LeetCode中很常用的方法，对于字符串的题目非常有用。首先brute force的时间复杂度是O(n^3), 对每个substring都看看是不是有重复的字符，找出其中最长的，复杂度非常高。优化一些的

2014-02-26 01:53:37 21729 17

原创 Swap Nodes in Pairs -- LeetCode

原题链接: http://oj.leetcode.com/problems/swap-nodes-in-pairs/ 这道题属于链表操作的题目，思路比较清晰，就是每次跳两个节点，后一个接到前面，前一个接到后一个的后面，最后现在的后一个（也就是原来的前一个）接到下下个结点（如果没有则接到下一个）。代码如下： public ListNode swapPairs(ListNode head) {

2014-02-26 01:37:59 13639 6

原创 Median of Two Sorted Arrays -- LeetCode

原题链接: http://oj.leetcode.com/problems/median-of-two-sorted-arrays/ 这道题比较直接的想法就是用Merge Sorted Array这个题的方法把两个有序数组合并，当合并到第(m+n)/2个元素的时候返回那个数即可，而且不用把结果数组存起来。算法时间复杂度是O(m+n)，空间复杂度是O(1)。因为代码比较简单，就不写出来了，跟

2014-02-25 11:26:33 15911 10

原创 Merge k Sorted Lists -- LeetCode

原题链接: http://oj.leetcode.com/problems/merge-k-sorted-lists/ 这道题目在分布式系统中非常常见，来自不同client的sorted list要在central server上面merge起来。这个题目一般有两种做法，下面一一介绍并且分析复杂度。第一种做法比较容易想到，就是有点类似于MergeSort的思路,就是分治法，不了解MergeS

2014-02-25 09:45:41 30796 10

原创 Generate Parentheses -- LeetCode

原题链接: http://oj.leetcode.com/problems/generate-parentheses/ 这道题其实是关于卡特兰数的，如果只是要输出结果有多少组，那么直接用卡特兰数的公式就可以。关于卡特兰数，请参见卡特兰数-维基百科，里面有些常见的例子，这个概念还是比较重要的，因为很多问题的原型其实都是卡特兰数，大家可以看看。特别是其中这个递推式的定义，很多这类问题都

2014-02-25 02:27:18 14376 18

原创 Valid Parentheses -- LeetCode

原题链接: http://oj.leetcode.com/problems/valid-parentheses/ 这道题思路比较简单，主要考察对栈数据结构的操作。遇到左括号就入栈，遇到右括号看栈顶左括号是否与当前右括号匹配，匹配继续，否则返回false。算法的时间复杂度是O(n)，空间复杂度也是O(n)。代码如下： public boolean isValid(String s) {

2014-02-24 07:25:29 8292 8

空空如也

空空如也