leetcode解题思路

转载地址：http://blog.csdn.net/liuxialong/article/details/41941407

收录https://oj.leetcode.com/problems/ 所有题目的解题思路。

Min Stack

题目要求：

设计一个最小栈，要求能实现pop、push、min操作，也就是返回栈内元素最小值。

解法：

新加一个辅助栈，保存当前栈内最小值。当入栈元素小于辅助栈栈顶元素时，同时入辅助栈；出栈时，当出栈元素等于栈顶元素时，同时辅助栈出栈。

Find Minimum in
Rotated Sorted Array II

题目要求：

旋转过的有序数组，数组内可能有重复元素，求最小值。

解法：

1、比较num[begin] < num[end]，试探是否旋转了。如果没旋转，直接返回num[begin];

2、如果旋转了。分情况讨论：

a、num[mid] > num[begin]，说明最小值在后半段[mid+1, end];

b、num[mid] < num[begin]，说明最小值在前半段[begin, mid];

c、num[mid] == num[begin]，如果num[begin] == num[end]，则两半段都要找一遍，如果num[begin] > num[end]，则最小值在后半段[mid+1, end];

Find
Minimum in Rotated Sorted Array

题目要求：

旋转的有序数组，数组内没有重复元素，求最小值。

解法：

1、比较num[begin] < num[end]，试探是否旋转了。如果没旋转，直接返回num[begin];

2、如果旋转了。分情况讨论：

a、num[begin] < num[mid]；说明最小值在后半段[mid+1, end];

b、num[begin] > num[mid]；说明最小值在前半段[begin, mid];

c、num[begin] == num[mid]；说明begin == mid，直接返回min(num[begin], num[end]);

Maximum Product Subarray

题目要求：

寻找连续子串中乘积最大的数。

解法：

和求最大字段和解法相似，不同的是，这里保留一个最大值，一个最小值。每次扫描一个数字时，更新这两个变量。

Reverse Words in a String

题目要求：

翻转整个字符串，但不颠倒单词内部字符的顺序。

解法：

先整体翻转一下，再以空格为分隔符翻转每个单词。

Evaluate Reverse Polish
Notation

题目要求：

求解反转波兰表达式。

解法：

栈操作即可。遇到数字入栈，遇到运算符则出栈，每次出栈两个数字，计算出的结果后入栈运算结果。

Max Points on a Line

题目要求：

给出一堆点，求在同一条线上最多的点个数。

解法：

用unordered_map保存斜率，选取某点为参照物，计算其他点与该点的连线的斜率。平行于Y轴的斜率可用INT_MAX表示。注意重复点。

Sort List

题目要求：

用nlogn的时间复杂度，对单链表排序。

解法：

把链表拆成两半，分别排序后，再合并。

Insertion Sort List

题目要求：

用插入排序 排序单链表。

解法：

逐步遍历，逐一插入。

LRU Cache

题目要求：

设计一个最近最少使用的cache，支持set、get操作。

解法：

设计一个双链表，保存kv数据，以满足快速移动节点操作。同时设计一个unordered_map方便根据key快速查找链接节点node。

Binary Tree Postorder Traversal

题目要求：

非递归实现二叉树后续遍历。

解法：

设置一个栈，先找到最左边的节点，经过的所有节点入栈。然后开始出栈，出栈时输出节点，并且判断该节点是否是新的栈尾节点的左节点。如果是，则寻找新的栈尾节点的最左边的子节点，寻找过程中经过的节点入栈。其他情况则继续出栈。直到栈为空。

Binary Tree Preorder Traversal

题目要求：

非递归实现二叉树前序遍历。

解法：

设置一个栈，先找栈最左边的节点，经过的节点逐一入栈，同时输出。然后开始出栈，出栈时判断是否存在右节点，如果存在，找到最左边的节点，并且逐一入栈和输出。如果不存在，则直接出栈。直到栈为空。和后续遍历相比，这里访问过的节点直接出栈，并不做保存。

