实现子数组的最大乘积

#ifndef CALC_H
#define CALC_H


class CCalc
{
private:
    //数组的首地址
    int* m_pArray;

    //数组的长度
    int m_length;

    int* m_pBeginArray;

    int* m_pBehindArray;

    int* m_pCalcArray;

public:

    CCalc();
    CCalc(int size);
    ~CCalc();

    //初始化数组
    void Init();
    void Init(int* pArray, int length);

    //返回数组的首地址
    int* GetPtrArray() const;

    //返回数组前n个元素的乘积s[i]首地址
    int* GetBeginPtrArray() const;

    //返回数组后n个元素的乘积t[i]首地址
    int* GetBehindPtrArray() const;

    //返回结果数组
    int* GetAnsArray() const;

    //返回数组的长度
    int GetArrayLength() const;

    //计算s[i]
    int CalcBeginSubArray(int* pArray,int length); 

    //计算t[i]
    int CalcBehindSubArray(int* pArray,int length);

    //计算p[i]
    void CalcArrayMul();

    //获取数组的最大值
    int CalcMaxFromArray(int* pArray, int length);
};

#endif










#include "Calc.h"
#include <time.h>
#include <iostream>

CCalc::CCalc()
{
    this->m_length = 10;
    this->m_pArray = new int[this->m_length];
    this->m_pBeginArray = new int[this->m_length];
    this->m_pBehindArray = new int[this->m_length];
    this->m_pCalcArray = new int[this->m_length];
}

CCalc::CCalc(int size)
{
    this->m_length = size;
    this->m_pArray = new int[this->m_length];
    this->m_pBeginArray = new int[this->m_length];
    this->m_pBehindArray = new int[this->m_length];
    this->m_pCalcArray = new int[this->m_length];
}

CCalc::~CCalc()
{
    delete[] this->m_pArray;
    this->m_pArray = NULL;
}

void CCalc::Init()
{
    srand((int) time(0));
    for(int i = 0; i < this->m_length; i++)
    {
        this->m_pArray[i] = 1 + (int)(10.0 * rand() / (RAND_MAX + 1.0));//产生10以内的随机数
    }
}

void CCalc::Init(int* pArray, int length)
{
    if(this->m_pArray != NULL)
    {
        delete[] m_pArray;
        this->m_pArray = NULL;
    }

    this->m_length = length;
    this->m_pArray = new int[this->m_length];
    for(int i=0;i<length;i++)
    {
        this->m_pArray[i] = pArray[i];
    }
}

int* CCalc::GetPtrArray() const
{
    return this->m_pArray;
}

int* CCalc::GetBeginPtrArray() const
{
    return this->m_pBeginArray;
}

int* CCalc::GetBehindPtrArray() const
{
    return this->m_pBehindArray;
}

int CCalc::GetArrayLength() const
{
    return this->m_length;
}

int* CCalc::GetAnsArray() const
{
    return this->m_pCalcArray;
}

int CCalc::CalcBeginSubArray(int* pArray,int length)
{
    if(length < 0)
    {
        return -1;
    }

    this->m_pBeginArray[0] = 1;

    for(int i=1;i<length;i++)
    {
        this->m_pBeginArray[i] = this->m_pBeginArray[i-1] * pArray[i-1];
    }

    return 0;
}

int CCalc::CalcBehindSubArray(int* pArray,int length)
{
    if(length < 0)
    {
        return -1;
    }

    this->m_pBehindArray[length-1] = 1;

    for(int i=length-2;i>=0;i--)
    {
        this->m_pBehindArray[i] = this->m_pBehindArray[i+1] * pArray[i+1];
    }

    return 0;
}

void CCalc::CalcArrayMul()
{
    this->CalcBeginSubArray(this->m_pArray,this->m_length);

    this->CalcBehindSubArray(this->m_pArray,this->m_length);

    for(int i=0;i<this->m_length;i++)
    {
        this->m_pCalcArray[i] = (this->GetBeginPtrArray())[i] * (this->GetBehindPtrArray())[i];
    }
}

int CCalc::CalcMaxFromArray(int* pArray, int length)
{
    int max = pArray[0];

    for(int i=0;i<length;i++)
    {
        if(max < pArray[i])
        {
            max = pArray[i];
        }
    }

    return max;
}









