2014年03月_littlestream9527

10月 09月 08月 03月 02月 01月

原创 LeetCode Word Ladder

终于憋出来了，虽说还不是特别好。没想到一点点的改动竟然是过于不过的差别就是这句：if(temp>1) break;。这题最令我为难的是我不能用unordered_set这个数据结构，原因简单的很，我用的是XP，VS是2008版的，所以操作都是基于vector的，首先就是复制到vector，这题就是找两点之间的最短距离呗，先是试了佛洛依德，后来迪杰斯克拉，后来广度优先，都没通过（要么时间要么空间），

2014-03-21 22:16:05 739

原创 LeetCode Valid Palindrome

这题感觉没什么，就是判断输入是否为数字，字符时比较麻烦，其他没啥。 bool isPalindrome(string s) { int lens = s.length(); if(lens==0) return true; int i=0,j=lens-1; while(i<j) { if(s[i]<'0') { i++; continue; } if(

2014-03-16 17:26:04 615

原创 LeetCode Binary Tree Maximum Path Sum

提也不怎么难，马虎了好几次，剑指offer上有类似的找最大和，那题是找叶子节点，这题是任意的节点，反正就是求和，一样的方法。 int maxPathSumRecursive(TreeNode *root,int &maxsumtoroot) { if(root==NULL) { maxsumtoroot = INT_MIN; return INT_MIN; } int leftm

2014-03-16 17:00:50 693

原创 LeetCode Best Time to Buy and Sell Stock III

这是好题，所谓的好题就是必须用优化的方法解，否则通不过。只能交易两次股票，本来想到第二题中的方法，找每个最小值最大值的差值，找两个最大的，仔细分析发现，这样的方法是错的，比如5,9，6，12，按上面的方法回提取两个最大差值，5和9,6和12，如果后面还有数，假设还是5，9，6，12，那么最大的利润值应该是两次5和12，也就是说不能选择每临近的最大值最小值的差值。接下来想到了二分法，从某一点划分开，

2014-03-16 15:23:37 724

原创 LeetCode Best Time to Buy and Sell Stock II

屡明白就行了，就是找小的，然后找大的，没找到这样一个组合就进行一次交易，把利润加到结果里，继续找。假设小数是5大数是9，对于之间出现的按序的数比如6,7,8不影响结果，因此直接略过，但对于不安续出现的比如5，8,7，9这样的话因为可以进行两次交易，这样利润会更大。 int maxProfit(vector &prices) { if(prices.size()==0||prices.size(

2014-03-14 19:50:03 629

原创 LeetCode Best Time to Buy and Sell Stock

就是找后面的数减去前面的数的最大差值，做过。 int maxProfit(vector &prices) { if(prices.size()==0||prices.size()==1) return 0; int maxdiff=0; int minvalue = prices[0]; for (int i=1;i<prices.size();i++) { if (price

2014-03-14 19:14:25 668

原创 LeetCode Triangle

题目得说明路径不能跨越，否则的话，每层找最小的就可以了。为什么多提交两次呢？dp[j] = (dp[j]>dp[j+1]?dp[j+1]:dp[j]) + triangle[i][j];要是条件表达式不加括号的话不可以，那样的话后面的加法就没加上。还有一点就是j从小到大遍历，否则的话会覆盖结果，正常人都会从小到大。 // LeetCode_Triangle.cpp : 定义控制台应用程序的入口点

2014-03-14 18:51:46 567

原创 LeetCode Pascal's Triangle II

不让用开辟空间的话不知道怎么做，要是让开辟空间，真没什么，但是容易马虎，所有parr[j] = parr[j] + parr[j-1];用一维数组解决时都应j从大到小，否则的话会覆盖原来的值。 vector getRow(int rowIndex) { vector ret; if(rowIndex<0) return ret; int *parr = new int[rowIndex

2014-03-13 22:09:48 556

原创 LeetCode Pascal's Triangle

见过无数次了，终于写了一次，一个数组都没用。 vector > generate(int numRows) { vector oneresult; vector > ret; if(numRows==0) return ret; oneresult.push_back(1); ret.push_back(oneresult); oneresult.clear(); int le

2014-03-13 21:46:27 507

原创 LeetCode Populating Next Right Pointers in Each Node II

有意思，看了题意，我只想说一句：上一题的方法依然好使，我只把64改成640就提交通过了。我却迷惑了，任意的二叉树640层完全不够用呀，1000层，10000层也有可能呀，难道还有什么更好的方法吗？ TreeLinkNode* layers[640]; void preOrderLayer(TreeLinkNode *root,int layer)//,TreeLinkNode *&layers

2014-03-13 20:59:31 563

原创 LeetCode Populating Next Right Pointers in Each Node

这题很有新意，刚开始想到后序遍历，可是对于给的例子5和6之间怎么连接呢？无论怎么遍历5和6之间都隔好几个数，递归引用传参数的方法肯定不行，题中又说常量的空间，对于完全二叉树最多也不过64层吧，所以每一层设定一个指针用于建立连接。传递指针数组不太容易，用了全局变量解决。如下： // LeetCode_PopulatingNextRightPointers.cpp : 定义控制台应用程序的入口点。

2014-03-13 20:53:38 564

原创 LeetCode Distinct Subsequences

这题有有意思，比前面的题好多了，刚开始时理解题意有误，就是没明白什么意思，看了别人的博客才明白。之后就是方法的问题，递归，动态规划，然后是动态规划的优化，不优化的动态规划不通过。所谓的优化，其实就是用一维数组代替DP的二维数组，dp式子dp[i][j]=dp[i-1][j-1]+dp[i-1][j](S[i]==T[j])时；dp[i][j]=dp[i-1][j](S[i]!=T[j])时；只要是

2014-03-13 20:14:19 568

原创 LeetCode Flatten Binary Tree to Linked List

这题还算有点意思，有意思的地方就是虽说是按先序遍历的方式连接的，却不能按先序的方式遍历（这样的话递归时会改变树的结构，导致找不到后面的节点），于是按照先序相反的方式遍历（注意，这可不是后序遍历），程序是写出来了，问什么多提交了几次，我理解成的双向链表了，结果居然提示时间超时，看看别人的程序才知道自己错哪了。 void flattenRecursive(TreeNode *root,TreeNod

2014-03-11 21:24:49 567

原创 LeetCode Path Sum II

没什么新意，就是在遍历到叶子节点的时候把一个结果存入结果集中，注意恢复临时结果。 void pathSumRecursive(TreeNode *root,int sum,vector &oneresult,vector > &ret) { if (root->left==NULL&&root->right!=NULL) { oneresult.push_back(root->val);

2014-03-11 19:39:47 615

原创 LeetCode Path Sum

做这题感觉像大妈在菜市场买菜唠唠叨叨，没什么技术含量，感觉有点烦。 bool hasPathSum(TreeNode *root, int sum) { if(root==NULL) return false; if (root->left==NULL&&root->right!=NULL) { return hasPathSum(root->right,sum - root->v

2014-03-11 19:26:44 481

原创 LeetCode Minimum Depth of Binary Tree

没什么难度的，刚开始又马虎了。。。 int minDepth(TreeNode *root) { if(root==NULL) return 0; if (root->left==NULL&&root->right!=NULL) { return minDepth(root->right)+1; } else { if (root->left!=NULL&&root->r

2014-03-11 19:08:40 501

原创 LeetCode Balanced Binary Tree

剑指offer上的题目，马虎了多提交了两次。 bool isBalancedRecursive(TreeNode *root,int &lenth) { if(root==NULL) { lenth = 0; return true; } int leftlenth,rightlenth; if (isBalancedRecursive(root->left,leftlenth

2014-03-11 18:54:45 572

原创 LeetCode Convert Sorted List to Binary Search Tree

这题刚开始的做法是把链表中的元素放到数组，然后按照上一题的做法，结果出现内存不够用而通不过，再想想，和上题相似，对链表递归操作，每次找到中间位置就行了，只不过时间复杂度增加了点，但对于链表这不可避免的。如下： TreeNode *resusiveListToBST(ListNode *head,int num) { if(head==NULL||num<=0) return NULL;

2014-03-10 22:10:27 502

原创 LeetCode Convert Sorted Array to Binary Search Tree

刚开始看这题真有点傻眼，平衡二叉搜索树，要不断地旋转才能保证平衡，那还要求有序数组干什么，不有序的数组也可以建立平衡二叉搜索树，所以想到不旋转该怎么做，要保证平衡性，只要平衡二叉树的左右子树节点数相差一即可，并且对于其所有的子树也满足这样的要求。这就是平衡二叉树了，至于搜索树，只要保证左面的比其小，右面比其大即可，这正是有序数组的原因呀，这么一想就出来了。 TreeNode *recursive

2014-03-10 21:41:58 553

原创 LeetCode Binary Tree Level Order Traversal II

如果说直接给这道题，没有前面那些题的铺垫，没准我会晕一阵子，有了前面的题就好办了，只是多一行代码。这题也说明了，有些题刚开始真是无从下手，或者按照题目要求的直接求很难求，比如这题，怎么才能先遍历子节点然后遍历父节点呢？这么想肯定晕，但是若能想到按照常规的遍历方法，只是结果集存在容器里，然后对容器里的元素处理就可以解出题目了。 vector > levelOrderBottom(TreeNode

2014-03-10 20:43:03 502

原创 LeetCode Construct Binary Tree from Inorder and Postorder Traversal

有了先序中序建二叉树，这题也是多余的。 TreeNode *generateOneTree(vector &midOrder,int midFrom,int midEnd,vector &postOrder,int postFrom,int postEnd) { TreeNode *p=NULL; if(midFrom>midEnd||postFrom>postEnd)

2014-03-10 20:35:27 493

原创 LeetCode Construct Binary Tree from Preorder and Inorder Traversal

前两天写过这样的程序，所以直接贴那天那个了，注意的是这里没有判断是否输入合理，对于判断是否两个序列（一个先序，一个中序）构成二叉树的问题又是另一个问题了，剑指offer上的。这题如下： TreeNode *generateOneTree(vector &preOrder,int preFrom,int preEnd,vector &midOrder,int midFrom,int midEnd)

2014-03-10 20:17:19 555

原创 LeetCode Maximum Depth of Binary Tree

没什么说的，要是非说的话，就是：这类题不应该在leetCode上出现。 int maxDepth(TreeNode *root) { if(root==NULL) return 0; int leftDepth=0,rightDepth=0; if (root->left) leftDepth = maxDepth(root->left); if(root->right) r

2014-03-10 20:06:24 484

原创 LeetCode Binary Tree Zigzag Level Order Traversal

比上一题多两行代码，就是在装入结果集时判断当前层数是奇是偶。这题要是更改遍历的方式，按照左子树右子树，右子树左子树的方式遍历恐怕要很难处理。 // LeetCode_BinaryTreeLevelOrderTraversal.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include u

2014-03-10 20:00:21 467

原创 LeetCode Binary Tree Level Order Traversal

这题不是普通的层次遍历，而且要分清每一层，办法就是对每一层的节点标注编号，编号相同的在同一层，队列里的元素是经过编号后的新结构体，刚开始想用1,2,4,8来编号这样能表示所有的节点，但是当层数多的时候数字不够用了，所以只能用012345678来编号了。如下： // LeetCode_BinaryTreeLevelOrderTraversal.cpp : 定义控制台应用程序的入口点。 // #i

2014-03-10 19:42:29 590

原创 LeetCode Symmetric Tree

思路就是：非递归中序遍历，只不过左子树右子树同时进行，而且方向始终相反，每一动一步都要判断当前两个指针的内容是否不同，一旦不同返回false；最后返回true；如下： bool isSymmetric(TreeNode *root) { if(root==NULL) return true; if(root->left==NULL&&root->right==NULL) return

2014-03-07 21:58:00 530

原创 LeetCode Same Tree

无它 bool isSameTree(TreeNode *p, TreeNode *q) { if (p==NULL&&q==NULL) return true; if (p==NULL&&q!=NULL||p!=NULL&&q==NULL) return false; if (p->val!=q->val) return false; return isSameTree(p

2014-03-07 20:54:22 537

原创 LeetCode Recover Binary Search Tree

只要记住中序遍历的顺序即可，不用开辟数组存储中序的序列，只需判断是否逆序就行了，逆序的用指针标出位置，然后交换个指针的值。想是想不出来的，在纸上画画揪出来了，就像刚才面阿狸的第一道算法题，手头没有笔思路打不开，回来一画揪出来了。如下： void interTrave(TreeNode *root,TreeNode *&plast,TreeNode *&p,TreeNode *&q,bool &i

2014-03-07 20:40:35 637

原创 LeetCode Validate Binary Search Tree

天若有情天亦老，人间正道是沧桑。输了，在那没考虑全面甚至没去考虑全面而提交的一刻就输了，再回首，正是那年似曾相识的题目，躲在旮旯深处！错了之后一想，记忆清晰呀，微策略面试题，在家里面试的，做之前却没想起来。所以还是原样子错过了。这题就是这么一个陷阱，明白了绕过来就行了。 bool isLeftRight(TreeNode *root,int &Biggest,int &Smallest) {

2014-03-06 21:55:13 537

原创 LeetCode Interleaving String

好题呀，适合面试。理解题意后首先想到的是递归，画了画，写了写，确实可以递归，再想想，恩，也可以用DP，于是写了dp的程序提交第一次，失败，开辟的空间太小了，在开辟大一点却被编译器限制了；试试递归吧，果然时间限制；恩，肯定还有可以优化的地方，再仔细看看，确实如此，DP【i】【j】【k】中，k始终等于i+j，不是多此一举吗，试试确实能去掉k，因此也就去了一维，二维数组就可以开辟500*500的空间了，

2014-03-06 20:50:53 554

原创 LeetCode Unique Binary Search Trees II

题记：我只看见一棵接一棵的树，却没看见整个森林。这题搞得蒙呀，刚开没看题意，以为和按顺序入栈出栈的种类一样呢，结果题意是：搜索二叉树，中序是123，求先序的可能。想了半天这也不能转化为进栈出栈的问题，有一种解法是求所有的排列，然后对任意排列作为先序判断是够能和按序的中序组成二叉树，再把符合条件的组合构建二叉树，确实很麻烦。再看看，肯定是有更直接的求法，自己没想出来，贴的别人想法。如此干练精

2014-03-05 11:13:20 492

原创 LeetCode Unique Binary Search Trees

卡特兰数，这题直接答1/（n+1）C(n,2n)最简单，而且时间也是最快的；但是怎么求出来的呢？下面的一道题是具体怎么构造二叉树，二叉树得不断开辟空间，进栈出栈的折腾还得删除空间（递归时要恢复现场）；所以我打算从1,2,3，n的入栈顺序，找出所有可能的出栈顺序，这个结果的个数也就是该题的结果。就是这个程序，没想到自己写了一天也没写出来，下面是我的错误的程序： void numPushPop(in

2014-03-04 21:19:49 459

原创 LeetCode Binary Tree Inorder Traversal

最简单的二叉树的题型了，好久不看还是一下子写了出来 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; vector inorderTraversal(TreeNo

2014-03-03 20:11:19 564

原创 LeetCode Restore IP Addresses

思路:可以枚举不用递归了，每个数字最多有三位数字，倒是由于马虎多提交了两次。 bool isValidNum(string s) { int num = 0; int len = s.length(); if(len>1&&s[0]=='0') return false; for (int i=0;i<len;i++) { num = num*10 + s[i] - '0';

2014-03-03 19:47:01 508

原创 LeetCode Reverse Linked List II

用插入法实现链表的倒序，对于是否从第一个元素开始的情况分别对待，没测试提交，第一次居然犯了太低级的错误了；这题给出了一个前提保证了m小于等于n小于等于链表长度，所以程序里不用担心链表在任何时候走过了（那样的话处处都得判断指针是否为空），我想说的是在没给出这样条件的时候，自己编程时也应该这样考虑，编写的函数假设输入合法，对于不合法的输入应该预先做一下判断，并且封装在另一个函数里，这样把核心算法与输入

2014-03-02 11:25:45 576

原创 LeetCode Subsets II

剑指offer上有不重复的排列，效率肯定比这个快，因为那个直接判断就能确定重复，少了很多递归，下面的算法却不同，利用递归求出所有的解决方案，然后再去除重复的，效率慢了不少，却也通过了，能不能有更好的方法呢？ // LeetCode_SubsetsII.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include

2014-03-01 19:23:45 664