算法 简单 | 50. 数组剔除元素后的乘积

题目描述

给定一个整数数组A。
定义B[i] = A[0] * … * A[i-1] * A[i+1] * … * A[n-1]， 计算B的时候请不要使用除法。
请输出B。

样例1

输入: A = [1, 2, 3]
输出: [6, 3, 2]
解析：B[0] = A[1] * A[2] = 6; B[1] = A[0] * A[2] = 3; B[2] = A[0] * A[1] = 2

样例2

输入: A = [2, 4, 6]
输出: [24, 12, 8]

java题解

分两次循环
第一次记录数组从后往前的累乘结果，f[i]代表i位之后所有元素的乘积
第二次循环，从左往右，跳过 i 左侧累乘，右侧直接乘以f[i + 1]

import java.util.ArrayList;
public class Solution {
    public ArrayList<Long> productExcludeItself(ArrayList<Integer> A) {
        int len = A.size();
        ArrayList<Long> B = new  ArrayList<Long>();
        long[] f = new long[len];

        long tmp = 1;
        long now = 1;
        f[len-1] = A.get(len-1);
        int i ;
        for ( i = len-2; i >= 0; --i)
        {
            f[i] = A.get(i);
            f[i] = f[i] * f[i+1];
        }

        for ( i = 0; i < len; ++i) {
    		
            now = tmp;
            if(i+1<len)
                B.add( now * f[i+1] );
            else
                B.add( now );
            now = A.get(i);
            tmp = tmp * now;

        }
        return B;
    }
}

C++题解

分两次循环
第一次记录数组从后往前的累乘结果，f[i]代表i位之后所有元素的乘积
第二次循环，从左往右，跳过 i 左侧累乘，右侧直接乘以f[i + 1]

using namespace std;
class Solution {
public:
    vector<long long> productExcludeItself(vector<int> &nums) {
        vector<long long> B;
        int len = nums.size();
        long long f[len + 1];
        
        f[len] = 1;
        for (int i = len-1; i >= 0; --i)
            f[i] = f[i + 1] * nums[i];
        long long tmp = 1; 
        for (int i = 0; i < len; ++i) {
            B.push_back(tmp * f[i + 1] );
            tmp *= nums[i];
        }
        return B;
    }
};

python题解

分两次循环
第一次记录数组从后往前的累乘结果，f[i]代表i位之后所有元素的乘积
第二次循环，从左往右，跳过 i 左侧累乘，右侧直接乘以f[i + 1]

class Solution:
    def productExcludeItself(self, A):
        length ,B  = len(A) ,[]
        f = [ 0 for i in xrange(length + 1)]
        f[ length ] = 1
        for i in xrange(length - 1 , 0 , -1):
            f[ i ] = f[ i + 1 ] * A[ i ]
        tmp = 1
        for i in xrange(length):
            B.append(tmp * f[ i + 1 ])
            tmp *= A[ i ]
        return B