2015年08月_struggler_1990

09月 08月 07月 06月 04月 03月 02月

原创 LeetCode之Combination Sum III

/*深度搜索。采用深度搜索，每次添加一个数字。*/class Solution {public: vector> combinationSum3(int k, int n) { vector > res; if(k <= 0 || n < (k+1)*k/2) return res; vector path; for(in

2015-08-31 21:54:51 269

原创 LeetCode之Best Time to Buy and Sell Stock II

/*可以多次交易，但是只能同时持有一个股。则对于当天的股，只要在第二天卖出能够盈利，那么就买进，第二天卖出。*/class Solution {public: int maxProfit(vector& prices) { if(prices.size() <= 1) return 0; int res(0); for(int i =

2015-08-31 21:28:23 240

原创 LeetCode之Best Time to Buy and Sell Stock

/*只能做一次交易。则对于在某天卖出的股票，获得最大盈利值的方法为：在这天之前中，股票价格最低的那天买进股票。比较每天卖出的股票，即可获得最大盈利。*/class Solution {public: int maxProfit(vector& prices) { if(prices.size() <= 1) return 0; int min_pric

2015-08-31 21:22:11 202

原创 LeetCode之Container With Most Water

/*对于(i,j)组成的container：1）若height[i] < height[j], 则以以height[i]为左边界的container最大容量的是height[j]为右边界。（因为height[j]是离height[i]最远且大于height[i]的边）。此时，应该i右移。2）反之，j应该左移。*/class Solution {public: int max

2015-08-31 20:57:31 234

原创 LeetCode之Contains Duplicate II

/*Hash Table*/class Solution {public: bool containsNearbyDuplicate(vector& nums, int k) { unordered_map count; for(int i = 0; i < nums.size(); ++i){ unordered_map::it

2015-08-31 17:18:00 304

原创 LeetCode之Contains Duplicate

/*Hash Table*/class Solution {public: bool containsDuplicate(vector& nums) { unordered_map count; for(int i = 0; i < nums.size(); ++i){ if(count.find(nums[i]) != coun

2015-08-31 16:47:38 210

原创 LeetCode之Find Minimum in Rotated Sorted Array II

/*二分查找。*/ class Solution { public: int findMin(vector& nums) { int l = 0, r = nums.size()-1; while(l < r){ while(l < r && nums[l+1] == nums[l]) ++l;

2015-08-31 16:22:10 196

原创 LeetCode之Find Minimum in Rotated Sorted Array

/*二分查找。*/class Solution {public: int findMin(vector& nums) { int l = 0, r = nums.size()-1; while(l < r){ int mid = (l + r) / 2; if(nums[mid] > nums[mid+1]

2015-08-31 15:37:47 215

原创 LeetCode之Find Peak Element

/*O(n)解法。直接比较相邻数字即可。*/class Solution {public: int findPeakElement(vector& nums) { int n = nums.size(); for(int i = 0; i < nums.size(); ++i){ if(i < nums.size() - 1){ if(nums[i] > nums[i

2015-08-31 15:17:13 212

转载 LeetCode之Majority Element II

/*O(n)解法。此题与Majority Element类似，考查摩尔投票的知识迁移。由于每个Majority Element的都more than⌊ n/3 ⌋，那么一个数组中顶多有两个Majority Elements。因此，可以先确定这个两个可能的元素，由于可能存在0个，1个，2个Majority Element，所以需要在确定这两个元素后进行检查。参考自：http://www.cn

2015-08-31 10:34:00 238

原创 LeetCode之Majority Element

/*O(n)解法：1.设置两个变量，cur保存当前元素值，count表示当前元素出现的个数；2.遍历数组， 1）如果当前元素nums[i]==cur,则++count； 2）否则，若count>1，--count;若count==1,则cur=nums[i]；最后，返回cur。*/class Solution {public: int majorityElement(v

2015-08-31 09:18:05 231

原创 LeetCode之Minimum Size Subarray Sum

/*O(n)解法。用sum保存某一子段的和，即sum=nums[i]+...+nums[j]。此时，res = j - i + 1;令sum=sum-nums[i]，如果sum>s, 则res=j-i；否则，sum+=nums[j+1]。重复。*/class Solution {public: int minSubArrayLen(int s, vector& nums) { if(

2015-08-30 20:39:05 277

原创 LeetCode之Maximum Product Subarray

/*如果数组中没有元素0，那么可以按照如下方法处理：1.统计数组中负数的个数；2.如果负数个数为偶数，则结果为数组所有元素相乘；3.如果负数个数为奇数，结果为一下4种情况的最大值： 1）第一个负数前所有的元素的乘积； 2）第一个负数后所有元素的乘积； 3）最后一个负数前的所有元素的乘积； 4）最后一个负数后的所有元素的乘积；所有，可以根据数组中0所在的位置，将原数组分割成一

2015-08-30 19:37:32 276

原创 LeetCode之Missing Number

/*为了获得线性时间的解法，直观的想法是Hash Table，然而Hash Table会引入O(n)的空间复杂度。因此可以试着用输入的数组直接作为Hash Table，用nums[i]存储大小为i的数，第一个nums[i] != i时，找到答案为i。*/class Solution {public: int missingNumber(vector& nums) {

2015-08-30 16:08:35 265

原创 LeetCode之Product of Array Except Self

/*时间复杂度为O(n)的解法：开两个数组sums1[n]、sums2[n]，开数组res[n]存结果。1.sums1元素值为：sums1[i] = num[0]*nums[1]*...*nums[i];2.sums2元素值为：sums2[i] = num[n-1]*nums[n-2]*...*nums[i];(n为数组nums长度)；3.则结果res[i] = sums1[i-1] *

2015-08-30 15:52:58 282

原创 LeetCode之Rotate Array

class Solution {public: void rotate(vector& nums, int k) { if(nums.empty()) return; k %= nums.size(); rotate(nums, 0, nums.size()-1-k); rotate(nums, nums.size()-k,

2015-08-30 11:24:41 276

原创 LeetCode之Summary Ranges

class Solution {public: vector summaryRanges(vector& nums) { vector res; if(nums.empty()) return res; int first(0); for(int i = 0; i < nums.size(); ++i){

2015-08-30 10:54:09 299

转载 LeetCode之Word Ladder II

/*BFS算法。此题与Word Ladder类似，但是需要记录路径。需要解决额外两个问题：1.不能在遍历到当前单词时，删掉遍历到的单词，因为上一层中还未遍历的单词可能能到这个单词，所以只能记下来，等到遍历完当前层时，统一删除。2.为了能够获得路径，需要记录每个单词的前一个单词。参考自：https://github.com/soulmachine/leetcode*/class Sol

2015-08-24 17:23:41 363

原创 LeetCode之Word Ladder

/*相当于寻找某个点到另一个点的最短路径，有点想图的最短路径。可以用宽度搜索求解问题，其思路类似于二叉树的层次遍历，只是在向下走的时候需要从字典中寻找下一层的节点。*/class Solution {public: int ladderLength(string beginWord, string endWord, unordered_set& wordDict) {

2015-08-20 21:44:59 328

原创 LeetCode之Sum Root to Leaf Numbers

/*从根节点到每个叶节点的数字由路径上的所有数字组成，可以采用深度搜索的方法，遍历二叉树的所有路径，也就获得了所有数字。在遍历的同时，将他们累加即可获得结果。*/class Solution {public: int sumNumbers(TreeNode* root) { int sums(0), num(0); Numbers(root, s

2015-08-19 20:38:38 322

原创 LeetCode之Populating Next Right Pointers in Each Node

/*用一个指针扫描上一层已经链接起来的节点，然后将这些节点的儿子节点连接起来即可。*/class Solution {public: void connect(TreeLinkNode *root) { if(root == nullptr) return; TreeLinkNode node(-1); node.next = roo

2015-08-19 20:02:55 311

转载 LeetCode之Binary Tree Maximum Path Sum

/* 参考自：http://www.cnblogs.com/TenosDoIt/p/3435366.html*/class Solution {public: int maxPathSum(TreeNode* root) { if(root == nullptr) return 0; int maxPath = INT_MIN; maxP

2015-08-19 12:13:29 360

转载 LeetCode之Path Sum II

/*与Path Sum类似，只是在递归时，同时记录它的路径。参考自：https://github.com/soulmachine/leetcode*/class Solution {public: vector> pathSum(TreeNode* root, int sum) { vector > res; vector path;

2015-08-19 10:34:35 280

原创 LeetCode之Path Sum

class Solution {public: bool hasPathSum(TreeNode* root, int sum) { if(root == nullptr) return false; if(root->left == nullptr && root->right == nullptr) return root->val == sum;

2015-08-18 22:12:39 255

原创 LeetCode之Maximum Depth of Binary Tree

/*递归法。某树的深度为其左右子树深度较大者加1.*/class Solution {public: int maxDepth(TreeNode* root) { if(root == nullptr) return 0; return 1 + max(maxDepth(root->left), maxDepth(root->right)); }

2015-08-18 19:32:44 251

原创 LeetCode之Minimum Depth of Binary Tree

/*采用递归法求解。*/class Solution {public: int minDepth(TreeNode* root) { if(root == nullptr) return 0; if(root->left == nullptr && root->right == 0) return 1; if(root->left &&

2015-08-18 17:25:49 255

原创 LeetCodeConvert Sorted List to Binary Search Tree

/*这道题与Convert Sorted Array to Binary Search Tree很类似，可以采用相同的方法解题，但是链表不支持随机访问，所以每次都需要查找链表的中间节点。同时，还有一个需要注意的地方：需要将输入的链表复制出来处理，否则会报错。*/class Solution {public: TreeNode* sortedListToBST(ListNode*

2015-08-18 16:58:26 326

原创 LeetCode之Convert Sorted Array to Binary Search Tree

/*采用分治法。排在中间的数作为根节点，前后段各作为左右子树，则左右子树的高度差不会大于1.因此，可以递归的构建左右子树，从而建立整个平衡二叉搜索树。*/class Solution {public: TreeNode* sortedArrayToBST(vector& nums) { return sortedArrayToBST(nums, 0, nums.

2015-08-18 16:22:04 340

原创 LeetCode之Validate Binary Search Tree

/*采用中序遍历，判断两个相邻元素是否满足递增规律即可。*/class Solution {public: bool isValidBST(TreeNode* root) { if(root == nullptr) return true; TreeNode *pre(nullptr), *cur(root); stack s;

2015-08-17 21:37:59 263

转载 LeetCode之Unique Binary Search Trees II

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; *//*采用

2015-08-17 21:05:37 264

转载 LeetCode之Unique Binary Search Trees

/*动态规划。参考自：https://github.com/soulmachine/leetcode设dp[n]表示n个没有重复的数组组成的二叉搜索数的数目。易知，以某个数字i为根节点的二叉树数目为其左子树数目乘以右子树数目。所以有dp[n] = sum(dp[i]*dp[n-1-i])，其中（i = 0,1,2...n-1）。*/class Solution {public:

2015-08-14 16:50:37 248

原创 LeetCode之Construct Binary Tree from Inorder and Postorder Traversal

/*此题利用二叉树中序和后序遍历的性质，递归重建二叉树。*/class Solution {public: TreeNode* buildTree(vector& inorder, vector& postorder) { if(inorder.empty() || inorder.size() != postorder.size()) return nullptr;

2015-08-13 22:10:48 307

原创 LeetCode之Construct Binary Tree from Preorder and Inorder Traversal

/*根据二叉树先序遍历和中序遍历的性质，递归的重建二叉树。*/class Solution {public: TreeNode* buildTree(vector& preorder, vector& inorder) { if(preorder.size() != inorder.size() || preorder.empty()) return nullptr;

2015-08-13 21:41:33 328

转载 LeetCode之Populating Next Right Pointers in Each Node II

/*这里考察的实际上是二叉树的层序遍历。*/class Solution {public: void connect(TreeLinkNode *root) { if(root == nullptr) return; queue cur, next; cur.push(root); while(!cur.empty()){

2015-08-11 19:48:54 344

原创 LeetCode之Flatten Binary Tree to Linked List

class Solution {public: void flatten(TreeNode* root) { if(root == nullptr) return; flatten(root->left); flatten(root->right); if(root->left == nullptr) return;

2015-08-11 19:36:10 256

原创 LeetCode之Balanced Binary Tree

/*遍历整颗二叉树，对于每遍历到的一点，都求它左右子树的深度。如果左右子树的深度差小于或等于1，则平衡的。判断二叉树所有节点，如果有一个不是平衡的，则不是平衡二叉树，否则为平衡二叉树。*/class Solution {public: bool isBalanced(TreeNode* root) { if(root == nullptr) return tru

2015-08-11 18:59:42 293

原创 LeetCode之Symmetric Tree

/*采用递归法，分别对左右子树进行检查。*/class Solution {public: bool isSymmetric(TreeNode* root) { if(root == nullptr || (root->left == nullptr && root->right == nullptr)) return true;

2015-08-10 21:54:03 299

原创 LeetCode之Same Tree

/*同时对两颗数进行遍历即可，同一位置的节点的变量必须相同。除此之外，两个数的结构也必须相同。满足上述条件即为相同的二叉树，否则为不同的二叉树。*/class Solution {public: bool isSameTree(TreeNode* p, TreeNode* q) { if(p == nullptr) return q == nullptr;

2015-08-10 21:33:43 286

转载 LeetCode之Recover Binary Search Tree

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ /*采

2015-08-10 21:27:19 319