算法 簡單 | 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