乘积最大子序列
给定一个整数数组 nums ,找出一个序列中乘积最大的连续子序列(该序列至少包含一个数)。
示例 1:
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:
输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
解法:
第一时间想到的是动态规划,想找当前位置上的乘积最大值,但是发现正负号的问题,即前一个位置上乘积最小值乘以当前位置上的数,可能会变成乘积最大值。
也就是两个dp数组,简化一下存储空间的话,就是两个值:前一个位置上的乘积最大值和乘积最小值。
每有一个新的数字加入,最大值要么是当前最大值*新数,要么是当前最小值(负数)*新数(负数),要么是新值。
class Solution(object):
def maxProduct(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
cur_min = cur_max = res = nums[0]
for i in range(1, len(nums)):
tmp_max = max(max(cur_min * nums[i], cur_max * nums[i]), nums[i])
tmp_min = min(min(cur_min * nums[i], cur_max * nums[i]), nums[i])
cur_min = tmp_min
cur_max = tmp_max
if cur_max > res:
res = cur_max
return res
魔术索引
魔术索引。 在数组A[0…n-1]中,有所谓的魔术索引,满足条件A[i] = i。给定一个有序整数数组,编写一种方法找出魔术索引,若有的话,在数组A中找出一个魔术索引,如果没有,则返回-1。若有多个魔术索引,返回索引值最小的一个。
示例1:
输入:nums = [0, 2, 3, 4, 5]
输出:0
说明: 0下标的元素为0
示例2:
输入:nums = [1, 1, 1]
输出:1
说明:
nums长度在[1, 1000000]之间
此题为原书中的 Follow-up,即数组中可能包含重复元素的版本
解法
- 暴力法:从左到右依次遍历即可,O(N)
- 如果没有重复元素的话,可以直接按照二分法
- 跳跃法:如果当前值大于i的话,就可以从当前位置继续遍历
class Solution(object):
def findMagicIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums:
return -1
i = 0
while i < len(nums):
if nums[i] > i:
i = nums[i]
elif nums[i] == i:
return i
else:
i += 1
return -1
旋转数组
给定一个数组,将数组中的元素向右移动 k 个位置,其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案,至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。
解法:
- 每次将整个数组向右移动一步,移动k次即可
- 运用python数组自带的切片方法,非常简单:nums[:]=nums[length-k:] + nums[:length-k]
- 经过3次子数组的 “对称翻折”:如 [1,2,3,4,5,6,7] 和 k = 3,第一步[1,2,3,4]->[4,3,2,1],第二步[5,6,7]->[7,6,5],最后[4,3,2,1,7,6,5]->[5,6,7,1,2,3,4]。
- 从第一个元素开始进行旋转,逐个将旋转位置上的元素移到下一个位置,直到旋转到该元素的初始位置。同时使用一个变量记录被旋转的元素数量,显然完成所有旋转后旋转元素数量应该是数组长度。(比较麻烦)
注意:
- k要对len求一下余
- 不知道为什么不能直接nums = list(reversed(nums)),可能是编辑器设置的问题,不过可以通过加上":"实现相同的功能
第三种解法:
class Solution(object):
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: None Do not return anything, modify nums in-place instead.
"""
k = k % len(nums)
pos = len(nums) - k
nums[:pos] = list(reversed(nums[:pos]))
nums[pos:] = list(reversed(nums[pos:]))
nums[:] = list(reversed(nums[:]))
第四种解法:
class Solution:
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: void Do not return anything, modify nums in-place instead.
"""
if len(nums)>1:
length = len(nums)
k = k%length
if k>0:
move_num = 0
move_pos = 0
move_value = nums[move_pos]
while move_num<length:
next_pos = (move_pos+k)%length
while next_pos!=move_pos:
save_value = nums[next_pos]
nums[next_pos] = move_value
move_value = save_value
next_pos=(next_pos+k)%length
move_num+=1
nums[move_pos]=move_value
move_num+=1
move_pos+=1
move_value = nums[move_pos]
移动零
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。
解法:
- 自己想的一个,用index(0)判断最左边的0的位置是否已经是最后了,如果不是,就把0后面的所有内容往前移一个位置。总的看来,就是冒泡排序的加强版
- 其实可以不需要管中间移动的过程,只关注最终的结果即可。只要把数组中所有的非零元素,按顺序给数组的前段元素位赋值,剩下的全部直接赋值0就可以。
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
if 0 not in nums:
return nums
right = len(nums)
while nums.index(0) != right:
pos = nums.index(0)
nums[pos:right-1] = nums[pos+1:right]
nums[right-1] = 0
right -= 1
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
i, j = 0, 0
while j < len(nums):
if nums[j] != 0:
nums[i] = nums[j]
i += 1
j += 1
while i < len(nums):
nums[i] = 0
i += 1
return nums
移除元素
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。
解法
同上
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
i, j = 0, 0
while j < len(nums):
if nums[j] != val:
nums[i] = nums[j]
i += 1
j += 1
return i
删除排序数组中的重复项
给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
解法
上面题目的变形,同样还是用两个指针,i和j来操作,只不过这个时候不是判断j位置是否是val了,而是判断是否和i前面的数相等。
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
i, j = 0, 0
while j < len(nums):
if j == 0 or nums[j] != nums[i - 1]:
nums[i] = nums[j]
i += 1
j += 1
return i
删除排序数组中的重复项 II
给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素最多出现两次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定 nums = [1,1,1,2,2,3],
函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
你不需要考虑数组中超出新长度后面的元素。
解法
同上,只需要稍作修改,和i-2的位置比较就可以了。因为它是排序的
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
i, j = 0, 0
while j < len(nums):
if j == 0 or j == 1 or nums[j] != nums[i - 2]:
nums[i] = nums[j]
i += 1
j += 1
return i
打乱数组
打乱一个没有重复元素的数组。
示例:
// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);
// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();
// 重设数组到它的初始状态[1,2,3]。
solution.reset();
// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();
解法:
注意这里的随机要用洗牌方法:在每次迭代中,生成一个范围在当前下标到数组末尾元素下标之间的随机整数。接下来,将当前元素和随机选出的下标所指的元素互相交换。注意,当前元素是可以和它本身互相交换的 - 否则生成最后的排列组合的概率就不对了。
注意randint(min, max)的用法,min和max的值都可能被取到的。
init的时候保存两个,否则shuffle后就变化了原始数组
不明白: self.ori必须在self.arr前面定义,而且必须是nums[:],是内部存储的一些问题么?如果定义的是self.ori = nums,修改arr的时候会把nums修改,进而把ori修改了。
import random
class Solution(object):
def __init__(self, nums):
"""
:type nums: List[int]
"""
self.ori = nums[:]
self.arr = nums
def reset(self):
"""
Resets the array to its original configuration and return it.
:rtype: List[int]
"""
return self.ori
def shuffle(self):
"""
Returns a random shuffling of the array.
:rtype: List[int]
"""
for i in range(len(self.arr)):
j = random.randint(i, len(self.arr)-1)
self.arr[i], self.arr[j] = self.arr[j], self.arr[i]
return self.arr
# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()
递增的三元子序列
给定一个未排序的数组,判断这个数组中是否存在长度为 3 的递增子序列。
数学表达式如下:
如果存在这样的 i, j, k, 且满足 0 ≤ i < j < k ≤ n-1,
使得 arr[i] < arr[j] < arr[k] ,返回 true ; 否则返回 false 。
说明: 要求算法的时间复杂度为 O(n),空间复杂度为 O(1) 。
示例 1:
输入: [1,2,3,4,5]
输出: true
示例 2:
输入: [5,4,3,2,1]
输出: false
解法:
注意是递增的子序列,并没有说是“连续”子序列,但是还是走动态规划的思路,保存两个指针,一个min,一个medium;
一种方式是把min和medium初始化为最大值:float(“inf”)
另一种是设置一个flag标记下medium是否已经被初始化了。
因此遍历一遍数组,随时更新min和Medium的值,一旦遍历到比medium还大的数,直接返回ture
class Solution(object):
def increasingTriplet(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
if not nums:
return False
mi = nums[0]
flag = 0
for i in range(1, len(nums)):
tmp = nums[i]
if tmp < mi:
mi = tmp
elif tmp > mi and (flag == 0 or tmp < me):
me = tmp
flag = 1
elif flag == 1 and tmp > me:
return True
return False
两个数组的交集 II
给定两个数组,编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明:
输出结果中每个元素出现的次数,应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢?你将如何优化你的算法?
如果 nums1 的大小比 nums2 小很多,哪种方法更优?
如果 nums2 的元素存储在磁盘上,磁盘内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?
解法:
- 最简单的方法就是遍历两个数组,遇到相同的就记录下来,并删除掉该元素,避免重复。
- 先给两个数组排序,使用归并排序的思路。遇到两个数组的情况,如果要加速处理,就要想到可以设置两个指针。
- 用dict存储元素
解法1:
class Solution(object):
def intersect(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
res = []
for idx, x in enumerate(nums1):
if x in nums2:
res.append(x)
nums2.remove(x)
return res
解法2:
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
res = []
nums1 = sorted(nums1)
nums2 = sorted(nums2)
i = 0
j = 0
while i < len(nums1) and j < len(nums2):
if nums1[i] > nums2[j]:
j += 1
elif nums1[i] < nums2[j]:
i += 1
else:
res.append(nums1[i])
i += 1
j += 1
return res
解法3:
class Solution:
def intersect(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
m = len(nums1)
n = len(nums2)
if m == 0 or n == 0:
return []
dicts = {
}
for i in nums1:
if i in dicts:
dicts[i] += 1
else:
dicts[i] = 1
ret = []
for j in nums2:
if j in dicts and dicts[j] > 0:
ret.append(j)
dicts[j] -= 1
return ret
除自身以外数组的乘积
给定长度为 n 的整数数组 nums,其中 n > 1,返回输出数组 output ,其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:
输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法,且在 O(n) 时间复杂度内完成此题。
进阶:
你可以在常数空间复杂度内完成这个题目吗?( 出于对空间复杂度分析的目的,输出数组不被视为额外空间。)
解法:
最简单的思路就是用除法或者O(n^2)的遍历,但是都被禁止了
其实想到用两个指针了,但是没想到用两个数组
因为是乘法,满足交换律,所以可以在第一遍遍历的时候把nums[i]左边部分的乘积存下来,第二遍的时候把右边的存下来,最后对应相乘就可以。(注意O(kn)=O(n))
但是要在常熟空间复杂度的话,就只能保留一个数组,可以选择保留左边数组,右边的用一个数值代替就可以了,因为每次用完就不用了。
遍历nums,在遍历的过程中将对应元素累乘,例如
1 2 3 4
1 1 2 6
这样我们就得到了对应元素左边所有元素的乘积。然后我们反向遍历nums,做相同操作即可。
1 2 3 4
24 12 4 1
再将两个结果相乘即可。
1 2 3 4
24 12 8 6
Code
class Solution(object):
def productExceptSelf(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
left = [1] * len(nums)
right = 1
for i in range(1, len(nums)):
left[i] = left[i-1] * nums[i-1]
for i in range(len(nums