Reorder List

题目要求：

将链表按照even-odd重新排序。要求in-place。

解法：

用快慢指针找到中间节点，将链表一分为二（要将前半段尾节点left_tail->next = nullptr），后半段逆序后，再和前半段逐一合并。

Linked List Cycle II

题目要求：

给定单链表，找到环的开始节点，如果不存在环，则返回null。

解法：

快慢两指针同时指向头结点，一个走一步，一个走两步，能相遇说明有环，遇到null说明无环。相遇后，将慢指针重新指向头结点，两个指针同时一次一步开始前进，相遇的那个点就是环的入口。

Linked List Cycle

题目要求：

给定单链表，确定该链表是否有环。

解法：

同上。

Word Break II

题目要求：

给定一个字符串，可以由词典中某些单词按顺序组成，要求输出所有可能的组合。

解法：

DP+backtracking。可以用回溯法解决，从头扫描字符，当发现字典中存在的字符串时，将剩下的字符串继续考察，如果直到字符串结束，则算作一个组合。否则，抛弃。

但这种方法存在重复查找字典的操作。所以用dp的方法，申请一个二维数组flag，flag[i][j]表示从i到j的子串是否在字典中存在。扫描一遍字符串发现所有可能匹配的子串，然后从尾部开始，检测是否能够通过该尾部组合，成功匹配。比如:flag[i]行全部flag均为false，说明从i开始往后找，不可能找到匹配的子串，所以flag[X][i]的所有flag均可以置为false。得到这个二维数组后，再用backtracking的方法可以节约匹配时间。

Word Break

题目要求：

给定一个字符串，判断是否可以由词典中某些单词按顺序组成，返回true or false。

解法：

可以用word break II的思路，dp+backtracking。也可以用hash_map代替dp数组，设置一个map，保存无法由词典构造的所有字符串。

Copy List with Random Pointer

题目要求：

单链表，每个节点带随机指针指向别的节点。要求copy一份一模一样的单链表。

解法：

插入法。分三步走，首先将新节点放在每个旧节点的next上面。其次，将新节点 的random指向旧节点的random的next（如果random非空）。最后，解除新旧节点的链接关系（注意bound case，结尾时要判断next是否为空）。

Single Number II

题目要求：

一个整数数组，除了一个整数出现一次，其他整数均出现三次，求出现一次的这个整数。

解法：

用数组vec[32]统计所有数字，在各个比特位上出现的次数。每个比特位上的数字mod3后剩下的就是出现一次的整数。（注意有负数的可能，所以全程都直接统计比特位）

Single Number

题目要求：

一个整数数组，除了一个整数出现一次，其他均出现两次，求这个出现一次的整数。

解法：

用上题的方法也可以。这里用异或也行。

Candy

题目要求：

给一组孩子分糖果，要求每个孩子最少一个糖果，且高个孩子比相邻的矮个孩子分到的糖果要多。求，最少要提供多少糖果可以满足要求。

解法：

初始化每个孩子一个糖果。从左往右扫描一遍，后面的孩子和前面的孩子做比较，如果后面的孩子个头大，但糖果却不多，则调整至比前面的孩子多一个。从右往左扫描，同理。然后把所有的糖果加起来。

Gas Station

题目要求：

一个环上面分布着几个加油站，加油站里有油，问车子从哪个加油站开始出发，可以跑完全程。

解法：

从某点开始，记录所有油量-消耗量，当发现不够时，从下一个加油站开始继续统计。同时记录所有经过的加油站的油量-消耗量。

当环走完一圈时，如所有油量-消耗量>0，则可以跑完全程，且起点是最后一个记录的可以跑到终点的加油站。

Clone Graph

题目要求：

深度复制一个无向图。

解法：

因为节点label唯一，借助map，记录新图的相应节点。

Palindrome Partitioning II

题目要求：