#include <gtest/gtest.h>
#include <time.h>
#include <iostream>
using namespace std;

#include "Calc.h"

class  CCalcTest: public  testing::Test
{
protected :
    virtual void  SetUp()
    {
        m_calc = new CCalc();

        m_calc->Init();
    }
    virtual void TearDown()
    {
        delete m_calc;
        m_calc = NULL;
    }
public:
    CCalc* m_calc;
};

//测试对数组的初始化
TEST_F(CCalcTest,InitRight)
{
    int* ptrArray = m_calc->GetPtrArray();
    for(int i=0;i<10;i++)
    {
        EXPECT_GE(10,ptrArray[i]);
        EXPECT_LE(1,ptrArray[i]);
    }
}

TEST_F(CCalcTest,CalcBeginSubArray)
{
    int array1[1] = {2};
    m_calc->CalcBeginSubArray(array1,sizeof(array1)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBeginPtrArray())[0]);

    int array2[4] = {3,2,3,4};
    m_calc->CalcBeginSubArray(array2,sizeof(array2)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBeginPtrArray())[0]);
    EXPECT_EQ(3,(m_calc->GetBeginPtrArray())[1]);
    EXPECT_EQ(6,(m_calc->GetBeginPtrArray())[2]);
    EXPECT_EQ(18,(m_calc->GetBeginPtrArray())[3]);
}

TEST_F(CCalcTest,CalcBehindSubArray)
{
    int array1[1] = {2};
    m_calc->CalcBehindSubArray(array1,sizeof(array1)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBehindPtrArray())[0]);

    int array2[4] = {2,2,3,4};
    m_calc->CalcBehindSubArray(array2,sizeof(array2)/sizeof(int));
    EXPECT_EQ(24,(m_calc->GetBehindPtrArray())[0]);
    EXPECT_EQ(12,(m_calc->GetBehindPtrArray())[1]);
    EXPECT_EQ(4,(m_calc->GetBehindPtrArray())[2]);
    EXPECT_EQ(1,(m_calc->GetBehindPtrArray())[3]);
}

TEST_F(CCalcTest,CalcArrayMul)
{
    int array[4] = {2,2,3,4};
    m_calc->Init(array,4);
    m_calc->CalcArrayMul();
    EXPECT_EQ(24,(m_calc->GetAnsArray())[0]);
    EXPECT_EQ(24,(m_calc->GetAnsArray())[1]);
    EXPECT_EQ(16,(m_calc->GetAnsArray())[2]);
    EXPECT_EQ(12,(m_calc->GetAnsArray())[3]);
}

TEST_F(CCalcTest, CalcMaxFromArray)
{
    int array[4] = {2,2,3,4};
    EXPECT_EQ(4,m_calc->CalcMaxFromArray(array, 4));
}

TEST_F(CCalcTest,CalcALL)
{
    int array1[4] = {2,2,3,4};
    m_calc->Init(array1,4);
    m_calc->CalcArrayMul();
    EXPECT_EQ(24,m_calc->CalcMaxFromArray(m_calc->GetAnsArray(), 4));

    int array2[6] = {1,-1,2,2,3,4};
    m_calc->Init(array2,6);
    m_calc->CalcArrayMul();
    EXPECT_EQ(48,m_calc->CalcMaxFromArray(m_calc->GetAnsArray(), 6));
}

int main(int argc,char* argv[])
{
    testing::InitGoogleTest(&argc, argv);

    return  RUN_ALL_TESTS();
}

 

问题描述：

给定一个长度为N的整数数组，只允许用乘法，不能用除法，计算任意(N-1)个数的组合乘积中的最大的一组。

 

算法描述：

设array为初始数组，s[i]表示数组前i个元素的乘积s[i]=s[i-1]*array[i-1].t[i]表示数组后(N-i)个元素的乘积t[i]=t[i+1]*array[i+1]

设p[i]为数组除第i个元素外，其它N-1个元素的乘积，即有：

p[i]=s[i-1]*t[i+1]

求出p[i]的最大值，即该题目的解

 

写测试用例：(测试用例框架用的是google的GTest)

• 对测试case进行初始化： 

 

