我们为什么要局限于某些条件?
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 res
0086题 分隔链表【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 False
0088题 合并两个有序数组【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