Find longest contiguous sub array

　　It's still an Amazon interview question.

　　Given an array containing only stars '*' and hashes '#' . Find longest contiguous sub array that will contain equal no. of stars '*' and hashes '#'.Output the index range if the longest contiguous sub array does exist or else output -1 and -1,which denote no corresponding contiguous sub array exist.

　　Think for a while......

　　Typical DP-solved question.Every time I scan the sub array,I can use something that has been done.Say when I want to scan [2,6] in the original array,I should know the information about [2,5] in advance.So we can scan the array by length.The code is below.Time:O(n³),Space:O(n²),(n denotes the length of the array).

 /*************************************************
 Author:Zhou You
 Time:2014.09.09
 *************************************************/
 #include <iostream>
 #include <cstdio>

 using namespace std;

 struct matrix_element
 {
 public:
     matrix_element():
         star_num_(),
         hash_num_(){}

     matrix_element(unsigned star_num,unsigned hash_num):
         star_num_(star_num),
         hash_num_(hash_num){
     }

     unsigned star_num_;
     unsigned hash_num_;
 };

 void BuildMatrix(matrix_element *** pmaze,unsigned row_num,unsigned column_num)
 {
     *pmaze = new matrix_element*[row_num];
     for(unsigned i=;i<row_num;++i){
         (*pmaze)[i] = new matrix_element[column_num];
     }
 }

 void ReleaseMatrix(matrix_element ***pmaze,unsigned row_num)
 {
     if(!pmaze) return;

     for(unsigned i=;i<row_num;++i){
         delete [](*pmaze)[i];
     }

     delete [](*pmaze);
 }

 void CoreSolve(char **parray,unsigned element_num)
 {
     matrix_element **pnote = NULL;
     BuildMatrix(&pnote,element_num,element_num);

     for(unsigned i=;i<element_num;++i){
         if((*parray)[i]=='*'){
             ++pnote[i][i].star_num_;
         }else if((*parray)[i]=='#'){
             ++pnote[i][i].hash_num_;
         }
     }

     int index_start = -,index_end = -;
     unsigned cur_length = ;

     for(unsigned sub_array_length = ;sub_array_length<=element_num;++sub_array_length){
         for(unsigned i=;i<=element_num-sub_array_length;++i){
             pnote[i][i+sub_array_length-].hash_num_ =
             pnote[i][i+sub_array_length-].hash_num_+
             pnote[i+sub_array_length-][i+sub_array_length-].hash_num_;

             pnote[i][i+sub_array_length-].star_num_ =
             pnote[i][i+sub_array_length-].star_num_+
             pnote[i+sub_array_length-][i+sub_array_length-].star_num_;

             if(pnote[i][i+sub_array_length-].star_num_==
                pnote[i][i+sub_array_length-].hash_num_){
                 if(sub_array_length>cur_length){
                     cur_length = sub_array_length;
                     index_start = i;
                     index_end = i+sub_array_length-;
                 }
             }
         }
     }

     cout<<index_start<<" "<<index_end;

     ReleaseMatrix(&pnote,element_num);
 }

 void Solve()
 {
     unsigned element_num = ;
     cin>>element_num;

     char *parray = new char[element_num];
     for(unsigned i=;i<element_num;++i){
         cin>>parray[i];
     }

     CoreSolve(&parray,element_num);
     delete []parray;
 }

 int main()
 {
     freopen("data.in","r",stdin);
     freopen("data.out","w",stdout);

     unsigned case_num = ;
     cin>>case_num;

     for(unsigned i=;i<=case_num;++i){
         cout<<"Case #"<<i<<" ";
         Solve();
         cout<<endl;
     }

     return ;
 }

　　Case in data.in file

5
4
*#*#
4
*#**
5
*****
6
*###**
12
****###*****

　　Output data in data.out file

Case #1 0 3
Case #2 0 1
Case #3 -1 -1
Case #4 0 5
Case #5 1 6