子数组的最大乘积

最新推荐文章于 2024-03-23 18:33:44 发布
最新推荐文章于 2024-03-23 18:33:44 发布
阅读量405 收藏
点赞数
分类专栏： 笔试面试题 算法 序列类型 数字相关 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyapy/article/details/38401323
版权

《编程之美》 2.13

问题：给定一个长度为N的整数数组，只允许用乘法，不能用除法，计算（N-1）个数的组合乘积中最大的一组，并写出算法的时间复杂度。

解法一：把所有N-1个数的组合找出来，分别计算乘积，比较大小。O(N^2)。

int MaxSubProducti(int a[],int n)
{
	assert(n > 1);
	int i,j,k,prod,ret;
	for (i = 0; i < n; i++){
		prod = 1;
		for(j = 0; j < i; j++){
			prod *= a[j];
		}
		for(j = i + 1; j < n; j++){
			prod *= a[j];
		}
		if (i == 0) ret = prod;
		if (prod > ret) ret = prod;
	}
	return ret;
}

int MaxSubProductii(int a[],int n)
{
	assert(n > 1);
	int i,j,prod,ret;
	for(i = 0; i < n; i++){
		prod = 1;
		for(j = 0; j < n; j++){
			prod *= (i == j) ? 1 : a[j];
			if (prod == 0)// terminate early
				break;
		}
		if (i == 0) ret = prod;
		if (prod > ret)	ret = prod;
	}
	return ret;	
}

解法二：利用两个数组s和s分别表示从数组a的两端开始计算的乘积，s[i] = a[0]*a[1]*...*a[i-1]，t[j] = a[j]*...*a[n-1]。那么p[i] = s[i-1] * t[i+1]。时间复杂度为O(N)。 

int MaxSubProductiii(int a[],int n)
{
	assert(n > 1);
	int *s = (int *)malloc(n*sizeof(int));
	int *t = (int *)malloc(n*sizeof(int));
	int i,j,lowprod,highprod,maxprod,prod;
	lowprod = 1;
	highprod = 1;
	assert(s != NULL && t != NULL);
	
	for(i = 0; i < n; i++){
		j = n - i - 1;
		lowprod *= a[i];
		highprod *= a[j];
		s[i] = lowprod;
		t[j] = highprod;
	}
	maxprod = (s[n-2] > t[1]) ? s[n-2] : t[1];
	for(i = 1; i < n - 1; i ++){
		prod = s[i-1] * t[i+1];
		if (prod > maxprod) maxprod = prod;
	}
	free(s);
	free(t); 
	return maxprod;
}

解法三：统计数组中正数、负数和零的个数，记录最小的正数、负数以及最大的负数。

1，如果零的个数n_zero大于1，那么最大乘积为0；

2，如果零的个数n_zero为1：

(1)，如果负数的个数n_neg为奇数，那么最大乘积为0；

(2)，如果负数的个数n_neg为偶数，那么最大乘积计算式扣除a[zeroi]；

3，如果零的个数n_zero为0：

(1)，如果负数的个数n_neg为奇数，那么最大乘积计算式扣除a[maxnegi]；

(2)，如果负数的个数n_neg为偶数：

1> 如果正数的个数n_pos为零，那么最大乘积计算式扣除a[minnegi]；

2> 如果正数的个数n_pos大于零，那么最大乘积计算式扣除a[minposi]；

