构建乘积数组

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

解法一：
最开始我想用移位来做的，举个栗子， (num * 5 = num >> 2 + num >> 1)，这种明显是可行的，然后我就想通过一些基础运算，把移位也应用到这里，发现还是太天真了。
老老实实蠢办法吧。对于最终生成的 vector 的每一个元素，都把A来遍历一遍。
时间复杂度O(n^{2)，空间复杂度O(n)}

class Solution {
public:
	vector<int> multiply(const vector<int>& A) {
		int length = A.size();
		vector<int> B;
		if (length <= 1)
			return B;

		int mul;
		for (int i = 0; i < length; i++)
		{
			mul = 1;
			for (int j = 0; j < length; j++)
			{
				if (i == j)
					continue;
				else
					mul *= A[j];
			}
			B.push_back(mul);
		}

		return B;
	}
};

解法二：
今天早晨看到昨天写的一些例子，
B[0] = A[1] * … * A[n-1];
B[1] = A[0] * A[2] * … A[n-1];
B[2] = A[0] * A[1] * A[3] * … * A[n-1];

当下标相等时就跳过，下标相等不就是对角线吗，然后就是像上图那样啦。这样一来的话，对于最终的数组，就不用每个都从头开始遍历了。思路如下：
- 定义两个数组，一个表示上三角B，一个表示下三角C（这个下三角感觉可以用栈来表示）
- B 从前往后遍历一遍，C 从后往前遍历
- 最后交叉相乘
时间复杂度O(n)，空间复杂度O(2n)

class Solution {
public:
    vector<int> multiply(const vector<int>& A) {
        int length = A.size();
        vector<int> B, C;
        if (length <= 1)
            return B;
        
        //B 用来正着放
        B.push_back(1);
        for (int i = 0; i < length - 1; i++)
        {
            B.push_back(B[i] * A[i]);
        }
        
        C.push_back(1);
        for (int i = length - 1, j = 0; i > 0; i--, j++)
        {
            C.push_back(C[j] * A[i]);
        }
        
        vector<int> vec;
        for (int i = 0, j = length - 1; i < length; i++, j--)
            vec.push_back(B[i] * C[j]);
        
        return vec;
    }
};

不知道为什么，执行时间反而变长了。