题目:
给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。
解法：
实际上第一反应就是先将N个数相乘得到结果，然后遍历每一个数，看去掉哪个数最适合，注意正负号。效率O(N).
但是文章在最后指出不允许用除法的用意是这样的，乘法很容易溢出。意思是干脆乘法也不要用。
文中给出如下几种算法：
源码出自：http://blog.csdn.net/qq120848369/archive/2010/05/12/5583796.aspx
算法一:
枚举每一个不在N-1内的数,分别计算剩余N-1个数的乘积, 由于有N种情况,每种情况遍历计算乘积,所以O(n2).
算法二：
假设第i位不在N-1内,那么需要左边的乘积乘以右边的乘积. 为了优化时间,做预处理,先算出i位左边的乘积与右边的乘积.
这个过程需要2 *n的时间，是线性的。 计算Max也是扫描一遍就得到了，所以算法复杂度n,代码如下：
01.#include <iostream>
02.using namespace std;
03.
04.//全局变量
05.int *num;
06.int *_left;
07.int *_right;
08.
09.void getLeft(int len)
10.{
11. _left[0]=1;
12. for(int i=1;i<len;++i)
13. {
14. _left[i]=_left[i-1]*num[i-1];
15. }
16.}
17.
18.void getRight(int len)
19.{
20. _right[len-1]=1;
21. for(int i=len-2;i>=0;--i)
22. {
23. _right[i]=_right[i+1]*num[i+1];
24. }
25.}
26.
27.int getMax(int len,int &max)
28.{
29. max=_left[0]*_right[0];
30. int pos=0;
31. for(int i=1;i<len;++i)
32. {
33. if(_left[i]*_right[i]>max)
34. {
35. max=_left[i]*_right[i];
36. pos=i;
37. }
38. }
39. return pos;
40.}
41.
42.int main()
43.{
44. int len;
45. cin>>len;
46. num=new int[len];
47. _left=new int[len];
48. _right=new int[len];
49. for(int i=0;i<len;++i)
50. {
51. cin>>num[i];
52. }
53. getLeft(len);
54. getRight(len);
55. int max;
56. cout<<"数组下标："<<getMax(len,max)<<",最大值:";
57. cout<<max<<endl;
58. delete []num;
59. delete []_left;
60. delete []_right;
61. return 0;
62.}
算法3：
计算N个数的乘积为P，然后分P的正负性讨论如下：
1，P==0
说明P中必定至少含有一个0。假设将这个0去掉后得到N-1个元素的乘积为Q。
1.1 Q==0
返回0。说明N个元素中必有至少两个0，所以不管去掉什么元素，N-1个乘积必为0。
1.2 Q为正
返回Q。说明其中再无0了，若之前去掉的不是0，则剩余的N-1个的乘积必为0。小于现在的Q。
1.3 Q为负
返回0,。说明其中再无0了，若之前去掉的不是0，则剩余的N-1个的乘积必为0。大于现在的Q，取大者，所以之前应该保留0。
2，P为负
说明这N个数中无0，并且至少有一个负数。所以只有去掉一个绝对值最小的负数才获得最大乘积Q。并且这个负数必定是存在的。
3，P为正
由于可能负负得正，所以现在应该考虑到应该去掉一个绝对值最小的正数，但是这个正数不一定存在，比如数组-1，-1。所以如果该正数不存在，就应该去掉一个绝对值最大的负数。
同时注意，为了避免乘积溢出，建议只统计符号，计算0，正，负的个数 。
代码：
#include "stdafx.h"
#include<iostream>
#include<stdio.h>
#include<time.h>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
#include<queue>
#include<Windows.h>
using namespace std;
#define MAX 100
int M;
int arr[MAX];
int sig[3];//统计符号0，正，负的个数
int _tmain(int argc, _TCHAR* argv[])
{
//处理输入
cin>>M;
for(int i=0;i<M;i++)
{
cin>>arr[i];
}
memset(sig,0,sizeof(int));
for(int i=0;i<M;i++)
{
if(arr[i]==0)
{
sig[0]++;
}
else if(arr[i]>0)
{
sig[1]++;
}
else
{
sig[2]++;
}
}
if(sig[0]>2||(sig[0]==1&&sig[2]%2==0))//情况1.1 1.2 去掉0
{
for(int i=0;i<M;i++)
{
if(arr[i]==0)
{
cout<<"位置:"<<i<<endl;
break;
}
}
}
else if(sig[0]==1)//情况1.3 Q为负数去掉任意一个都可以
{
for(int i=0;i<M;i++)
{
if(arr[i]!=0)
{
cout<<"位置:"<<i<<endl;
break;
}
}
}
else if(sig[2]%2==1)//情况2 去掉绝对值最小的负数
{
int min=INT_MIN;
int pos=0;
for(int i=0;i<M;i++)
{
if(arr[i]<0&&arr[i]>min)
{
min=arr[i];
pos=i;
}
}
cout<<"位置:"<<pos<<endl;
}
else //情况3
{
//有正数
if(sig[1]>0)
{
int max=INT_MAX;
int pos=0;
for(int i=0;i<M;i++)
{
if(arr[i]>0&&arr[i]<max)
{
max=arr[i];
pos=i;
}
}
cout<<"位置:"<<pos<<endl;
}
else
{
int min=0;
int pos=0;
for(int i=0;i<M;i++)
{
if(arr[i]>0&&abs(arr[i])>min)
{
min=abs(arr[i]);
pos=i;
}
}
cout<<"位置:"<<pos<<endl;
}
}
::system("pause");
return 0;
}
题目：
给定一个长度为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;
}
[] f;
[] r;
[] 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;
}