构建乘积数组--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(n2);空间复杂度为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)。

posted @ 2017-08-15 14:21 笨鸟多学 阅读(...) 评论(...) 编辑 收藏