我们为什么要局限于某些条件？
0085题 最大矩形【Maximal Rectangle】
题目：
给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
示例：
输入:
[
["1","0","1","0","0"],
["1","0","1","1","1"],
["1","1","1","1","1"],
["1","0","0","1","0"]
]
输出: 6题目相对严谨
除Robust外无需注意太多
解题思路：
这题如果没有上下题的联系，单独来看，一点思路都没有，暴力搜索肯定是没有办法破解的。
结合上一道题的思路，这题进行一些预处理，应该就能够好一些，简单来说就是每层进行建楼操作，然后建完楼之后每一行就是0084题中的diagram参数，然后求最大矩形，然后再返回跟其他建出来的矩形进行比较，注意robust，post代码
class Solution:
def largestRectangleArea(self, heights):
n = len(heights)
if n == 0: return 0
left = [0]*n
right = [0]*n
left[0] = 0
for i in range(1,n):
left[i] = i
j = i
while left[j] - 1 >=0 and heights[left[j]-1] >= heights[i]:
j = left[j] - 1
left[i] = left[j]
right[n-1] = n-1
for i in range(n-2,-1,-1):
right[i] = i
j = i
while right[j] + 1 <= n-1 and heights[right[j] + 1] >= heights[i]:
j = right[j] + 1
right[i] = right[j]
res = -1
for i in range(n):
res = max(res, heights[i]*(right[i]-left[i]+1))
return res
def maximalRectangle(self, matrix):
n = len(matrix)
if n == 0: return 0
m = len(matrix[0])
if m == 0: return 0
for i in range(m): matrix[0][i] = int(matrix[0][i])
for i in range(1,n):
for j in range(m):
matrix[i][j] = int(matrix[i][j])
if matrix[i-1][j] != 0 and matrix[i][j] != 0:
matrix[i][j] = matrix[i-1][j] + 1
res = -1
for i in range(n):
res = max(res, self.largestRectangleArea(matrix[i]))
return res0086题 分隔链表【Partition List】
题目：
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。
你应当保留两个分区中每个节点的初始相对位置。
示例：
输入: head = 1->4->3->2->5->2, x = 3
输出: 1->2->2->4->3->5题目相对严谨
又是链表题，小心一点
解题思路：
哦，简单来讲就是在链表的基础上完成快速排序的过程，应该不算什么难事儿，老方法，建两个list，一个存放小于的，一个存放的大于等于的即可。（话说貌似是作业原题来着……emmm）
post代码
class Solution:
def partition(self, head, x):
if head == None: return head
smallList = None
bigList = None
while head != None:
if head.val < x:
if smallList == None:
smallList = ListNode(head.val)
tmpSmallBigin = smallList
else:
smallList.next = ListNode(head.val)
smallList = smallList.next
else:
if bigList == None:
bigList = ListNode(head.val)
tmpBigBigin = bigList
else:
bigList.next = ListNode(head.val)
bigList = bigList.next
head = head.next
if smallList != None:
if bigList != None:
smallList.next = tmpBigBigin
res = tmpSmallBigin
else:
res = tmpBigBigin
return res 其实如果可以新建一个新链表的话，我愿意那么做，不太喜欢在原链表上改来改去，尤其是使用python的时候，不知道什么时候就给你copy（安排）了。
0087题 扰乱字符串【】
题目：
给定一个字符串 s1，我们可以把它递归地分割成两个非空子字符串，从而将其表示为二叉树。
下图是字符串 s1 = "great" 的一种可能的表示形式。
great
/ \
gr eat
/ \ / \
g r e at
/ \
a t在扰乱这个字符串的过程中，我们可以挑选任何一个非叶节点，然后交换它的两个子节点。
例如，如果我们挑选非叶节点 "gr" ，交换它的两个子节点，将会产生扰乱字符串 "rgeat"。
rgeat
/ \
rg eat
/ \ / \
r g e at
/ \
a t我们将 "rgeat” 称作 "great" 的一个扰乱字符串。
同样地，如果我们继续将其节点 "eat" 和 "at" 进行交换，将会产生另一个新的扰乱字符串 "rgtae" 。
rgtae
/ \
rg tae
/ \ / \
r g ta e
/ \
t a我们将 "rgtae” 称作 "great" 的一个扰乱字符串。
给出两个长度相等的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。
示例：
输入: s1 = "great", s2 = "rgeat"
输出: true
输入: s1 = "abcde", s2 = "caebd"
输出: false题目相对严谨
除Robust外无需注意太多
解题思路：
这题就是怎么说的怎么来，既然你是树，那必然就要分解。
class Solution:
def isScramble(self, s1, s2):
if s1 == s2: return True
if sorted(s1) != sorted(s2): return False
for i in range(1,len(s1)):
res = self.isScramble(s1[0:i],s2[0:i]) and self.isScramble(s1[i:],s2[i:])
res = res or (self.isScramble(s1[0:i], s2[len(s2)-i:]) and self.isScramble(s1[i:],s2[0:len(s2)-i]))
if res: return True
return False0088题 合并两个有序数组【Merge Sorted Array】
题目：
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:
- 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
- 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例：
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]题目相对严谨
除Robust外无需注意太多
解题思路：
就是完成归并排序中的归并操作，简单易懂，直接post代码
class Solution:
def merge(self, nums1, m, nums2, n):
k = m+n-1
i = m-1
j = n-1
while i>=0 and j>=0:
if nums1[i] >= nums2[j]:
nums1[k] = nums1[i]
k-=1; i-=1
else:
nums1[k] = nums2[j]
k-=1; j-=1
while j>=0:
nums1[k] = nums2[j]
k-=1; j-=1
return