给定一个整数数组 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
给定一个数组,将数组中的元素向右移动 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) 的 原地 算法。
解法:
注意:
第三种解法:
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]
说明:
必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。
解法:
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
打乱一个没有重复元素的数组。
示例:
// 以数字集合 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
给定两个数组,编写一个函数来计算它们的交集。
示例 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 的元素存储在磁盘上,磁盘内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?
解法:
解法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
给定长度为 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)-1, -1, -1):
left[i] *= right
right *= nums[i]
return left
给定一个整数类型的数组 nums,请编写一个能够返回数组“中心索引”的方法。
我们是这样定义数组中心索引的:数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
如果数组不存在中心索引,那么我们应该返回 -1。如果数组有多个中心索引,那么我们应该返回最靠近左边的那一个。
示例 1:
输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11),与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。
示例 2:
输入:
nums = [1, 2, 3]
输出: -1
解释:
数组中不存在满足此条件的中心索引。
说明:
nums 的长度范围为 [0, 10000]。
任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。
解法一:
class Solution(object):
def pivotIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums:
return -1
for i in range(len(nums)):
left = sum(nums[:i])
right = sum(nums[i+1:])
if left == right:
return i
return -1
解法二:
class Solution:
def pivotIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
res = sum(nums)
lsum = 0
for i, j in enumerate(nums):
if lsum * 2 + j == res:
return i
lsum += j
return -1
解法三:
class Solution:
def pivotIndex(self, nums: List[int]) -> int:
a=sum(nums[:0])
b=sum(nums[1:])
for i in range(0,len(nums)-1):
if a==b:
return i
a+=nums[i]
b-=nums[i+1]
if a==b:
return len(nums)-1
return -1
在一个给定的数组nums中,总是存在一个最大元素 。
查找数组中的最大元素是否至少是数组中每个其他数字的两倍。
如果是,则返回最大元素的索引,否则返回-1。
示例 1:
输入: nums = [3, 6, 1, 0]
输出: 1
解释: 6是最大的整数, 对于数组中的其他整数,
6大于数组中其他元素的两倍。6的索引是1, 所以我们返回1.
示例 2:
输入: nums = [1, 2, 3, 4]
输出: -1
解释: 4没有超过3的两倍大, 所以我们返回 -1.
提示:
nums 的长度范围在[1, 50].
每个 nums[i] 的整数范围在 [0, 100].
解法
就是求数组中的最大数和第二大数即可,注意第二大数的求法
class Solution(object):
def dominantIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
m1, m2 = 0, 0
res = 0
for i, x in enumerate(nums):
if x > m1:
m2 = m1
m1 = x
res = i
elif x > m2:
m2 = x
if m1 >= m2 * 2:
return res
return -1
给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一。
最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外,这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
解法
主要是对最后面是9的判断
class Solution(object):
def plusOne(self, digits):
"""
:type digits: List[int]
:rtype: List[int]
"""
if digits[-1] != 9:
digits[-1] += 1
return digits
idx = len(digits) - 1
while idx >= 0 and digits[idx] == 9:
digits[idx] = 0
idx -= 1
if idx == -1:
digits.insert(0, 1)
else:
digits[idx] += 1
return digits
给定一个含有 M x N 个元素的矩阵(M 行,N 列),请以对角线遍历的顺序返回这个矩阵中的所有元素,对角线遍历如下图所示。
示例:
输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,4,7,5,3,6,8,9]
解法
参考:https://leetcode-cn.com/problems/diagonal-traverse/solution/dui-jiao-xian-bian-li-by-leetcode/
初始化数组 result,用于存储最后结果。
使用一个外层循环遍历所有的对角线。第一行和最后一列的元素都是对角线的起点。
使用一个内层 while 循环遍历对角线上的所有元素。可以计算指定对角线上的元素数量,也可以简单迭代直到索引超出范围。
因为不知道每条对角线上的元素数量,需要为每条对角线分配一个列表或动态数组。但是同样也可以通过计算得到当前对角线上的元素数量。
对于奇数编号的对角线,只需要将迭代结果翻转再加入结果数组即可。
class Solution(object):
def findDiagonalOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
if not matrix or not matrix[0]:
return []
n, m = len(matrix), len(matrix[0])
res = []
for i in range(m + n + 1):
tmp = []
r, c = 0 if i < m else i - m + 1, i if i < m else m - 1
while r < n and c > -1:
tmp.append(matrix[r][c])
r += 1
c -= 1
if i % 2 == 0:
res.extend(tmp[::-1])
else:
res.extend(tmp)
return res
一个2*N长度数组,其中N个奇数,N个偶数,要求实现1个函数,把奇数放置到奇数下标,偶数放置到偶数下标
要求:1. 不能额外开辟一个内存/数组;2. 数组只能遍历1次
解法
就是可以看成是两个数组,一个奇数数组,一个偶数数组,所以也就是两个指针,都从左往右遍历,找到有问题的就交换。
def try(nums):
i, j = 0, 1
n = len(nums)
while i < n and j < n:
while nums[i] % 2 == 0 and i < n:
i += 2
while nums[j] % 2 == 1 and j < n:
j += 2
nums[i], nums[j] = nums[j], nums[i]
return nums