[动态规划+优化] 238. 除自身以外数组的乘积（暴力解 → 动态规划 → 空间优化）

238. 除自身以外数组的乘积

题目链接：https://leetcode-cn.com/problems/product-of-array-except-self/

同 剑指 Offer 66. 构建乘积数组 https://leetcode-cn.com/problems/gou-jian-cheng-ji-shu-zu-lcof/

---

分类：

• 动态规划：
  • 时间优化：对暴力解（思路1）用辅助数组记录中间结果，减少重复计算（思路2）；
  • 空间优化：存在两个dp数组，其一用输出数组代替 + 其二改为迭代更新变量（思路3）。

---

题目分析

题目要求每个元素除自身外的其他元素的乘积，且不能使用除法，我们可以先用暴力解法把握整个解题流程，再对暴力解用辅助空间进行时间上的优化，最后再对辅助空间进行优化。

思路1：暴力解 （时间O(N^2)，空间O(1）)

对于每个元素nums[i]，都从头遍历一遍数组，计算除自身外所有元素的乘积。

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] res = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            res[i] = 1;
            for(int j = 0; j < nums.length; j++){
                if(j == i) continue;
                res[i] *= nums[j];
            }
        }
        return res;
    }
}

• 时间复杂度：O(N^2)，用例超时

思路2：左右乘积列表 （双向动态规划，时间O(N),空间O(N)）

分析思路1的过程可以发现，在计算除每个元素除自身外的元素乘积时做了很多重复计算:

例如：
计算nums[0]*nums[1]得到nums[2]的左半部分乘积，但在计算nums[3]的左半部分乘积时，需要做nums[0]*nums[1]*nums[2]，相当于把nums[0]*nums[1]又重新计算了一遍。

根据这个例子可以发现：在计算nums[0] * nums[1]得到nums[2]的左半部分乘积时，把nums[0] * nums[1]保存起来，之后在计算nums[3]的左半部分时就可以直接利用保存好的值即可，不必再做重复计算。

同理，计算一个元素的右半部分乘积时，也把这部分乘积保存下来，供前一个元素计算有半部分乘积时使用。

状态设置：
根据上面的结论，可以设置两个数组left,right，分别保存元素i的左半部分元素的乘积和右半部分元素的乘积，最后的输出数组res[i] = left[i] * right[i]。

状态转移：
先正向遍历一次nums数组构建left数组，再反向遍历一次nums数组构建right数组:

• 如何构建left数组？left[i]存放的是nums[0~i-1]的元素乘积，正向遍历nums数组：

  • i=0时，没有左边元素，所以直接令left[i]=1，避免干扰后面的计算；

  • i=1时，存在一个左边元素nums[0]，所以left[1]=left[0]*nums[0]；

  • i=2时，存在两个左边元素nums[0],nums[1]，此时left[1]=nums[0]，所以left[2]=left[1]*nums[1]；

    以此类推，可以总结为：

      i!=0时，left[i] = left[i-1]*nums[i-1]，
      
      i==0时，left[0] = 1;
    

• 如何构建right数组？right[i]存放的是nums[i+1~len-1]的元素乘积，反向遍历nums数组：

  • i=len-1时，没有右半元素，所以直接令right[len-1]=1；

  • i=len-2时，存在一个右边元素nums[len-1]，所以right[len-2]=right[len-1]*nums[len-1]

    以此类推，可以总结为：

      i==len-1时，right[len-1]=1;
      
      i!=len-1时，right[i] = right[i+1]*nums[i+1];
    

最后从i=0开始构造res：res[i] = left[i] * right[i]。

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int len = nums.length;
        int[] left = new int[len];
        //left数组的初始化
        left[0] = 1;
        int[] right = new int[len];
        //right数组的初始化
        right[len - 1] = 1;
				//正向遍历构造left数组
        for(int i = 1; i < len; i++){
            left[i] = left[i - 1] * nums[i - 1];
        }
				//反向遍历构造right数组
        for(int i = len - 2; i >= 0; i--){
            right[i] = right[i + 1] * nums[i + 1];
        }
        //计算最终结果
        int[] res = new int[len];
        for(int i = 0; i < len; i++){
            res[i] = left[i] * right[i];
        }
        return res;
    }
}

思路3：思路2的空间优化（时间O(N)，空间O(1)）

动态规划优化空间的常规思路就是观察状态转移方程，如果第i个状态之和有限个其他状态有关，就可以用变量迭代更新的方式代替dp数组。

观察思路2的两个状态转移方程可以发现，left数组的构建过程中，第 i 个状态只和第 i - 1 个状态有关，可以用一个变量的迭代更新来获取left的所有状态，同理把right数组也用一个变量的迭代更新来优化，但在计算res[i]时需要left[i]和right[i]同时填充完成，而如果left,right变量同步更新，则当left迭代更新到 i 处时，right还没更新到 i 处，如果等待right继续更新直到right[i]，也就失去了思路2随存随取的优势，退化为思路1的暴力解法了。

所以不能两个dp数组都缩减为一个变量。

根据题目提示，输出数组不被视为额外空间，所以我们可以把其中一个dp数组存放在输出数组上，然后迭代更新另一个状态变量，就能将空间复杂度缩减为O(1)。

这里我们把left数组存放在输出数组上：

• 首先，做一次正向遍历，把输出数组res当做left数组来使用；
• 然后，再做一次反向遍历，设置一个right迭代更新，初始值right=1，则：

  	  res[i]=res[i] * right;
  	  
  	  right *= nums[i];

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int len = nums.length;
        //存放最终结果
        int[] res = new int[len];
        res[0] = 1;
        //正向遍历，res[i]存放的是[0~i-1]的乘积，相当于构建left数组
        for(int i = 1; i < len; i++){
            res[i] = res[i - 1] * nums[i - 1];
        }
        //反向遍历，res[i]和[i+1~len-1]的乘积相乘，得到最终的结果
        int right = 1;//right数组优化为一个迭代更新的变量，表示[i+1~len-1]的乘积
        for(int i = len - 1; i >= 0; i--){
            res[i] = res[i] * right;
            right *= nums[i];
        }
        return res;
    }
}