给定一个字符串s，要求切成的每一块都是回文，求最少需要切几下。

解法：

dp，设置一个初始化数组flag[i][j]，表示从i到j的子串是否为回文。if (s[i] == s[j] && (i - j == 1 || flag[i + 1][j-1] == true)) { flag[i][j] = true;}

随后利用这个flag数组，再做一次dp，申请一个一维数组cut[i]，记录从0到i需要的切次数，cut[i] =  flag[0][i] == true ? 0 : from 0 to i ,min(cut[j] + 1)

Palindrome Partitioning

题目要求：

给定字符串s，要求切成的每一块子串都是回文，求出所有可能的切法组合。

解法：

dp，设置一个初始化二维数组flag[i][j]，表示从i到j的子串是否为回文。

随后，做一次清洗，从头到尾check一遍，如果从i出发所有的子串都不是回文，那么所有到达i的回文都不可能组成s，所以，一旦整个flag[i][x]都是false，那么flag[x][i-1]也应设成false。

最后用backtracking，统计所有可能的组合。

Surrounded Regions

题目要求：

一个矩形，里面有O有X，要求把所有被X包围的O改成X。

解法：

bfs或dfs都可以。在边上的O，肯定是没完全被X包围的。通过四条边，用dfs(递归)或bfs(queue)，找到没被X完全包围的O，标成E。然后再扫描一遍矩阵，将O、X全部改成X，E改成O

Sum Root to Leaf Numbers

题目要求：

二叉树，每个节点上有个数字，从跟到叶子的路径可以组成一个数字，求所有数字的总和。

解法：

用bfs递归，找到叶子节点时把组成的数字累加，最后返回总和。

Longest Consecutive Sequence

题目要求：

给定一个数组，要求找到数组中数值连续的最大长度，要求时间复杂度O(n)。

解法：

排序不行，因为排序O(nlgn)。这里用unordered_set存储所有数字，扫描一遍数组，每个数字，挨个找左右数字，更新连续数值的长度。为了防止重复扫描，删除set中已经扫描过的数字。

Word Ladder II

题目要求：

给一个start字符串，end字符串，和一堆词典。要求找到最短的转移方法。有几种列几种。

解法：

bsf（queue），设置前驱map，保存节点前驱，方便恢复路径。

Word Ladder

题目要求：

给一个start字符串，end字符串，和一堆词典。要求找到最短的转移方法。有几种列几种。

解法：

bfs（queue），每遍历完节点记得删除，避免重复计算。

Valid Palindrome

题目要求：

判断是否为回文，可跳过非字母数字字符，且不考虑大小写。

解法：

遇到非字母数字直接跳过。



Binary Tree Maximum Path Sum

题目要求：

二叉树，节点带值，找到值和最大的路径，路径可以从任意节点到任意节点。

解法：

递归。每次返回该节点为根的最大路径和穿过该节点的最长路径。

Best Time to Buy and
Sell Stock III

题目要求：

有一组股票价格序列，最多两次交易，求最大利润。（卖完可以立马买）

解法：

dp问题。先用left[i]数组，求出在i时刻以前（包括i时刻）先买后卖的最大利润。再用right[i]数组，求出在时刻j以后，先买后卖的最大利润。

然后遍历一遍两个数组，求出max(left[i] + right[i])

Best Time to Buy and
Sell Stock II

题目要求：

给定一个股票价格序列，交易次数无限制，求可以获得的最大利润。

解法：

贪心。高点卖，低点买。从左开始扫描，把所有上升坡段的增值累加起来就行。profit += prices[i + 1] > prices[i] ? : prices[i+1] - prices[i] : 0;

Best Time to Buy and Sell
Stock

题目要求：

给定一个股票队列序列，只交易一次，求可获得的最大利润。

解法：

dp，保存i以前的最小价格，profit = max(profit, prices[i] - min_price)

Triangle

题目要求：

三角形数组，求从跟到叶子和最小路径。

解法：

