构建乘积数组--java

题目：给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1]，其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。

解析：这道题，直观的解法是：设置一个循环（由0到n-1），计算B[i]时，忽略掉A[i]项，把数组A中的其他项全部相乘，即得到B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。这样，一次循环过后，就可以在没有除法的条件下，得到数组B中所有的值。那么，这种解法的时间复杂度和空间复杂度是多少呢？时间复杂度：由于循环由0~n-1，即o(n)，在每次循环中，要执行n-1次乘法运算，所以这种解法的时间复杂度为o(n)*o(n-1)=o(n²)；空间复杂度为o(1)。

　　显然，上面这种解法的时间复杂度较高，那么有没有o(n)的解法呢？我们不妨分析一下上面这种解法的问题，从而找到可以优化的突破口。上面的复杂度由两部分组成，第一部分：循环由0~n-1，显然我们需要计算每一个B[i]，不管怎样，我们都没办法去掉这样的基本循环，也就是说这一部分带来了时间复杂度o(n)不能再进行优化；第二部分：每一次计算B[i]都需要进行n-1次乘法，也即是需要计算n次n-1个数相乘，细心的人可以发现，这里面有很多的乘法是重复的，正是由于这部分重复的乘法计算造成我们的时间复杂度很高。那么，有没有办法只计算一次这样的n-1个数相乘呢？我们可以定义两个中间数组来存储已经计算过得乘法结果，这样，在进行下一个B[i]计算时，我们只需要完成一次乘法就可以得到B[i]的结果了。这样，时间复杂度就变成了o(1)，整个算法时间复杂度就降成了o(n)。具体分析思路如下：

        首先，我们可以将数组B表示成矩阵的形式如下：

B[0]	1	A[1]	A[2]	...	A[n-2]	A[n-1]
B[1]	A[0]	1	A[2]	...	A[n-2]	A[n-1]
B[2]	A[0]	A[1]	1	...	A[n-2]	A[n-1]
...	...	...	...	1	...	...
B[n-2]	A[0]	A[1]	A[2]	...	1	A[n-1]
B[n-1]	A[0]	A[1]	A[2]	...	A[n-2]	1

如上图所示，矩阵的每一行代表数组B的一个元素，从上往下，依次是B[0],B[1],...B[n-2],B[n-1]。那么，我们可以将每一个B[i]看成两部分，分别用C[i]和D[i]表示。其中C[i] = A[0]*A[1]*...*A[i-1]，D[i] = A[i+1]*...*A[n-2]*A[n-1]，这样，B[i]=C[i]*1*D[i]。也就是说，我们可以每次更新数组C[i]和D[i]，即C[i]=C[i-1]*A[i-1]和D[i]=D[i+1]*A[i+1](需要说明的是，这里C[i]的更新是按照从前往后，而D[i]则是从后往前)，从而为我们节省了大量的重复的乘法计算，使得时间复杂度降为o(n)。

int[] multiply(int[] A){
    if(A==null||A.length<=0)//边界条件，最好附带上
            return null;
    int n = A.length;
    int[] B = new int[n];
    B[0]=1;
    /*更新C[i],这里我们不另外定义数组，直接将C[i]的计算结果存储在B[i]中,
       这样，再将D[i]的结果直接乘以B[i]（此时B[i]等于C[i]），就得到了最终
       的B[i]，显然为我们又节省了不少空间存储。
    */
    for(int i=1;i<n;i++){
            B[i]=B[i-1]*A[i-1];
    }
    int temp =1;
    //更新D[i],这里要从n-2开始，因为B[n-1]已得到最终结果
    for(int j=n-2;j>=0;j--){
            temp*=A[j+1];
            B[j]*=temp;
    }
　　 return B;
}

　　显然，上述解法的时间复杂度为：2*o(n)*2=o(n)。