• 测试数组的初始化：

TEST_F(CCalcTest,InitRight)
{
    int* ptrArray = m_calc->GetPtrArray();
    for(int i=0;i<10;i++)
    {
        EXPECT_GE(10,ptrArray[i]);
        EXPECT_LE(1,ptrArray[i]);
    }
}

 

• 测试获取s[i]

TEST_F(CCalcTest,CalcBeginSubArray)
{
    int array1[1] = {2};
    m_calc->CalcBeginSubArray(array1,sizeof(array1)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBeginPtrArray())[0]);

    int array2[4] = {3,2,3,4};
    m_calc->CalcBeginSubArray(array2,sizeof(array2)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBeginPtrArray())[0]);
    EXPECT_EQ(3,(m_calc->GetBeginPtrArray())[1]);
    EXPECT_EQ(6,(m_calc->GetBeginPtrArray())[2]);
    EXPECT_EQ(18,(m_calc->GetBeginPtrArray())[3]);
}

 

• 测试获取t[i]

TEST_F(CCalcTest,CalcBehindSubArray)
{
    int array1[1] = {2};
    m_calc->CalcBehindSubArray(array1,sizeof(array1)/sizeof(int));
    EXPECT_EQ(1,(m_calc->GetBehindPtrArray())[0]);

    int array2[4] = {2,2,3,4};
    m_calc->CalcBehindSubArray(array2,sizeof(array2)/sizeof(int));
    EXPECT_EQ(24,(m_calc->GetBehindPtrArray())[0]);
    EXPECT_EQ(12,(m_calc->GetBehindPtrArray())[1]);
    EXPECT_EQ(4,(m_calc->GetBehindPtrArray())[2]);
    EXPECT_EQ(1,(m_calc->GetBehindPtrArray())[3]);
}

 

• 测试获取p[i]

TEST_F(CCalcTest,CalcArrayMul)
{
    int array[4] = {2,2,3,4};
    m_calc->Init(array,4);
    m_calc->CalcArrayMul();
    EXPECT_EQ(24,(m_calc->GetAnsArray())[0]);
    EXPECT_EQ(24,(m_calc->GetAnsArray())[1]);
    EXPECT_EQ(16,(m_calc->GetAnsArray())[2]);
    EXPECT_EQ(12,(m_calc->GetAnsArray())[3]);
}

 

• 测试获取数组最大值

TEST_F(CCalcTest, CalcMaxFromArray)
{
    int array[4] = {2,2,3,4};
    EXPECT_EQ(4,m_calc->CalcMaxFromArray(array, 4));
}

 

• 整合到一起测试

TEST_F(CCalcTest,CalcALL)
{
    int array1[4] = {2,2,3,4};
    m_calc->Init(array1,4);
    m_calc->CalcArrayMul();
    EXPECT_EQ(24,m_calc->CalcMaxFromArray(m_calc->GetAnsArray(), 4));

    int array2[6] = {1,-1,2,2,3,4};
    m_calc->Init(array2,6);
    m_calc->CalcArrayMul();
    EXPECT_EQ(48,m_calc->CalcMaxFromArray(m_calc->GetAnsArray(), 6));
}

 

 

 所有程序代码：

 

#ifndef CALC_H

#define CALC_H

class CCalc

{

private:

//数组的首地址

int* m_pArray;

//数组的长度

int m_length;

int* m_pBeginArray;

int* m_pBehindArray;

int* m_pCalcArray;

public:

CCalc();

CCalc(int size);

~CCalc();

//初始化数组

void Init();

void Init(int* pArray, int length);

//返回数组的首地址

int* GetPtrArray() const;

//返回数组前n个元素的乘积s[i]首地址

int* GetBeginPtrArray() const;

//返回数组后n个元素的乘积t[i]首地址

int* GetBehindPtrArray() const;

//返回结果数组

int* GetAnsArray() const;

//返回数组的长度

int GetArrayLength() const;

//计算s[i]

int CalcBeginSubArray(int* pArray,int length); 

//计算t[i]

int CalcBehindSubArray(int* pArray,int length);

//计算p[i]

void CalcArrayMul();

//获取数组的最大值

int CalcMaxFromArray(int* pArray, int length);

};

#endif