dp，申请一个底边长大小的数组，每次数值等于上一行两个数字最小的那个+当前数字，不断更新这个数组即可。（注意每次更新数组，从后往前更新）

Pascal's Triangle II

题目要求：

三角数组，每个数字等于上一行两个数字之和，求第t行数组。

解法：

dp，申请一个t大小的数组，逐行更新，每次更新从后往前，循环t次。

Pascal's Triangle

题目要求：

生成共t行的三角数组，每个数字都是上一行两个数字之和。

解法：

逐行相加即可。

Populating
Next Right Pointers in Each Node II

题目要求:

给定二叉树，为每个节点的同行下一节点指针赋值。

解法：

层次遍历，queue。同level节点队尾设nullptr。

Populating
Next Right Pointers in Each Node

题目要求：

给定完美二叉树，同上。

解法：

同上。

Distinct Subsequences

题目：

给定字符串S，字符串T，求S中有多少个不同的子序列是T。（子序列，不要求序列连续，但要求顺序）

解法：

dp，开辟二维数组flag[i][j]，记录从0到i的S，可以组成多少个从0到j的T，flag[i][j] = flag[i-1][j] + S[i] == T[j] ? flag[i-1][j-1] : 0

最后返回flag[S.size()][T.size()]

Flatten Binary Tree
to Linked List

题目要求：

将二叉树按前序遍历排成一个单链表。

解法：

非常巧妙的办法，如左子树不存在，则直接看右节点；若存在，则找到左子树的尾节点，也就是左子树的最右边节点，把右子树挂到这下面，然后把左子树移到右边，左指针置空。然后看右指针。这种办法每次都解决一个节点的flatten问题，依次解决直到最后节点。

Path Sum II

题目要求：

给定二叉树，找到路径和为某数的路径。

解法：

递归，找到叶子节点，如果和为指定某数，则输出。注意节点可能有正有负，所以不能剪枝，必须遍历所有路径。

Path Sum

题目要求：

给定二叉树和一个给定数字，判断是否存在和为该数字的路径。

解法：

同上。

Minimum Depth of Binary Tree

题目要求：

求二叉树的最小深度。（深度定义为路径上节点的个数）

解法：

递归或非递归（层次遍历用queue）

Balanced Binary Tree

题目要求：

给定一个二叉树，判断是否是平衡二叉树。

解法：

递归，先判断子树是否为平衡二叉树，并根据返回的子树树高判断本节点的树是否为平衡二叉树。

Convert Sorted
List to Binary Search Tree

题目：

用排序好的链表创建BST。

解法：

计算链表长度，以后每次递归到中间节点，用中间节点建根（偶数时，取前一个），递归下去建树。

Convert Sorted
Array to Binary Search Tree

题目：

用排序好的数组创建BST

解法：

每次用中间节点建树，递归。

Binary Tree Level
Order Traversal II

题目：

按层遍历二叉树。

解法：

非递归用queue

Construct
Binary Tree from Inorder and Postorder Traversal

题目：

中序后序建二叉树。

解法：

递归

Construct
Binary Tree from Preorder and Inorder Traversal

题目：

前序中序建立二叉树。

解法：

递归

Maximum Depth of Binary Tree

题目：

求二叉树的最深深度。

解法：

递归。

Binary Tree Zigzag
Level Order Traversal

题目：

层次打印二叉树，要求第一层从左到右，第二层从右到左，以此类推。

解法：

非递归，用queue，每层节点用vector先存着，level%2 == 0时，正序输出，否则，反序即可。

Binary Tree Level Order
Traversal

题目：

层次遍历二叉树。

解法：

非递归，用queue。

Symmetric Tree

题目：

给定一个二叉树，判断树是否是对称结构。

解法：

递归，每次判断节点相对应的节点在另一半子树那里，是否存在且相等。

Same Tree

题目：

判断两棵树，是否结构和值相同。

解法：

