子数组的最大乘积---编程之美

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

题目：

给定一个长度为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[N],假设这样思考假设去除第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[N]
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[N]则p[i] = f[i-1]*r[i+1]。

long long LevelTwo(const int *d, unsigned int n)
{
  int *f = new int [n];
  int *r = new int [n];
  long long *p = new long long [n];
  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;
}