longessumSubArray DP

/*
Copyright personal all reversed
Author   Steven
Date   2011-06-28
description:
            input :
          number array(positive and negative) in any sequence.
   output
          the sum of the longest subArray which the sequence  must be continue .

Algorithm description:
                     use the thought of the recursion(准确说是分治). The longest sequence must in only left part or in right side
      or both side.
                     if we use non-algorithm. we may enum all the possibilities. Enum the start point and the end point Cn2 = n*(n-1) +n
                     Calculate the result need n. we need O(n3)
      分治每次可以二分，复杂度降低到logn 计算复杂度还是N 故总体复杂度n*logn
*/
#include <stdio.h>
#include <stdlib.h>
//[a,b)
int  RecursionSum(int* pArray,int start,int end)
{
 int sum = 0;                         
 if(end - start == 1)                                           // single point can return directly

  return pArray[start];
 int middleNum = (end + start)/2;                             // calculate the middle point
  int left   = RecursionSum(pArray, start, middleNum) ;      // longest subArray in left part
 int right  = RecursionSum(pArray, middleNum, end);
 if(left > right)
  sum = left;
    else
  sum = right;
 int leftSum = pArray[middleNum-1];
 int tempSum = 0;
 //================ longest subArray is  both in left part and right part==========================//
 //left side
 for(int index = middleNum-1; index >= start; index--)
 {
  tempSum = tempSum + pArray[index];
  
  if(leftSum <= tempSum)
  {
   leftSum = tempSum;
  }
 }
 int righttSum = pArray[middleNum];
 tempSum = 0;
 // right side
 for(index = middleNum; index < end;index++)
 {
  tempSum = tempSum + pArray[index];
  if(righttSum <= tempSum)
  {
   righttSum = tempSum;
  }
 }
 
    int LrSum = leftSum + righttSum;
 if(LrSum  >  sum)
 {
  return LrSum;
 }
 else
  return sum;
}
// 动态规划求解。时间复杂度O(n) 求状态的时候算法是O(n),枚举状态算法是O(n)
int DynamicRecursion(int* pArray,int size,int ranges)
{
    int longestSubArray[10];
 for(int j=0;j<size;j++) longestSubArray[j]=-1;
 int sum =0;
 for(int index=1;index<ranges;index++)
    {
        if(longestSubArray[index-1]==-1)// not be stored
  {
   // calculate and store
            int subSum = 0;
   int tempSum =0;
   for(int i=index;i>=1;i--)
   {
               tempSum = tempSum + pArray[i];
      if(subSum < tempSum)
      {
       subSum = tempSum;
      }
   }
   // store
   longestSubArray[index] = subSum;

  }
  else
  {
   // how to write this code?
   if(longestSubArray[index-1]<0)
   {
    longestSubArray[index] = pArray[index];
   }
   else
              longestSubArray[index] = longestSubArray[index-1] + pArray[index];
  }
  
 }
 int sum2 =0;
 for(int i=0;i<ranges;i++)
 {
     if(sum2 < longestSubArray[i])
   sum2 = longestSubArray[i];
 }
 return sum2;
}
int main()
{
 int nArray[11]={0,1,2,3,-100,5,6,7,8,9};
 int sum = RecursionSum(nArray,0,10);
 int sum2 = DynamicRecursion(nArray,10,10);
 printf("%d",sum2);
 system("pause");
 return 0;
}