构建乘积数组。

题目描述

给定一个数组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]。 不能使用除法 。

二种解法：

第一种更好：O(n)时间复杂度，O(1)空间复杂度。

class Solution {
public:
    vector<int> multiply(const vector<int>& A) {
        vector<int> B(A.size(),0);
        if(A.empty()||A.size()<2) return B;
        int len=A.size();
        
        B[0]=1;
        for (int i = 1; i <= len-1; ++i)
        {
            B[i]=A[i-1]*B[i-1];
        }
        int tmp=1;
        for (int i = len-2; i >=0 ; --i)
        {
            tmp=tmp*A[i+1];
            B[i]=B[i]*tmp;
        }

        return B;
    }
};

仔细对比分析：

B[k] = leftproduct[k] * rightproduct[k];

所以只要两次遍历即可，O(2n)的时间复杂度，即O(2n)的空间复杂度，这题不能用除法。

注意：

1、//vector<int> B; 没有初始化vector<int>B的长度，怎么可以用B[k]访问值,你脑袋进屎了？

2、//int leftproduct[len]; //Error:表达式必须含有常量值，记住，分配多大的内存，一定要有值，而不能被动等待值。

class Solution {
public:
	vector<int> multiply(const vector<int>& A) {
        //vector<int> B; 没有初始化vector<int>B的长度，怎么可以用B[k]访问值,你脑袋进屎了？
		vector<int> B(A.size(),0);
		if (A.empty() || A.size()<2) return B;
		int len = A.size();
		int*leftproduct = new int[len];
		int*rightproduct = new int[len];
		//int leftproduct[len]; //Error:表达式必须含有常量值，记住，分配多大的内存，一定要有值，而不能被动等待值。
		//int rightproduct[len];

		int product = 1;
		leftproduct[0] = 1;
		for (int i = 1; i <= len - 1; ++i)
		{
			product = A[i - 1] * product;
			leftproduct[i] = product;
		}

		product = 1;
		rightproduct[len - 1] = 1;
		for (int i = len - 2; i >= 0; --i)
		{
			product = A[i + 1] * product;
			rightproduct[i] = product;
		}

		for (int k = 0; k < len; ++k)
		{
			B[k] = leftproduct[k] * rightproduct[k];
		}

		delete[]leftproduct;
		delete[]rightproduct;

		return B;
	}
};