子数组的最大乘积

题目：

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

方法一：

最简单的计算就是把所有N-1个数的组合全找出来，共有C(N, N-1) = N 种情况，所以算法的复杂度为Ο(N2)。




方法一

#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

long long LevelOne(const int *d, unsigned int n)
{
long long ret;
long long max;
int i, j;
for(i=0; i<n; i++)
{
for(j=0, ret=1; j<n; j++)
{
ret *= ((i==j) ? 1 : d[j]);
if(ret == 0) break;
}
max = (i==0 ? ret : max);
max = (max<=ret ? ret : max);
}

return max;
}

int main()
{
const int maxsize = 10;
int data[maxsize];
long long max;

srand(time(NULL));

for(int i=0; i<maxsize; i++)
data[i] = ((rand()%10<2) ? -1:1) * (rand()%10);

for(int i=0; i<maxsize; i++)
cout<<data[i]<<" ";
cout<<endl;

max = LevelOne(data, maxsize);

cout<<"max: "<<max<<endl;

return 0;
}

方法二：

对于数组A
,假设这样思考假设去除第i个元素的乘积可以表示为A[0]*A[1]*…A[i-1] * A[i+1]*A[i+2]*…A[N-1]，则可以写出如下算法满足复杂度为Ο(N)。 1.算出A[0]~A[N-1]，N个元素的乘积赋值给M 2.定义变量i=N-1, R=1,和数组p
3.如果i==0 p[0] = A[0] 返回 4.如果i>=0 重复步骤5 5.M /= A[i]; p[i] = M*R; R *= A[i] 但是本算法使用了除法，而规定不允许，所以可以做个小的调整。设f[i]=A[0]*A[1]*…A[i],
r[i]=A[i]*A[i+1]*…A
则p[i] = f[i-1]*r[i+1]。




方法二

long long LevelTwo(const int *d, unsigned int n)
{
int *f = new int
;
int *r = new int
;
long long *p = new long long
;
long long max;

assert(f!=0 && r!=0 && p!=0);

long long fv=1, rv=1;
for(int i=0; i<n; i++)
{
int j = n-i-1;
fv *= d[i];
rv *= d[j];
f[i] = fv;
r[j] = rv;
}

max = p[0] = r[1];
for(int i=1; i<n; i++)
{
p[i] = f[i-1] * r[i+1];
max = max<p[i] ? p[i] : max;
}

delete [] f;
delete [] r;
delete [] p;

return max;
}

方法三：

虽然以上算法已经将复杂度降到了Ο(N)了，但还是可以进一步减少计算量。子数组最大乘积问题可以分为以下几种情况。

1.数组中有多于一个零则最大乘积为0；

2.数组中只有一个零，而有奇数个负数，则最大乘积必定为0；

3.数组中只有一个零，而有偶数个负数，则最大乘积为除去0的元素的乘积；

4.数组中没有零，而有奇数个负数，则最大乘积为除去绝对值最小的负数的乘积；

5.数组中没有零，而有偶数个负数，则最大乘积为除去最小的正数的乘积。




方法三

long long LevelThree(int *d, int n)
{
int n_zero = 0;
int n_neg = 0;
int maxneg = 0;
int minpos = 0;
int maxnegi = 0;
int minposi = 0;
int zeroi = 0;
int out;
long long max = 1;

for(int i=0; i<n; i++)
{
if(d[i] < 0)
{
n_neg++;
if(maxneg == 0)
{
maxneg = d[i];
maxnegi = i;
}
else if(maxneg<d[i])
{
maxneg = d[i];
maxnegi = i;
}
}
else if(d[i] == 0)
{
zeroi = i;
if(++n_zero>1) return 0;
}
else
{
if(minpos == 0)
{
minpos = d[i];
minposi = i;
}
else if(minpos > d[i])
{
minpos = d[i];
minposi = i;
}
}
}

if(n_zero==1 && n_neg%2==1)
{
return 0;
}
else if(n_zero==1 && n_neg%2==0)
{
out = zeroi;
}
else if(n_zero==0 && n_neg%2==1)
{
out = maxnegi;
}
else if(n_zero==0 && n_neg%2==0)
{
out = minposi;
}

for(int i=0; i<n; i++)
{
max *= (i==out)?1:d[i];
}
return max;
}