递归，先看本节点取值是否相同，再看左子树和右子树。

Recover Binary Search Tree

题目：

一个BST，其中有两个节点的值被互换了，请恢复这个BST。

解法：

中序遍历BST，记录pre，如果pre->val > cur->val，说明有被互换，记录下这个pre和cur。如果又遇到了pre->val > cur->val的情况，更新后面那个cur，说明第二个被换的节点在这。如果没遇到，说明前面那对pre和cur就是被互换的节点。找到这两个节点后，直接把值换回来即可。

Validate Binary Search Tree

题目：

验证是否为合格的BST。

解法：

中序遍历，检查pre->val < cur->val，看是否有序。或者，直接递归判断，要求每个节点都在父节点的限定的数值范围内（但这种方法无法处理INT_MIN INT_MAX的情况）。

Interleaving String

题目：

判断字符串s是否能由两子串t1、t2交叉组成。

解法：

dp，设置一个二维数组，array[i][j]表示是否能由ti[0....i] t2[0....j]组成。回溯法也能做，但重复计算过多，效率低，会超时。

Unique Binary Search Trees
II

题目：

给定数字n，返回所有从1.......n可以组成多少BST

解法：

递归解决。每次取一个节点做根，左子树m种和右子树n种都递归生成，然后合并成m*n种。

Unique Binary Search Trees

题目要求：

给定数字n，求1.....n可以组成多少组不同的BST。

解法：

Dp，申请一个数组，每个i，可以由j , 1  i-j-1组成。于是vec[i] = vec[j] * vec[i-j-1]  j从0.....i-1

Binary Tree Inorder Traversal

题目要求：

二叉树非递归中序遍历。

解法：

用栈，先走到最左边，然后出栈，访问，然后再看是否有右子树，有的话，走到右子树的最左边，走的时候入栈。没有的话，继续出栈，访问。

Restore IP Addresses

题目要求：

给一串字符数字，要求返回所有可能的ip地址组合。

解法：

回溯法，每次选取一部分ip string，然后剩下的继续选取，直到所有的字符串都被划分完毕。如果步长为4，且所有的字符均被选取完，则保存起来。

Reverse Linked List II

题目要求：

从n到m的节点，逆序。

解法：

保存n节点前一个节点，然后开始逆转，直到逆转到m+1节点时终止，这时把逆序链表头部和尾部全部连接好。注意bound case

Subsets II

题目：

给定一个数组，可能有重复数字，要求返回所有子集，子集与子集不能重复，子集内部允许有重复数字，子集内部有序排列。

解法：

典型的回溯问题。背包问题。先排序，每次选取一个，或者不选。如果遇到重复，直接选取重复值从0.....dup_num

Decode Ways

题目要求：

A->1 B->2 ..... Z->26,给定一个字符串数字，判断可以组合出多少种组合。

解法：

dp问题，申请一个数组，或者不用数组也行，只需保留前两个组合数目。array[i]表示从0到i可以组成的组合数目。

array[i] = array[i - 1] (if s[i] is valid) + array[i - 2] (if s[i-1, i] is valid) 

字符串长度小于3时，需要单独计算。

Gray Code

题目：

格雷码，（一种编码方法，定义自行百度），给定数字n，求n位格雷码可以表示的数字，按十进制输出。

解法：

格雷码要求相邻的两码，只有一个比特位不同。

可以用栈的方式来做。当n == 1，插入0，1。  当n == 2，从栈尾向栈头获取元素，元素高位前加1，然后入栈。比如n==i 时，入栈元素为 stk.back() | 1 << i。依此类推。

Merge Sorted Array

题目：

将有序数组B合并到有序数组A中。

解法：

既然A数组空间够大，那就申请两指针，分别指向A和B有序数组的尾部，从后向前。胜出的就保存在A数组的最尾部。

Scramble String

题目：

google当年的面试题。一个字符串可由树构成，交换左右节点，可形成新的字符串。这两个字符串互为scramble string。

