u014257954的专栏

会了两数组的交I, II自然就很简单了:class Solution {public: /** * @param nums1 an integer array * @param nums2 an integer array * @return an integer array */ vector intersection(vector& n

/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeNode(int val) { * this->val = val; * this->left = this->right

图是否是树来自lintcode。 这里我用的方法是并查集。 基本思想：对于有n个节点的树，首先生成一个n维数组，并初始化为自己的index，也就是他们的father指向自己。并查集的操作有两个：find（int p）和union（int p， int q）。find是找到参数p的father，union是将p和q的father设置为一个。在Solution里，对传进来的边依次进行find父

这是回溯类型的简单题。 分析： - 函数一定要传一个引用类型的vector，以便以后可以往里加数据。其他参数包括n，k，temp（这个就不可以是引用了），还有最重要的一个i，这个函数栈里应该从哪取。 - 函数里首先应该判断return的条件，即result.size()==k或者temp的最后一个元素达到最大n时return。接下来是for循环，每次重新分配一个temp2，然后往里加i，再调用

还是回溯的问题。 思路：这里应该先对num排序，排序sort（）中是迭代器的范围，然后应该排除重复的组合，所以调用的时候要传入setprocess(num, result, item, target, sum, i+1);item.push_back(num[i]);process(num, result,item, target, sum+num[i], i+1);这三行第一行表示不取，

分治，动态规划。分析：最长的路径一定经过某一个点，并且以这一个点为根节点；所以可以动态遍历每一个节点，找到使路径和最大的根节点。C++代码：/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeNode(int

分治，递归。 这道题有两种好方法。方法1：先有一个求深度depth的函数，然后递归比较各个节点的depth之差，返回结果。C++代码：class Solution { public: /** * @param root: The root of binary tree. * @return: An integer */ int m

排列。通过这道题，我知道了，在一个类中，不可以使用该类中定义的campare函数来作为sort函数中第三个参数，必须使用lambda—-函数对象。它的用法是这样的：{}; 其中，（）中是函数参数，{}中是函数的返回值。还有一个注意的地方就是，关于数字总小到大排列的顺序要搞清楚。C++代码：class Solution {public: /** * @param nums:

回溯问题。 这道题的重点在于退出递归的条件，有：扫描的迭代器大于字符串长度；递归次数大于3；开头是0并且后面还有数字；截取的字符串数字大于255.然后如果满足这些条件，就要判断是否要添加”.”或者是否次数等于3，把它push进result中。 最后，要按照之选一个数字，选两个数字，选三个数字的递归方式找全所有种可能（毕竟如果找4个数字的话，它肯定大于255了）。 C++代码：clas

回溯法： 解题思想：这里的关键点是要搞清楚函数的参数应该传什么，这里应该传的是最后结果，要插入的字符串，左括号的个数，右括号的个数和括号对总数n。有了这样的参数，函数处理起来就方便多了，代码也清晰。不满足递归的条件：左括号数或者右括号大于n或者左括号右括号顺序相反；插入res的条件：左右括号数都等于n；最后递归的代码含义是选择左括号或者选择右括号。C++代码：class Solution

这道题考的还是回溯和递归。思路是这样的，process函数中传入res结果，temp（string的vector）和s（string）。它完成的功能是这样的：如果s为空字符串，则把说明已经找完一个回文串的分割，将这个temp放进res中后返回；否则，就将从s的0到i位开始迭代，看看是否s.substr(0,i)是回文串，如果是的话，就将它放进temp中，然后将从s的第i位开始继续调用此函数，直到s

递归这里就是先构造一个数字到字符串的字典map，然后函数中传入引用res（结果），引用dic（字典），数字字符串，合成的字符串。在process函数里，首先判断返回条件，然后递归调用。C++代码：class Solution {public: /** * @param digits A digital string * @return all posible le

这个问题我看的别人的，用的动态规划解决。dp[i][j]表示的是s的前i个字符和p的前j个字符是否匹配；首先要使从1到最后初始化为false；然后初始化dp[0][0],表示前0个字符肯定匹配；然后根据是否是*来初始化边缘的dp值，如果s是是全*，则dp[i][0]全是true；最后要匹配中间的字符，根据是否有* 和是否有？来判断，最后根据是否相等来判断；返回d[lenS][lenP];

排列。这道题可以参照下一个排列来做，关键是能够举出一个例子来，如123这三个数字组成的排列，归纳出一般的解题方法。中间一些细节需要仔细斟酌。C++代码：class Solution {public: /** * @param nums: An array of integers * @return: An array of integers that's prev

分治法。简单，考虑到大于0，等于0，小于0的各种可能。C++代码：class Solution {public: /** * @param x the base number * @param n the power number * @return the result */ double myPow(double x, int n)

分治法。a%b == (a%b)%b;ans、a要用long long 来保存，不然会溢出；应该用分治法来解决问题，如果n为奇数，就计算一次ans，然后n减半，aa倍增；直到n==0，结束循环C++代码：class Solution {public: /* * @param a, b, n: 32bit integers * @return: An integ

递归，queue，const vector； 这道题应该：看懂题意；想到用queue；还有就是函数传入的参数不是const vector，但是如果传入的是const vector的话就会出错。C++代码：/** * // This is the interface that allows for creating nested lists. * // You should not im

这道题应该背下来，是经典的DP问题。当n==1时，有k种方案；当n==2时，有k*k种方案；当n==3时，分两种情况：1：后两根颜色相同（有num[1] * （k-1）=k*(k-1)种方案）2：后两根颜色不同（有num[2]*(k-1) = k*k*(k-1)种方案 ）以后num[i]表示前i根柱子的方案数，num[i-1],num[i-2]表示前i-1 和 i-2种方案

分治法。分左右子树进行计算，但在计算时，有两点需要注意：需要另外创建一个函数，它用来传递不能超过的最低值和不能超过的最高值；但是还有一个特殊值需要排除，就是最大最小int本身。C++代码：/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *ri

分治法。 这道题我是先用自己的方法做了出来，花费了很多时间，调试了很多次。最后和网上的解法对比了一下，发现自己的合并两个链表的函数太繁杂，包含太多if else，典型的初学者思维，代码不简洁还容易出错。所以网友的方法是在是值得学习，建议记下来，这是公式化的合并双链表法。我的C++代码：/** * Definition of ListNode * class ListNode { * publ

这道题主要是可以学习一下C/C++的字符串和数字的互相转化问题。1 string--->数字：在C的stdlib.h库中，有atoi，atof等函数，但要注意，这是C风格的转换方法，形参必须是char*类型的字符串，不可以是C++的string。2数字--->string： sprintf函数；最后发现还可以用更简单的方法迭代一下就可以算出最后结果。C++代码：clas

这道题思路简单:1.首先确定right-------指向的是最右端不为零的数的下标;2.从右向左依次迭代.代码:class Solution {public: /** * @param nums an integer array * @return nothing, do this in-place */ void moveZeroe

C++代码：/** * Your object will be instantiated and called as such: * ShapeFactory* sf = new ShapeFactory(); * Shape* shape = sf->getShape(shapeType); * shape->draw(); */class Shape {public:

此题用到了深度搜索的思想，在depth_search()中，首先判断边界条件和是否为0的点，然后对该点的上下左右进行depth_search()：class Solution: # @param {boolean[][]} grid a boolean 2D matrix # @return {int} an integer def numIslands(self, g

这道题的做法就是把模式记下来。源函数是传入一个二叉树（treeNode*），但是我们应该自己再实现一个函数search用于传递结点、vector的引用和string path，这样可以递归的去调用search，当然，在search中一开始就有结束条件，遇到结束条件会return。随着不断地递归，只要不满足结束条件--------root的left和right都为NULL，该递归就会不断地增长pat

注意：1.ctype.h这个库里有toupper()、isdigit()、isalpha()、这些函数。这样就不用自己写了，虽然自己写也简单，但是记住这些功能就会方便很多。做了这道题，我还看了ctype库里还有判断是否为空白，空格，十六进制，操作符，标点符号等函数，记住他的这些功能然后以后用到的时候就可以去搜。我的C++代码（多写了自己的判断代码）：class Solution {

这道题简单，典型的从左右两端推进算法。C++代码：class Solution {public: /** * @param nums: a vector of integers * @return: nothing */ void partitionArray(vector &nums) { int i=0,j=nums.si

看两个二叉树形状和内容是否完全相等。可以递归求解，每一个调用栈内存储两个返回的bool结果：lflag和rflag。然后返回它们的与。同样，和通常的递归思想一样，调用栈开始就要做好递归结束的判断：a、b都为NULL返回true，一个为NULL另一个不为NULL返回false，val不相同返回false。C++代码：/** * Definition of TreeNode: * class

这个应该实现真实的节点的交换，而不只是节点值的交换。这种题一定要用笔来模拟一遍！C++代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {}

我的一开始思路是先将root按照先序遍历输出到一个queue中，然后依次处理其节点,记得要把left节点置为NULL。程序比较简单，易懂。C++代码：/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeN

这种题目就是按照《算法导论》的来就行。先添加一个python的归并排序，一开始只能通过95%的数据，后来按照《算法导论》归并后的第一个习题改了一下，可以全部通过，但是时间还是挺长。归并排序-python代码：class Solution: # @param {int[]} A an integer array # @return nothing def sort

Map类负责对原始数据进行处理，将单词拆分后输出到output； Reduce负责对Map输出的数据进行计数。C++代码：/** * Definition of Input: * template * class Input { * public: * bool done(); * // Returns true if the iteration ha

注意C++中注意int、float转化为string的方法：#include#include#includeusing namespace std;string itos(float a){ stringstream ss; ss<<a; return ss.str();}int main() { float a = 32.232; string ss = ito

LintCode的特色是它可以为你检测代码的风格是否人性化，长得好看。比如：for，if 后面应该加一个空格，{ 之前也应该有空格，= 等运算符左右应该有空格等等。然后下面是我的简单O(n^2)排序算法:选择排序：class Solution {public: /** * @param A an integer array * @return void

思路一： 先排序，然后依次遍历，时间复杂度是nlog(n)，仅仅排序耗时：python代码：class Solution: def intersection(self, nums1, nums2): len1 = len(nums1) len2 = len(nums2) nums1.sort() nums2.sort(

步骤：1.先对vector排序。2.再按要求合并。用到的知识：sort存在于algorithm头文件中； vector的erase（）的参数是迭代器。C++代码：/** * Definition of Interval: * classs Interval { * int start, end; * Interval(int start, int end

这个就是递归和非递归两种方法，非递归难一点，但是不用调用栈。递归：注意vector相接的方法，用insert（，，）。C++代码：/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeNode(in

使用两个栈来实现。第二个栈先遍历其本身，然后遍历其右孩子，最后遍历其左孩子。这正好与后续遍历相反！所以第二个栈的出栈顺序就是后续遍历的顺序。C++代码：/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * Tree

注意：C的math.h头文件中的pow(a,b)中，b应该是小数，不能是1/2这样的分数。C++代码：class Solution {public: /** * @param A: An integer array. * @param B: An integer array. * @return: Cosine similarity. */