MarStarck的专栏

分治

题目：给出0到n的数，但是其中缺了一个，问缺了哪个分析：非常有名的题，求和再做差。答案：class Solution {public: int missingNumber(vector& nums) { int sum = 0; int n = nums.size()+1; int n_sum = n*( 0 + n -1) /2;

题目：给一排小孩发糖果，每个小孩有自己的评分，评分高的小孩得到的糖果比评分低的左右邻居要多。每个小孩至少一个糖果。问最少发多少糖果？分析：对于一个顺序上升或者下降的评分序列，小孩得到的糖果最少也得是递增/递减的比如评分 1 3 5 7 8糖果 1 2 3 4 5评分 9 7 4 3 1糖果 5 4 3 2 1而对于非递增/递减的评分序列，可以拆分成几段上升/下降的序

题目：给一个字符矩阵，在里面找单词。相邻字母必须要4邻域内。分析：典型的4邻域深度优先搜索，答案：class Solution {public: bool exist(vector>& board, string word) { M = board.size(); N = board[0].size(); for (int i

题目：数组第i个元素表示的是股票在第i天的价格，问最大的收益。要求必须先买后卖，可以进行任意次交易。分析：只要有收益就进行买卖即可。比如以下序列1 2 9 3我们可以看到，在1时买入，2时卖出，2时买入，9时再卖出，收益为8而在1时买入，9时卖出，收益也为8所以只要赚钱，不见得要找绝对差值最大的，因为买卖是无限次数的，只要能赚就买/卖即可。答案：class Solu

题目：判断一颗树是否左右对称分析：可以用递归的方法，判断对应的左右位置是否对称答案：class Solution {private: bool isSym(TreeNode* t1, TreeNode* t2){ if (!t1 && !t2) return true; if (!t1 || !t2)

题目：输出能跳到数组末尾的最小跳数。详见Jump Game分析：同样，也是贪心。因为当前跳如果能跳到k，那么必然也能跳到小于k的地方，所以贪心是可以的。然后用一个int记录当前跳能到的最大位置，另一个int记录下一跳能到的最大位置，模拟跳的过程：从i=0往前跳，如果当前跳不能到i，而下一跳可以到i，则多跳一步，否则就以i跳更新下一跳的最大距离答案：class Solution {publ

题目：遍历二叉树，从下到上，从左到右分析：这个跟之前的从上到下，从左到右的层序遍历是姊妹篇。答案：先回顾一下原先的层序遍历（把下层节点弄到队列里保存起来）/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNo

题目：一个环形路线上有加油站，每个加油站可以加gas[i]的油，走到下一站得消耗cost[i]的油，问能不能找一个点出发，走完全程。若能，输出点的位置，若不能，输出-1。题目确保给定数据有唯一解。分析：每个加油站的增益为retain[i] = gas[i] - cost[i]，那么如果n个油站的retain加起来为负，怎么走都不可能走完。如果为正，就可以。那么我们希望一开始就能得到尽量大的re

题目：给一个数组，存的是从这个点最多能往前跳多少，问能否跳到终点分析：对于一个点能不能到达，主要看前面的点能不能跳到。比如第0个点，如果能跳到k。那么第1个点可能跳到k，也可能跳不到k，我们就可以搜索1~k的点，看能不能跳得更远。如果我们发现[1,k]的点都不能跳得更远了，而且kn的，那么就可以到终点。答案：class Solution {public: bool canJu

题目：返回字符串中最后一个单词的长度分析：因为是最后一个单词，所以可以从后往前遍历，遇到不为‘ ’的开始计数，到为‘ ’停止，其中的长度即为最后一个单词的长度。答案：class Solution {public: int lengthOfLastWord(string s) { int res = 0; int i = s.length() -

题目：将数组中的重复数字去除，不能新开一个数组。返回数组和去重后的个数分析：用一个数字记录数组非重复 的，如果是重复的，就把后面不重复的搬过来。复杂度O(n)答案：class Solution {public: int removeDuplicates(vector& nums) { int res = 0; if (nums.size()<1

题目：给定n，输出小于n的数中，质数的个数分析：就用传说中的筛石头的方法，每次把i的倍数的数给删掉。答案：class Solution {public: int countPrimes(int n) { if (n < 3) return 0; bool *p=new bool[n]; memset(p, 1, n*sizeof(bool)); for

题目：从字符串中查找字串，若有则返回匹配开始位置，无返回-1分析：最原始的方法就是一个个划过去比较，复杂度O(n*m)答案：class Solution {public: int strStr(string haystack, string needle) { for(int hi = 0; ; hi ++){ for(int ni

题目：将数组中值为val的去掉，并返回去掉后数组的长度分析：和#26如出一辙，就是通过将合格的数搬移到不合格的位置来完成，从而不需要新开数组答案：class Solution {public: int removeElement(vector& nums, int val) { int res = 0; for (int i = 0; i <

题目：有n级台阶，你可以选择一次爬1级或者2级，问上去有几种不同的方法？分析：这其实是一道典型的斐波拉契数列。因为考虑第一次选择：你可以爬1级，也可以爬2级，所以f(n) = f(n-1) + f(n-2)答案：先写了个递归的方法：class Solution {public: int climbStairs(int n) { if (n == 1)

题目：判断一个数组里是否有重复元素分析：如果用2个for loop来做，复杂度为O(n^2)，先排序再遍历看相邻数是否相等，复杂度O(nlgn)答案：class Solution {public: bool containsDuplicate(vector& nums) { sort(nums.begin(),nums.end()); for

题目：从一个有序链表里删除重复元素分析：这个和数组去重很像。都只需记录下当前不重复的元素位置到下一个不重复的元素位置，然后建立联系即可。答案：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x

题目：将单链表反转分析：可以用迭代或者递归来做答案：迭代的示意图：代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {}

题目：判断单向链表是否有环分析：用1个慢指针和一个快指针，慢指针每次往前走一步，快指针每次往前走2步。如果没有环，那么最终快指针会指向null或者null的上一步，如果有环，那么2个指针会相遇，即慢指针比快指针整整少走了一圈。答案：/** * Definition for singly-linked list. * struct ListNode { * int val;

题目：将链表中的节点两两交换分析：假设节点1->2->3，那么我们首先让1指向3，2指向1，但是其实1指向的不一定是3，而是3和下一个交换，所以用递归的方法可以返回交换后的第3个节点答案：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next

题目：找出以1..n为元素值的所有bst的个数分析：对于n=1，那么就只有1个对于n=2，可以以1为root，剩下一个2就放右边；也可以以2为root，剩下的1放左边，一共2个对于3呢？同样可以尝试分别以1 2 3作为root，其余的作为子树总之，对于n，可以把1...n分别作为root，答案为这些情况之和考虑当把k做为root时，那么1到k-1必在左子树，k+1到n必在右

题目：二叉树的先序遍历分析：用递归超级容易答案：递归：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(N

题目：二叉树中序遍历分析：也是递归答案：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), rig

题目：打印二叉树的所有路径分析：就是深度遍历呗。注意对第一个节点做处理，不用打->，然后就完了答案：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(in

题目：判断一个数是不是丑数：即质因数只有2 3 5组成分析：那么丑数必为2^i*3^j*5^k答案：class Solution {public: bool isUgly(int num) { if (num == 0) return false; while (num%2 == 0) num /

题目：将某数的每位相加，和作为新数，直至不超过10分析：按部就班地做呗答案：class Solution {public: int addDigits(int num) { while (num/10 >0 ){ int newnum = 0; while(num){ int di

题目：数组中每个数都出现了2次，有且只有2个数出现了1次，求这2个数分析：回顾single number这道题，我们知道可以通过把所有数异或的方式，求得唯一的那个single number。那么这道题我们考虑把数组分为2部分，每个部分都包含一个single number，从而求得这2个single number。那么问题就变成了如何将1个数组划分成2个数组的问题。考虑到将含2个single n

题目：输出第n个丑数（关于丑数的定义见ugly number）分析：这就需要生成n个丑数。我们可以看到，1是丑数，然后其2,3,5倍皆是丑数。这要求我们将2,3,5的幂都排序，可以用优先队列来做，也可以依大小生成：每次生成的是乘以2,3,5中最小的，然后乘过的做一个标记。答案：class Solution {private: int findMin(int a, int b, int

题目：输入一个数组，输出所有子集分析：每个数有选/不选2种，一共2^n种答案：class Solution {private: vector> res;public: vector> subsets(vector& nums) { res.clear(); sort(nums.begin(),nums.end()); vect

题目：生成格雷码。即下一个数和上一个数比只有一个位不同。分析：格雷码的特点，是n位格雷码和是的前一半是n-1位格雷码前面+0，后一半是n-1为格雷码倒序且前面+10 0 00 0 10 1 10 1 0答案：用递归：class Solution {public: vector grayCode(int n) { vector res;

题目：一个数组中，有一个数只出现了一次，其余数都出现2次，求找这个只出现一次的数分析：a xor 0 = a; a xor a =0; so...答案：class Solution {public: int singleNumber(vector& nums) { int res = 0; for (int i = 0; i< nums.siz

题目：将链表分成前后2部分，一部分小于x，另一部分不小于x，且保留各元素的相对位置分析：再建2个链表分别保存小的和大的，然后合并答案：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :

题目：将二叉树左右反转分析：可以采用递归的方法反转每个节点的左右子树。非递归的话其实就是层序遍历然后从后到前排就行了。答案：递归：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right;

题目：已知长度为n的数组中有一个出现次数>n/2的数字，求这个数字分析：第一眼的想法就是记录下出现的每个不重复数字，然后统计每个数字出现的次数，复杂度n*n，也是暴力啊然后想到的就是随机抽一个数字，判断它出现的次数是否>n/2，毕竟是众数容易抽到，期望复杂度是2*n还有一个容易想到的方法就是开一个长度> max(array)的数组mark，扫描一遍array，将对应下标的m

题目：对一个单向链表，如有环，返回环的起始节点，如果没环，返回NULL分析：在Cycle I部分，我们就讨论了如何判断链表是否有环，即通过快慢指针的相遇来判断。那么如何找到起始点呢？首先，假设链表需要走a个节点进入环，走b个节点相遇，如图所示：那么慢指针走了a+b, 快指针走了a+b + c + b，环长b+c所以ia+b = (a + b + c + b)/2        

题目：求2个矩形加起来覆盖的面积分析：主要要考虑重叠的判断。2个矩形若重叠，那么在水平方向它们左侧起点的最右端应该比右侧起点的最左端左，同时垂直方向，下侧起点的最上端比上侧的最下端要下。答案：class Solution {public: int computeArea(int A, int B, int C, int D, int E, int F, int G, int

题目：判断一个整数是否是2的次方分析：2的次方具有这样的特征：二进制表示下，有且只有第一位是1，其余位为0。所以n&n-1必定为0答案：class Solution {public: bool isPowerOfTwo(int n) { return !(n & (n-1)) && (n>0); }};

题目：用队列实现栈分析：和之前那个用栈实现队列是姐妹篇。这个的奥义在于，一定要保证2个队列中的一个为空。这样就可以把新加入的元素放到空队列中，再将非空队列的元素一个个加入该队列，这样就实现了新入的在队首。答案：class Stack {public: queue q1; queue q2; // Push element x onto stack.

题目：判断一个二叉树是不是平衡二叉树（任意左右子树深度差不超过1）分析：深度优先搜索，可以先算深度再判断答案：/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x)