现在给定两字符串，判断是否为scrambled string。

解法：

DP，三维数组，第一维表示长度，第二维、第三维表示从str1的i，str2的j开始。 array[k][i][j]表示：str1从i开始，str2从j开始，长度为k的字符串是否互为scrambled string。

Partition List

题目：

给定一个数字target，将单链表重整为，所有大于数字target的均排在所有小于数字target的节点之后。

解法：

申请两dummy节点，一个用来挂大于数字target的节点，一个用来挂小于数字target的节点。遍历一边后，将链表分成了大小两个，然后将两个串一起。

Maximal Rectangle

题目：

给定一个矩阵，里面有0，有1.求出所有都是1的最大子矩阵的面积area。

解法：

DP。申请一个vector，长度就是二维矩阵的长，vector记录着以当前行结尾连续1的高。从0行到n-1行，循环更新这个vector，如果遇到0，则vector[i]=0；否则vector[i]++。

比如：某个vector可能为｛1，2，3，1，0，0，2，1，3｝

每次循环中，单独计算最大矩阵，这时求最大矩阵面积的问题就变成了求最大直方图的矩阵面积了。也就是下面这个题目的解法。

Largest Rectangle in Histogram

题目：

给定一个vector，里面存着整数，表示直方图的长，求最大的矩阵面积。

解法：

用栈。

Remove Duplicates
from Sorted List II

题目要求：

删除有序单链表中重复的节点。有重复的就全部删掉。

解法：

逐一遍历单链表，如果下一节点为空或不等于下一节点，则过，如果不是，则一直找到结尾或者不等于该节点的节点，直接跳过。

重复节点可能从头结点就有，为了操作方便，可以虚构一个dummy节点。

Remove Duplicates from
Sorted List

题目：

删除有序单链表中重复的节点，有重复的只保留一个。

解法：

逐一扫描单链表。和下一个节点做比较，如果相同，则跳过。为了操作方便，也可以虚构一个dummy节点。

Search in Rotated Sorted
Array II

题目：

旋转有序数组，允许重复，查找某数字是否存在。

解法：

变种二分查找。分情况：

1、如果 A[begin] < target < A[middle],说明target在左半边。

2、如果A[middle] < target < A[end],说明target在右半边。

3、其他情况均无法判断在左半边还是在右半边，所以直接判断A[begin] == target ,是则返回，否则begin++

Remove Duplicates
from Sorted Array II

题目：

删除有序数组中的重复元素，同一重复的元素最多只保留两个。

解法：

一个写地址指针（从第三个元素开始），一个读指针，每次判断是否同时和写指针之前的两个数相同，如果相同，直接跳过，如果不同，则写入。

Word Search

题目：

给一个二维字符矩阵，判断给定的字符串是否可以由该矩阵生成。

解法：

回溯法，从二维矩阵的每一个字符都找一遍。同时设置used_flag保证已在路径中的节点不被重复访问。

