同源策略 ≠ 万能盾牌：为什么你的后端仍需防范“盲打“攻击？

LeetCode

除自身以外数组的乘积 - 完整解法详解

问题理解问题描述给你一个整数数组nums返回数组answer其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。

要求不使用除法在O(n)时间复杂度内完成并且不能使用额外的数组空间输出数组不被视为额外空间。

示例text输入: nums [1,2,3,4] 输出: [24,12,8,6] 解释: 对于索引0乘积 2×3×4 24 对于索引1乘积 1×3×4 12 对于索引2乘积 1×2×4 8 对于索引3乘积 1×2×3 6 输入: nums [-1,1,0,-3,3] 输出: [0,0,9,0,0] 解释: 注意处理0的情况要求不使用除法时间复杂度O(n)空间复杂度O(

输出数组不计入空间复杂度

核心思路前缀积与后缀积基本思想对于数组中的每个位置i我们需要计算除nums[i]外所有元素的乘积。

这可以分解为两个部分前缀积nums[0] × nums[1] × ... × nums[i-1]后缀积nums[i1] × nums[i2] × ... × nums[n-1]那么answer[i] 前缀积 × 后缀积优化方法为了避免重复计算我们可以从左到右计算前缀积并存储从右到左计算后缀积并与前缀积相乘

代码逐行解析方法一使用两个数组空间复杂度 O(n)Java 解法javaclass Solution { public int[] productExceptSelf(int[] nums) { int n nums.length; //

计算前缀积 // pre[i] 表示 nums[0] × nums[1] × ... × nums[i-1] 的乘积 int[] pre new int[n]; pre[0] 1; for (int i 1; i n; i) { pre[i] pre[i-1] * nums[i-1]; } //

计算后缀积 // suf[i] 表示 nums[i1] × nums[i2] × ... × nums[n-1] 的乘积 int[] suf new int[n]; suf[n-1] 1; for (int i n-2; i 0; i--) { suf[i] suf[i1] * nums[i1]; } //

计算最终结果前缀积 × 后缀积 int[] answer new int[n]; for (int i 0; i n; i) { answer[i] pre[i] * suf[i]; } return answer; } }Python 解法pythonfrom typing import List class Solution: def productExceptSelf(self, nums: List[int]) - List[int]: n len(nums) #

计算前缀积 # pre[i] 表示 nums[0] × nums[1] × ... × nums[i-1] 的乘积 pre [1] * n for i in range(1, n): pre[i] pre[i-1] * nums[i-1] #

计算后缀积 # suf[i] 表示 nums[i1] × nums[i2] × ... × nums[n-1] 的乘积 suf [1] * n for i in range(n-2, -1, -

: suf[i] suf[i1] * nums[i1] #

计算最终结果前缀积 × 后缀积 answer [0] * n for i in range(n): answer[i] pre[i] * suf[i] return answer方法二优化空间复杂度O(

额外空间Java 解法javaclass Solution { public int[] productExceptSelf(int[] nums) { int n nums.length; int[] answer new int[n]; //

先计算前缀积直接存储在 answer 中 // 此时 answer[i] nums[0] × nums[1] × ... × nums[i-1] answer[0] 1; for (int i 1; i n; i) { answer[i] answer[i-1] * nums[i-1]; } //

计算后缀积并乘到 answer 中 // 用一个变量 suffix 记录当前的后缀积 int suffix 1; for (int i n-1; i 0; i--) { // 将后缀积乘到当前结果上 answer[i] * suffix; // 更新后缀积包含当前元素为下一轮计算做准备 suffix * nums[i]; } return answer; } }Python 解法pythonfrom typing import List class Solution: def productExceptSelf(self, nums: List[int]) - List[int]: n len(nums) answer [1] * n #

先计算前缀积直接存储在 answer 中 # 此时 answer[i] nums[0] × nums[1] × ... × nums[i-1] for i in range(1, n): answer[i] answer[i-1] * nums[i-1] #

计算后缀积并乘到 answer 中 # 用一个变量 suffix 记录当前的后缀积 suffix 1 for i in range(n-1, -1, -

: # 将后缀积乘到当前结果上 answer[i] * suffix # 更新后缀积包含当前元素为下一轮计算做准备 suffix * nums[i] return answer

Java 与 Python 语法对比

数组/列表操作操作JavaPython创建数组/列表int[] arr new int[n];arr [0] * n数组/列表长度arr.lengthlen(arr)遍历数组for (int i0; in; i)for i in range(n):逆序遍历for (int in-1; i0; i--)for i in range(n-1, -1, -

:

变量初始化操作JavaPython初始化数组int[] arr new int[n];arr [0] * n初始化列表ListInteger list new ArrayList();list []

数学运算操作JavaPython乘法a * ba * b赋值a ba b自乘赋值a * ba * b

实例演示以nums [1, 2, 3, 4]为例演示两种方法的过程方法一两个数组Java/Python 步骤1计算前缀积textpre[0] 1 pre[1] pre[0] × nums[0] 1 × 1 1 pre[2] pre[1] × nums[1] 1 × 2 2 pre[3] pre[2] × nums[2] 2 × 3 6 pre [1, 1, 2, 6]Java/Python 步骤2计算后缀积textsuf[3] 1 suf[2] suf[3] × nums[3] 1 × 4 4 suf[1] suf[2] × nums[2] 4 × 3 12 suf[0] suf[1] × nums[1] 12 × 2 24 suf [24, 12, 4, 1]Java/Python 步骤3计算最终结果textanswer[0] pre[0] × suf[0] 1 × 24 24 answer[1] pre[1] × suf[1] 1 × 12 12 answer[2] pre[2] × suf[2] 2 × 4 8 answer[3] pre[3] × suf[3] 6 × 1 6 answer [24, 12, 8, 6]方法二优化空间Java/Python 步骤1计算前缀积到 answer 中textanswer[0] 1 answer[1] answer[0] × nums[0] 1 × 1 1 answer[2] answer[1] × nums[1] 1 × 2 2 answer[3] answer[2] × nums[2] 2 × 3 6 answer [1, 1, 2, 6] # 此时 answer[i] 前缀积Java/Python 步骤2计算后缀积并乘到 answer 中text初始化 suffix 1 i3: answer[3] * suffix → 6 × 1 6 suffix * nums[3] → 1 × 4 4 i2: answer[2] * suffix → 2 × 4 8 suffix * nums[2] → 4 × 3 12 i1: answer[1] * suffix → 1 × 12 12 suffix * nums[1] → 12 × 2 24 i0: answer[0] * suffix → 1 × 24 24 suffix * nums[0] → 24 × 1 24 最终 answer [24, 12, 8, 6]

关键细节解析

为什么前缀积数组的初始值都是 1对于第一个元素它没有前缀元素所以前缀积应该是 1乘法单位元对于其他元素前缀积初始为 1然后逐步乘以前面的元素

如何处理数组边界前缀积从第二个元素开始计算避免数组越界后缀积从倒数第二个元素开始向前计算避免数组越界

为什么优化版本的空间复杂度是 O(

只使用了输出数组answer和一个变量suffix输出数组不计入空间复杂度分析因此额外空间是常数级别

如何处理包含 0 的数组算法天然支持 0 的情况textnums [1, 0, 3, 4] 前缀积: [1, 1, 0, 0] 后缀积: [0, 12, 4, 1] 结果: [0, 12, 0, 0]

复杂度分析方法一两个数组时间复杂度O(n)需要三次遍历数组空间复杂度O(n)使用了两个额外数组方法二优化空间时间复杂度O(n)需要两次遍历数组空间复杂度O(

只使用了常数额外空间输出数组不计入

其他解法解法一使用除法不符合题目要求Java 解法javaclass Solution { public int[] productExceptSelf(int[] nums) { int n nums.length; int[] answer new int[n]; // 计算所有元素的乘积 int totalProduct 1; int zeroCount 0; int zeroIndex -1; for (int i 0; i n; i) { if (nums[i]

{ zeroCount; zeroIndex i; if (zeroCount

{ // 如果有多个0所有结果都是0 return new int[n]; // 默认都是0 } } else { totalProduct * nums[i]; } } // 计算答案 if (zeroCount

{ // 只有一个0那么只有该位置的结果不为0 answer[zeroIndex] totalProduct; } else { // 没有0正常计算 for (int i 0; i n; i) { answer[i] totalProduct / nums[i]; } } return answer; } }Python 解法pythonfrom typing import List class Solution: def productExceptSelf(self, nums: List[int]) - List[int]: n len(nums) answer [0] * n # 计算所有元素的乘积 total_product 1 zero_count 0 zero_index -1 for i, num in enumerate(nums): if num 0: zero_count 1 zero_index i if zero_count 1: # 如果有多个0所有结果都是0 return answer else: total_product * num # 计算答案 if zero_count 1: # 只有一个0那么只有该位置的结果不为0 answer[zero_index] total_product else: # 没有0正常计算 for i in range(n): answer[i] total_product // nums[i] return answer

九、

常见问题与解答Q1: 如果数组中有 0 怎么办A1: 算法天然支持 0 的情况。

当遇到 0 时如果只有一个 0那么除了该位置外其他位置的结果都是 0如果有多个 0那么所有位置的结果都是 0Q2: 为什么不能使用除法A2: 题目明确要求不使用除法。

此外如果使用除法需要处理 0 的情况如果是整数除法可能产生精度问题不符合题目考察的目的考察前缀积和后缀积的思想Q3: 如果数组很大怎么办A3: 算法的时间复杂度是 O(n)空间复杂度是 O(

优化版本可以处理非常大的数组。

Q4: 这个方法适用于负数吗A4: 是的算法适用于包含负数的数组因为乘法对负数同样有效。

Q5: Java 和 Python 版本有什么区别A5: 主要区别在于语法Java 需要显式声明数组类型和大小Python 使用列表推导式和简洁的语法循环语法不同Java 使用 C 风格 for 循环Python 使用 range数组/列表操作语法不同

相关题目

LeetCode

乘积最大子数组Java 解法javaclass Solution { public int maxProduct(int[] nums) { if (nums.length

return 0; int maxProd nums[0]; int minProd nums[0]; int result nums[0]; for (int i 1; i nums.length; i) { int tempMax Math.max(nums[i], Math.max(maxProd * nums[i], minProd * nums[i])); int tempMin Math.min(nums[i], Math.min(maxProd * nums[i], minProd * nums[i])); maxProd tempMax; minProd tempMin; result Math.max(result, maxProd); } return result; } }Python 解法pythonfrom typing import List class Solution: def maxProduct(self, nums: List[int]) - int: if not nums: return 0 max_prod nums[0] min_prod nums[0] result nums[0] for i in range(1, len(nums)): temp_max max(nums[i], max_prod * nums[i], min_prod * nums[i]) temp_min min(nums[i], max_prod * nums[i], min_prod * nums[i]) max_prod, min_prod temp_max, temp_min result max(result, max_prod) return result

LeetCode

最大子数组和Java 解法javaclass Solution { public int maxSubArray(int[] nums) { int maxSum nums[0]; int currentSum nums[0]; for (int i 1; i nums.length; i) { currentSum Math.max(nums[i], currentSum nums[i]); maxSum Math.max(maxSum, currentSum); } return maxSum; } }Python 解法pythonfrom typing import List class Solution: def maxSubArray(self, nums: List[int]) - int: max_sum nums[0] current_sum nums[0] for i in range(1, len(nums)): current_sum max(nums[i], current_sum nums[i]) max_sum max(max_sum, current_sum) return max_sum

十一、

总结核心要点分解问题将每个位置的乘积分解为前缀积和后缀积的乘积避免重复计算通过预处理前缀积和后缀积避免重复计算优化空间可以使用输出数组存储前缀积然后用一个变量计算后缀积算法步骤优化版本初始化输出数组answer所有元素为 1从左到右计算前缀积存储在answer中从右到左计算后缀积同时乘到answer中返回answer时间复杂度与空间复杂度时间复杂度O(n)需要两次遍历数组空间复杂度O(

输出数组不计入空间复杂度适用场景需要计算除自身外所有元素的乘积不能使用除法要求时间复杂度和空间复杂度都尽可能低扩展思考这种前缀积和后缀积的思想可以应用到其他类似问题中如计算除自身外所有元素的和计算除自身外所有元素的最大值/最小值多维数组的类似问题掌握前缀积和后缀积的解法不仅能够解决除自身以外数组的乘积问题还能够理解如何通过预处理来优化计算是面试中非常重要的算法技巧。

16岁女初中生免费观看电视剧-16岁女初中生免费观看电视剧应用