[容易]数组剔除元素后的乘积

题目来源:http://www.lintcode.com/zh-cn/problem/product-of-array-exclude-itself/

方法1:直接法

可以accept的程序如下:

 1 class Solution {
 2 public:
 3     /**
 4      * @param A: Given an integers array A
 5      * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
 6      */
 7     vector<long long> productExcludeItself(vector<int> &nums) {
 8         // write your code here
 9         vector<long long> result;
10         for(int i=0;i<nums.size();i++)
11         {
12             long long temp=1;
13             for(int j=0;j<i;j++)
14                 temp*=nums[j];
15             for(int j=i+1;j<nums.size();j++)
16                 temp*=nums[j];
17             result.push_back(temp);
18         }
19         return result;
20     }
21 };

方法2:Time: O(n)   Space: O(1)

可以accept的程序如下:

 1 class Solution {
 2 public:
 3     /**
 4      * @param A: Given an integers array A
 5      * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
 6      */
 7     vector<long long> productExcludeItself(vector<int> &nums) {
 8         // write your code here
 9         vector<long long> left_product(nums.size());
10         left_product[0] = 1;
11         for (int i = 1; i < nums.size(); ++i) {
12             left_product[i] = left_product[i - 1] * nums[i - 1];
13         }
14         long long right_product = 1;
15         for (int i = static_cast<int>(nums.size()) - 2; i >= 0; --i) {
16             right_product *= nums[i + 1];
17             left_product[i] = left_product[i] * right_product;
18         }
19         return left_product;
20     }
21 };

方法3:Time: O(n)   Space: O(n)

可以accept的程序如下:

 1 class Solution {
 2 public:
 3     /**
 4      * @param A: Given an integers array A
 5      * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
 6      */
 7     vector<long long> productExcludeItself(vector<int> &nums) {
 8         // write your code here
 9         vector<long long> left_product(nums.size());
10         vector<long long> right_product(nums.size());
11         vector<long long> product(nums.size());
12         left_product[0] = 1;
13         for (int i = 1; i < nums.size(); ++i) {
14             left_product[i] = left_product[i - 1] * nums[i - 1];
15         }
16         right_product[nums.size() - 1] = 1;
17         for (int j = static_cast<int>(nums.size()) - 2; j >= 0; --j) {
18             right_product[j] = right_product[j + 1] * nums[j + 1];
19         }
20         for (int k = 0; k < nums.size(); ++k) {
21             product[k] = left_product[k] * right_product[k];
22         }
23         return product;
24     }
25 };
时间: 2024-10-20 14:03:35

[容易]数组剔除元素后的乘积的相关文章

lintcode 容易题:Product of Array Exclude Itself 数组剔除元素后的乘积

题目: 数组剔除元素后的乘积 给定一个整数数组A. 定义B[i] = A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1], 计算B的时候请不要使用除法. 样例 给出A=[1, 2, 3],返回 B为[6, 3, 2] 解题: leftb计算左侧的连乘值,每次增加一个成绩,rightb计算右侧的连乘值,每次重新计算,时间复杂度O(N2),下面写的程序,自我感觉很差的... Java程序: public class Solution { /** * @param

LintCode_50 数组剔除元素后的乘积

题目 给定一个整数数组A. 定义B[i] = A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1], 计算B的时候请不要使用除法. 样例 给出A=[1, 2, 3],返回 B为[6, 3, 2] vector<long long> productExcludeItself(vector<int> &nums) { // write your code here vector<long long> v(nums.size());

LintCode 50. 数组剔除元素后的乘积

题目: 给定一个整数数组A. 定义B[i] = A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1], 计算B的时候请不要使用除法. 样例 给出A=[1, 2, 3],返回 B为[6, 3, 2] 解:看样例,B[0]=A[1]*A[2],B[1]=A[0]*A[2],B[2]=A[0]*A[1]; 代码中left保存左边的值, right保存右边的值 class Solution { public: /* * @param nums: Given an int

数组剔除元素后的乘积

给出A=[1, 2, 3],返回 B为[6, 3, 2] public ArrayList<Long> productExcludeItself(ArrayList<Integer> A) { ArrayList<Long> rst = new ArrayList<>(); for(int i=0; i<A.size(); i++){ Long cur = 1L; for(int j=0; j<A.size(); j++){ if(j==i) c

LintCode-数组剔除元素后的乘积

题目描述: 给定一个整数数组A. 定义B[i] = A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1], 计算B的时候请不要使用除法. 样例 给出A=[1, 2, 3],返回 B为[6, 3, 2] 1 public class Solution { 2 /** 3 * @param A: Given an integers array A 4 * @return: A Long array B and B[i]= A[0] * ... * A[i-1] *

在有顺序的数列中插入一个元素后该数列仍然是有顺序的数组

/** 在有顺序的数组中插入一个元素后该数列仍然是有顺序的数组: 思路:先找到该元素的插入位置 插入数据时要先将数组中得元素后移,然后插入该元素 */ #include <stdio.h> #define  n 10 int main() { // 在有顺序的数列中插入一个元素后该数列仍然是有顺序的数列: int a[n] = {-1, 3, 6, 9, 13, 22, 27, 32, 49}; int insertVal; int insertLoc; scanf("%d"

腾讯面试题之求数组前小后大划分元素

时间:2014.04.29 地点:基地二楼 --------------------------------------------------------------------------------------- 一.题目 整型数组里找出符合要求的元素,满足前面的元素比该元素小,后面的元素比该元素大. 时间复杂度为:O(n) 原理:另外开辟两个数组,初始化为原数组值,一个用于存储到当前元素为止前面部分的最大值,另一个用于存储到当前元素为止,后面部分的最小值.最后用当前元素和最大值数组和最小

javascript 笔试题之删除数组重复元素

笔试时紧张没写出来,静下心后发现简单的要死. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html lang="en"> <head> <meta http-equiv="Content-Type" content=&quo

求数组主元素的递归算法

数组A是具有n个元素的数组,x是A中的一个元素,若A中有一半以上的元素与A相同,则称x是数组A的主元素.例如 ,数组A={1,3,2,3,3,4,3},元素3就是该数组的主元素. 1.移去数组中的两个不同元素后,如果原来数组中有主元素,那么该主元素依然是新数组的主元素. 2.如果数组2k个元素中有k个元素相同(k<n/2),移去这2k个元素以后,如果原来数组中有主元素,那么该主元素依然是新数组的主元素. 如果新数组只剩下一个元素,该元素可作为主元素的候选者.新数组是若干个相同元素,该元素可作为主