如果是不连续的情况，只考虑正数的话会不会错过负负得正的情况？

暴力法参考@大可可的代码，希望可以指正，共同学习 // 暴力法 public static int maxProduct(int[] nums) { int max = Integer.MIN_VALUE; for(int i = 0; i < nums.length; i++) { for(int j = i; j < nums.length; j++) { int[] subNums = Arrays.copyOfRange(nums, i, j + 1); // 复制的区间是左闭右开，即不包括j+1 int product = 1; for(int k = 0; k < subNums.length; k++) { product *= subNums[k]; } if(max < product) max = product; } } return max; } // 动态规划 public static int maxProduct2(int[] nums) { int[][] dp = new int[2][2]; // 第一维表示数组的长度，由于不需要保存整个数组，所以长度只需要取2即可，第二维用0表示是正的最大值，用1表示为负的最大值 int res = nums[0]; // 最终的结果 dp[0][0] = nums[0]; dp[0][1] = nums[0]; for(int i = 1; i < nums.length; i++) { int x = i % 2; int y = (i - 1) % 2; // 滚动数组，取值 0 or 1 // if (nums[i] >= 0) { // dp[x][0] = Math.max(dp[y][0] * nums[i], nums[i]); // 正的最大值 // dp[x][1] = Math.min(dp[y][1] * nums[i], nums[i]); // 负的最大值 // } else { // dp[x][0] = Math.max(dp[y][1] * nums[i], nums[i]); // 正的最大值，负负得正 // dp[x][1] = Math.min(dp[y][0] * nums[i], nums[i]); // 负的最大值 // } // 上面的if语句可以简写成下面这样 dp[x][0] = Math.max(Math.max(dp[y][0] * nums[i], dp[y][1] * nums[i]), nums[i]); dp[x][1] = Math.min(Math.min(dp[y][0] * nums[i], dp[y][1] * nums[i]), nums[i]); res = Math.max(res, dp[x][0]); // 最后的结果取决于正的最大值 } return res; }

最终还是写了一个DFS版本 - 就是将递推转变为dfs的递归，每次带上最大和最小两个状态，当递归到数组末尾，返回。过程中，始终记录最大值。 ··· class Solution { int res = Integer.MIN_VALUE; public int maxProduct(int[] nums) { if (nums.length == 0) return 0; dfs(nums, 0, 1, 1); return res; } public void dfs(int[] nums, int i, int positive, int negative) { if (i == nums.length) return; int num = nums[i]; if (num >= 0){ positive = positive * num; negative = negative * num; if (num > positive) positive = num; }else { int negative1 = positive * num; positive = negative * num; negative = negative1; if (num < negative) negative = num; } if (res < positive) res = positive; dfs(nums, i + 1, positive, negative); } } ···

老师可以解释一下这种方法遇到零是怎么解决的吗？这一块有一点想不通

视频中给出的第二种解法没有考虑到如果数组中含有0的情况 会出错

重新提交一个 js版的暴力求解代码 // 暴力求解 function maxProductSubarray(nums) { if(!nums || (nums && nums.length === 0)) return 0 let max = Number.MIN_SAFE_INTEGER for(let i = 0, len = nums.length; i < len; i++) { for(let j = i; j < len; j++) { let sub = nums.slice(i, j + 1) let product = 1 for(let j = 0, subLen = sub.length; j < subLen; j++) { product *= sub[j] } if(product > max) { max = product } } } return max }

还需要和自身a[i] 比较，这个白板没讲到

老师，这题本身思路就比较复杂，能不能在讲完思路实现后，再进行代码优化，这样更加有层次。

1.这道题和前两道题对比：这里的递归方法（深度枚举）并不体现出递推方程，而前两道题即使在递归（回朔）中也可以看出递推方程。 2.要有确定状态维度的概念：一维或多维。一般情况下，n维的数据，n维的状态，但这道题不是

这里dp[i]表示的并不是子问题的解，max(dp[i], dp[i-1], dp[i-2]...dp[0])才是。