int MaxSubProductiv(int *a, int n)
{
	int n_zero = 0; // count of zero 
	int n_neg = 0;  // count of negative integer
	int n_pos = 0;
	int maxneg = 0; // maximum negative integer 
	int minpos = 0; // minimum positive integer 
	int maxnegi = 0; // index of maxneg
	int minposi = 0; // index of minimum positive integer
	int zeroi = 0;   // index of zero
	int minneg = 0;
	int minnegi = 0;
	int out = -1;    // index of the val to be omitted 
	                 // when calculating result product
	int max = 1;
	
	/* collect some statistic info in one loop */
	for(int i = 0; i < n; i++)
	{
		if(a[i] < 0)  //a[i] is negative
		{
			n_neg++;
			if(maxneg == 0)
			{
				maxneg = a[i];
				maxnegi = i;
			}
			else if(maxneg < a[i])
			{
				maxneg = a[i];
				maxnegi = i;
			}
			
			if (minneg == 0) {
				minneg = a[i];
				minnegi = i;
			}
			else if (minneg > a[i]) {
				minneg = a[i];
				minnegi = i;
			}
		}
		else if(a[i] == 0) // a[i] is zero
		{
			zeroi = i;
			if(++n_zero > 1) return 0;
		}
		else // a[i] is positive
		{
			n_pos++;
			if(minpos == 0)
			{
				minpos = a[i];
				minposi = i;
			}
			else if(minpos > a[i])
			{
				minpos = a[i];
				minposi = i;
			}
		}
	}
 
 
	if((n_zero == 1) && (n_neg & 0x1))
	{
		// one zero and odd negatives
		return 0;
	}
	else if((n_zero == 1) && !(n_neg & 0x1))
	{
		// one zero and even negatives
		printf("one zero and even negatives\n");
		out = zeroi;
	}
	else if((n_zero == 0) && (n_neg & 0x1))
	{
		// no zero and odd negatives
		printf("no zero and odd negatives\n");
		out = maxnegi;
	}
	else if((n_zero == 0) && !(n_neg & 0x1))
	{
		// no zero and even negatives
		printf("no zero and even negatives\n");
		if (n_pos == 0){
			out = minnegi;
		}
		else {
			out = minposi;
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		max *= (i == out) ? 1 : a[i];
	}
	return max;
}

int MaxSubProductv(int *a, int n)
{
	int n_zero = 0; // count of zero 
	int n_neg = 0;  // count of negative integer
	int n_pos = 0;  // count of positive integer
	int maxneg = 0; // maximum negative integer 
	int minpos = 0; // minimum positive integer 
	int maxnegi = 0; // index of maxneg
	int minposi = 0; // index of minimum positive integer
	int zeroi = 0;   // index of zero
	
	int minneg = 0;
	int minnegi = 0;
	
	int out = -1;         // index of the val to be omitted 
	                 // when calculating  product
	int max = 1;
	
	for(int i = 0; i < n; i++)
	{
		if(a[i] < 0)  //a[i] is negative
		{
			n_neg++;
			if(maxneg == 0)
			{
				maxneg = a[i];
				maxnegi = i;
			}
			else if(maxneg < a[i])
			{
				maxneg = a[i];
				maxnegi = i;
			}
			
			if (minneg == 0){
				minneg = a[i];
				minnegi = i; 
			}
			else {
				if (minneg > a[i]){
					minneg = a[i];
					minnegi = i;
				}
			} 
		}
		else if(a[i] == 0) // a[i] is zero
		{
			zeroi = i;
			if(++n_zero > 1) return 0;
		}
		else // a[i] is positive
		{
			n_pos++;
			if(minpos == 0)
			{
				minpos = a[i];
				minposi = i;
			}
			else if(minpos > a[i])
			{
				minpos = a[i];
				minposi = i;
			}
		}
	}
 
 	if (n_zero){
 		printf("zeros.\n");
 		if (n_neg & 1)
 			return 0;
 		else
 			out = zeroi;
 	}
 	else {
 		printf("no zero.\n");
 		if (n_neg & 1)
 			out = maxnegi;
 		else if (n_pos == 0){
 			out = minnegi;
 		}
 		else {
 			out = minposi;
 		}
 	}
		
	for(int i = 0; i < n; i++)
	{
		max *= (i == out) ? 1 : a[i];
	}
	return max;
}

测试程序： 

#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <stdlib.h>


int MaxSubProducti(int a[],int n)
{
	assert(n > 1);
	int i,j,k,prod,ret;
	for (i = 0; i < n; i++){
		prod = 1;
		for(j = 0; j < i; j++){
			prod *= a[j];
		}
		for(j = i + 1; j < n; j++){
			prod *= a[j];
		}
		if (i == 0) ret = prod;
		if (prod > ret) ret = prod;
	}
	return ret;
}

int MaxSubProductii(int a[],int n)
{
	assert(n > 1);
	int i,j,prod,ret;
	for(i = 0; i < n; i++){
		prod = 1;
		for(j = 0; j < n; j++){
			prod *= (i == j) ? 1 : a[j];
			if (prod == 0)// terminate early
				break;
		}
		if (i == 0) ret = prod;
		if (prod > ret)	ret = prod;
	}
	return ret;	
}

int MaxSubProductiii(int a[],int n)
{
	assert(n > 1);
	int *s = (int *)malloc(n*sizeof(int));
	int *t = (int *)malloc(n*sizeof(int));
	int i,j,lowprod,highprod,maxprod,prod;
	lowprod = 1;
	highprod = 1;
	assert(s != NULL && t != NULL);
	
	for(i = 0; i < n; i++){
		j = n - i - 1;
		lowprod *= a[i];
		highprod *= a[j];
		s[i] = lowprod;
		t[j] = highprod;
	}
	maxprod = (s[n-2] > t[1]) ? s[n-2] : t[1];
	for(i = 1; i < n - 1; i ++){
		prod = s[i-1] * t[i+1];
		if (prod > maxprod) maxprod = prod;
	}
	free(s);
	free(t); 
	return maxprod;
}

int MaxSubProductiv(int *a, int n)
{
	int n_zero = 0; // count of zero 
	int n_neg = 0;  // count of negative integer
	int n_pos = 0;
	int maxneg = 0; // maximum negative integer 
	int minpos = 0; // minimum positive integer 
	int maxnegi = 0; // index of maxneg
	int minposi = 0; // index of minimum positive integer
	int zeroi = 0;   // index of zero
	int minneg = 0;
	int minnegi = 0;
	int out = -1;    // index of the val to be omitted 
	                 // when calculating result product
	int max = 1;
	
	/* collect some statistic info in one loop */
	for(int i = 0; i < n; i++)
	{
		if(a[i] < 0)  //a[i] is negative
		{
			n_neg++;
			if(maxneg == 0)
			{
				maxneg = a[i];
				maxnegi = i;
			}
			else if(maxneg < a[i])
			{
				maxneg = a[i];
				maxnegi = i;
			}
			
			if (minneg == 0) {
				minneg = a[i];
				minnegi = i;
			}
			else if (minneg > a[i]) {
				minneg = a[i];
				minnegi = i;
			}
		}
		else if(a[i] == 0) // a[i] is zero
		{
			zeroi = i;
			if(++n_zero > 1) return 0;
		}
		else // a[i] is positive
		{
			n_pos++;
			if(minpos == 0)
			{
				minpos = a[i];
				minposi = i;
			}
			else if(minpos > a[i])
			{
				minpos = a[i];
				minposi = i;
			}
		}
	}
 
 
	if((n_zero == 1) && (n_neg & 0x1))
	{
		// one zero and odd negatives
		return 0;
	}
	else if((n_zero == 1) && !(n_neg & 0x1))
	{
		// one zero and even negatives
		printf("one zero and even negatives\n");
		out = zeroi;
	}
	else if((n_zero == 0) && (n_neg & 0x1))
	{
		// no zero and odd negatives
		printf("no zero and odd negatives\n");
		out = maxnegi;
	}
	else if((n_zero == 0) && !(n_neg & 0x1))
	{
		// no zero and even negatives
		printf("no zero and even negatives\n");
		if (n_pos == 0){
			out = minnegi;
		}
		else {
			out = minposi;
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		max *= (i == out) ? 1 : a[i];
	}
	return max;
}

int MaxSubProductv(int *a, int n)
{
	int n_zero = 0; // count of zero 
	int n_neg = 0;  // count of negative integer
	int n_pos = 0;  // count of positive integer
	int maxneg = 0; // maximum negative integer 
	int minpos = 0; // minimum positive integer 
	int maxnegi = 0; // index of maxneg
	int minposi = 0; // index of minimum positive integer
	int zeroi = 0;   // index of zero
	
	int minneg = 0;
	int minnegi = 0;
	
	int out = -1;         // index of the val to be omitted 
	                 // when calculating  product
	int max = 1;
	
	for(int i = 0; i < n; i++)
	{
		if(a[i] < 0)  //a[i] is negative
		{
			n_neg++;
			if(maxneg == 0)
			{
				maxneg = a[i];
				maxnegi = i;
			}
			else if(maxneg < a[i])
			{
				maxneg = a[i];
				maxnegi = i;
			}
			
			if (minneg == 0){
				minneg = a[i];
				minnegi = i; 
			}
			else {
				if (minneg > a[i]){
					minneg = a[i];
					minnegi = i;
				}
			} 
		}
		else if(a[i] == 0) // a[i] is zero
		{
			zeroi = i;
			if(++n_zero > 1) return 0;
		}
		else // a[i] is positive
		{
			n_pos++;
			if(minpos == 0)
			{
				minpos = a[i];
				minposi = i;
			}
			else if(minpos > a[i])
			{
				minpos = a[i];
				minposi = i;
			}
		}
	}
 
 	if (n_zero){
 		printf("zeros.\n");
 		if (n_neg & 1)
 			return 0;
 		else
 			out = zeroi;
 	}
 	else {
 		printf("no zero.\n");
 		if (n_neg & 1)
 			out = maxnegi;
 		else if (n_pos == 0){
 			out = minnegi;
 		}
 		else {
 			out = minposi;
 		}
 	}
		
	for(int i = 0; i < n; i++)
	{
		max *= (i == out) ? 1 : a[i];
	}
	return max;
}


void show(int a[],int n)
{
	for(int i = 0; i < n; i++){
		printf("%-3d",a[i]);
	}
	printf("\n");
}
int main()
{
	int a[6];
	int N = 6;
	srand(time(NULL));
	for(int i = 0; i < N; i++){
		a[i] = rand() % 10 ; 
		if (a[i] & 0x1)
			a[i] = -a[i];
	}
	show(a,N);
	printf("Max Sub Product of N-1 elements: %d .\n",MaxSubProducti(a,N));
	printf("Max Sub Product of N-1 elements: %d .\n",MaxSubProductii(a,N));
	printf("Max Sub Product of N-1 elements: %d .\n",MaxSubProductiii(a,N));
	printf("Max Sub Product of N-1 elements: %d .\n",MaxSubProductiv(a,N));
	printf("Max Sub Product of N-1 elements: %d .\n",MaxSubProductv(a,N));
}

测试输出： 

2  -5 -5 -5 -7 2  
Max Sub Product of N-1 elements: 1750 .
Max Sub Product of N-1 elements: 1750 .
Max Sub Product of N-1 elements: 1750 .
no zero and even negatives
Max Sub Product of N-1 elements: 1750 .
no zero.
Max Sub Product of N-1 elements: 1750 .


REF:

1，编程之美 2.13



Scandinavians
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法 子数组最大乘积
04-04
算法 子数组最大乘积
子数组最大乘积
qq_43774324的博客
03-10 566
题目：给定一个double类型的数组arr，其中的元素可正可负可0，返回子数组累乘的最大乘积。 例如：[-2.5,4,0,3,0.5,8,-1]其中子数组[3,0.5,8]的乘积最大，为12； 算法思想：创建新的double型变量：max，min，MAX。当数组记录到i位置时，此时max记录（arr[i]，max*arr[i],min*arr[i]）其中的最大值。 min记录（arr[i]，max*arr[i]，min*arr[i]）中的最小值，记录最小值的目的是：当min为负数时且arr[i]为负数
NC83 子数组最大乘积
weixin_43310882
07-22 153
NC83 子数组最大乘积 本题要求最大子序积，是【最大子序和】的加强版，动态规划是最优解法。 在最大子序和中，状态转移方程为： f(i)=max{f(i−1)+arr[i], arr[i]} f(i)是数组的局部最大子序和，求出最大的f(i)即可。 最大子序积中，需要考虑负数的问题，因为一个负数乘以一个负数可能会变为最大值。于是我们维护局部最大值fmax(i)和局部最小值fmin(i),状态转移方程如下： fmax(i) = max{fmax(i-1)*arr[i], fmin(i-1)*arr[i], a
（20）连续子数组最大乘积
最新发布
泰狮N的博客
03-23 285
【代码】（20）连续子数组最大乘积。
每日一算法：子数组最大乘积
danepk的博客
09-07 143
给定一个double类型的数组arr，其中的元素可正可负可0，返回子数组累乘的最大乘积。例如arr=[-2.5，4，0，3，0.5，8，-1]，子数组[3，0.5，8]累乘可以获得最大的乘积12，所以返回12。 public class maxProduct{ public double maxProduct(double[] arr) { if(arr == null || arr.length <= 0){ return 0.0; }
LeetCode 152. Maximum Product Subarray--连续子数组最大乘积、最小乘积-动态规划dp[j] = dp[j] * nums[i]
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
08-23 506
Find the contiguous subarray within an array (containing at least one number) which has the largest product. For example, given the array[2,3,-2,4], the contiguous subarray[2,3]has the largest ...
DP-LeetCode152. 乘积最大子数组（Python）
12-21
给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字）。 2、代码详解 法一：可扩展性好（推荐） 二维数组，2*2大小，一维存最大值，一维存负最大值 class Solution(object)...
最大子数组乘积
10-04
给定一个n个元素的数组,数组元素全部为整数，负数，正数和0均有可能存在，设设计一个算法，找出连续的几个数组元素相乘积最大
乘积最大子数组（动态规划）1
08-03
示例 1:输入: [2,3,-2,4]输出: 6解释: 子数组 [2,3] 有最大乘积 6。示例 2:输入: [-2,0,-1]输出: 0解释: 结果不能为 2
利用Matlab实现二叉树的树形显示
热门推荐
flyapy
07-03 1万+
接文章《求二叉树的高度以及二叉树的树形显示》，当求出erweiju
寻找主元素(高效算法)
flyapy
06-24 4776
关于这种主元素还有种更加巧妙地方法，没看到过一定想不到的。这种方法的原理是如果一个数组中存在一个主元素（个数大于n/2），则同时删除两个不相等的值，这个主元素不会改变。 简单的说就一个大小为n数组中存在一个元素的个数大于n/2，则如果用这个数组中其他元素和该主元素进行抵消的话，最后剩下的一定是主元素，因为主元素个数最多。 该方法可以在O(n)的时间内找到主元素，十分高效。 代码：
2-3-4树与红黑树的对应关系
flyapy
07-09 3835
2-3-4树和红黑树之间
单源多目标最短路径之Dijkstra算法
flyapy
06-29 2606
Dijkstra算法（单源最短路径）       单源最短路径问题，即在图中求出给定顶点到其它任一顶点的最短路径。在弄清楚如何求算单源最短路径问题之前，必须弄清楚最短路径的最优子结构性质。 一.最短路径的最优子结构性质    该性质描述为：如果P(i,j)={Vi....Vk..Vs...Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么P(k,s)必定是从k到s的最短路
打印二叉树根结点到所有叶子结点的路径
flyapy
07-06 1962
打印路径的思路：利用yig
控制台的二叉树树形显示
flyapy
07-04 1851
在文章《求二叉树的高度以及二叉树的树形显示》中，显示的结点的下一行de
二叉树的后序遍历(非递归算法)
flyapy
06-27 1837
可以巧妙的用两个栈来实现后序遍历的非递归算法。注意到后序遍历可以看作是下面遍历的逆过程：即先遍历某个结点，然后遍历其右孩子，然后遍历其左孩子。这个过程逆过来就是后序遍历。算法步骤如下： Push根结点到第一个栈s中。 从第一个栈s中Pop出一个结点，并将其Push到第二个栈output中。然后Push结点的左孩子和右孩子到第一个栈s中。 重复过程2和3直到栈s为空。 完成后
两个字符串的最长公共子序列(可以不连续)
flyapy
07-01 1269
问题：给定两个字符串，输出其最长公共子序列及其长度。 解法：此问题为动态规划的经典问题。解题有固定套路利用二维数组C，和标志位数组FLAG（表示回溯方向）： 步骤一：构建二维数组，求得最长公共子序列的长度。 步骤二：利用数组C构建数组FLAG。 步骤三：利用初始字符串和FLAG回溯输出最长公共子序列。 数组C的构建方式： 回溯输出最长公共子序列过程： 上图中的箭头即为
图的深度优先遍历(邻接表存储)
flyapy
06-28 1269
深度优先遍历的思路：从源点开始，标记源点，
归并排序的迭代算法
flyapy
05-12 1258
在归并算法的迭代算法中，可以把输入看成是n个已排列序列，qizho
错误 1 error C2039: “max”: 不是“std”的成员 c:\users\xunuo\documents\visual studio 2013\projects\连续子数组最大乘积\连续子数组最大乘积\源.cpp 16 1 连续子数组最大乘积
03-19
这个错误是由于在代码中使用了"max"函数，但是编译器无法找到该函数的定义。根据错误提示，这个函数不是"std"命名空间的成员。 解决这个问题的方法是使用正确的命名空间来调用"max"函数。在C++中，"max"函数位于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值