方便上下左右移动，可以的定义数组move[4][2] =  {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

Subsets

题目：

给定一个数组，没有重复数字。返回所有的子集。要求子集有序、子集间不重复。

解法：

回溯法。背包问题，每次选一个数字或者不选，同时step+1，直到step == s.size()则保存结果并返回。

Combinations

题目：

给定n，k，返回包含k个数字的1.....n的子集。

解法：

同上背包问题。每次选或者不选，同时step +1，只不过退出条件变成了 combine.size() == k

Minimum Window Substring

题目：

给定字符串S，目标串T，找到在S中最短的字符串，使得刚好所有T的元素都至少出现了在T中出现的次数。

解法：

用一个hash_map保存T中的元素和次数。

设立两个指针，一头一尾表示选中的子串。用临时hash_map保留子串元素和次数，如果不达T的标准，则右指针向右，如果达标，则左指针向右，直到不达标。

依次类推，每次记录达标的子串和长度。

Sort Colors

题目：

经典荷兰旗问题，数组中存在三种元素0，1，2.排列该数组，顺序为0<1<2。要求时间复杂度为O（n）。

解法：

三指针方法。左指针指向数组头，表示0的位置；右指针指向数组尾，表示2的位置。

另一个指针（中指针）开始i遍历数组。发现1，则不管。发现0，则和左指针的元素互换，左指针右移一位。发现2，则和右指针的元素互换，右指针左移一位。直到中指针元素为1，中指针右移。

循环下去，直到中指针和右指针相遇。

Search a 2D Matrix

题目：

二维数组，每行内部有序，行与行之间有序，下一行的所有值大于上一行。

解法：

先找到所在行，二分。再找到所在列，二分。注意bound case，想做到bug-free，最好先用case自测。

Set Matrix Zeroes

题目：

有一个二维数组，如果某个节点为0，则把节点所在行和所在列所有元素设为0. 要求原地。

解法：

用一个数组记录所有要设置为0的行，再用一个数组记录所有要设置为0的列。

还有一种办法，用两个flag，一个flag记录第0行是否全为0，一个flag记录第0列是需要全为0.这种空间复杂度是常数。

遍历整个矩阵，如果该行为0，只要把matrix[i][0] = 0， 如果需要把该列设置为0，只要把matrix[0][j] = 0. 再遍历一遍，把行列该设置为0的设置为0.最后根据两个flag将0行、0列根据需要设为0

Edit Distance

题目：

求两个string的编辑距离。

解法：

经典DP问题。distance[i][j] = min{   distance[i -1][j] + 1,    distance[i][j-1] + 1,     distance[i-1][j-1]  + str1[i] == str2[j] ? 0 : 1  }

Simplify Path

题目：

简化文件路径。

解法：

用栈，先将路径按/切分，遇到.时不作为，遇到..时出战，遇到字符时入栈。最后根据栈内结果返回。

Climbing Stairs

题目：梯子一次可以爬一层，一次可以跑两层。求问n层梯子有多少种爬法。

解法：爬到当前层可以有的爬法=前一层的爬法+前两层的爬法。

非递归的办法是，保存pre，prepre，循环累加。

Sqrt(x)

题目：

求整数的X的平方根，要求返回int。

解法：

二分法。有时会超时，也可以用牛顿法。

Text Justification

题目：

给定一个单词序列，要求单词每行长度固定，不允许单词跨行，词与词之间用空格填充。

解法：

逐一统计长度，超过长度时填充。

Plus One

题目：

给定一组数字，加1后，返回。

解法：

数字进位。

Valid Number

题目：

Add Binary

题目：

两个二进制相加。

解法：

注意进位。

Merge Two Sorted Lists

题目：

合并两有序单链表。

解法：

双指针

Minimum Path Sum

题目：

m*n矩阵，求从左上角到右下角的最短路径长度。

解法：

dp，定义一个数组，用来统计从左上角到该格子的最短路径长度。

matrix[i][j] = min{matrix[i - 1][j],  matrix[i][j - 1]}  + array[i][j]

Unique Paths II

题目：

在01的格子里面，求出所有从左上角到右下角的路径数目。

解法：

dp，遇到1则表示有阻碍

Unique Paths

题目：

在格子里面，求出所有从左上角到右下角的路径数目。

解法：

dp，定义数组，逐步求和。

Rotate List

Permutation Sequence

Spiral Matrix II

Length of Last Word

Insert Interval

Merge Intervals

Jump Game

Spiral Matrix

Maximum Subarray

N-Queens II

N-Queens

Pow(x, n)

Anagrams

Rotate Image

Permutations II

Permutations

Jump Game II

Wildcard Matching

Multiply Strings

Trapping Rain Water

First Missing Positive

Combination Sum II

Combination Sum

Count and Say

Sudoku Solver

Valid Sudoku

Search Insert Position

Search for a Range

Search in Rotated Sorted
Array