网易笔试题：求和最大的连续子串

昨晚网易的笔试题中出现了一道之前在网上看过的编程题，早上着手编写测试了一下，题目如下：

给定一整型数字a[]={a[0],...,a[n])},找出连续子串{a[x]),a[x+1],...,a[y]},使得和最大，其中，0<=x<=y<=n。

要求时间复杂度为O（n）

 

解决思路：（1）和最大的子串一定是以数组a中的某一个元素为结束，所以我们分别对每一个元素作为当前子串的结尾计算当前和最大的子串，

              再对计算出的所有子串和进行比较，最大的那个就是解。

（2）计算以元素a（i+1）结尾的和最大的子串：假定以a（i）结尾的和最大子串为L[i]，和为sum[i]，则当sum[i]+a[i+1]>a[i+1],

　　 那L[i+1]为L[i]加上a[i+1]，sum[i+1]=sum[i]+a[i+1]；否则L[i+1]为a[i]，sum[i+1]=a[i+1]；为什么这样？注意“连续”，也就是说

      以a[i+1]结尾的子串必定包含a[i+1]，那和最大的子串L[i+1]只能是a[i+1]或者L[i]加上a[i+1]，显然，sum[i]+a[i+1]>a[i+1]则不取a[i+1]而

      取L[i]加上a[i+1]，否则就取a[i+1];

 

代码如下：

 

代码

   
     

    
      
    
      struct
    
       SubMax
    
      //
    
      最大和的子串
    
      

    
      {
 
    
      int
    
       start;
    
      //
    
      子串开始位置
    
      

    
       
    
      int
    
       end;
    
      //
    
      子串结束位置
    
      

    
       
    
      int
    
       sum;
    
      //
    
      和
    
      

    
      };
SubMax maxsub(
    
      int
    
       a[],
    
      int
    
       size)
{


 
    
      int
    
       
    
      **
    
      sub
    
      =
    
      new
    
       
    
      int
    
      *
    
      [size];//以所有元素为结尾的最大子串信息数组，共size个一维数组，
   
     
   
     

    
      //每个一维数组含3个元素，0下标子串为开始位置，1下标为结束位置，2下标为和
 
    
      for
    
      (
    
      int
    
       k
    
      =
    
      0
    
      ;k
    
      <
    
      size;k
    
      ++
    
      )
 {
 sub[k]
    
      =
    
      new
    
       
    
      int
    
      [
    
      3
    
      ];
 }

 sub[
    
      0
    
      ][
    
      0
    
      ]
    
      =
    
      0
    
      ;
 sub[
    
      0
    
      ][
    
      1
    
      ]
    
      =
    
      0
    
      ;
 sub[
    
      0
    
      ][
    
      2
    
      ]
    
      =
    
      a[
    
      0
    
      ];
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      0
    
      ;i
    
      <
    
      size
    
      -
    
      1
    
      ;i
    
      ++
    
      )
 {
 
    
      if
    
      (sub[i][
    
      2
    
      ]
    
      +
    
      a[i
    
      +
    
      1
    
      ]
    
      >
    
      a[i
    
      +
    
      1
    
      ])
 {
 sub[i
    
      +
    
      1
    
      ][
    
      0
    
      ]
    
      =
    
      sub[i][
    
      0
    
      ];
 sub[i
    
      +
    
      1
    
      ][
    
      1
    
      ]
    
      =
    
      i
    
      +
    
      1
    
      ;
 sub[i
    
      +
    
      1
    
      ][
    
      2
    
      ]
    
      =
    
      sub[i][
    
      2
    
      ]
    
      +
    
      a[i
    
      +
    
      1
    
      ];
 }
 
    
      else
    
      
 {
 sub[i
    
      +
    
      1
    
      ][
    
      0
    
      ]
    
      =
    
      i
    
      +
    
      1
    
      ;
 sub[i
    
      +
    
      1
    
      ][
    
      1
    
      ]
    
      =
    
      i
    
      +
    
      1
    
      ;
 sub[i
    
      +
    
      1
    
      ][
    
      2
    
      ]
    
      =
    
      a[i
    
      +
    
      1
    
      ];
 }
 }
 
    
      int
    
       max_sub
    
      =
    
      0
    
      ;
 
    
      int
    
       maxsubsum
    
      =
    
      0
    
      ;
 
    
      for
    
      (
    
      int
    
       j
    
      =
    
      0
    
      ;j
    
      <
    
      size;j
    
      ++
    
      )
 {
 
    
      if
    
      (sub[j][
    
      2
    
      ]
    
      >
    
      maxsubsum)
 {
 maxsubsum
    
      =
    
      sub[j][
    
      2
    
      ];
 max_sub
    
      =
    
      j;
 }
 }
 SubMax s;
 s.start
    
      =
    
      sub[max_sub][
    
      0
    
      ];
 s.end
    
      =
    
      sub[max_sub][
    
      1
    
      ];
 s.sum
    
      =
    
      sub[max_sub][
    
      2
    
      ];
 
    
      for
    
      (
    
      int
    
       m
    
      =
    
      0
    
      ;m
    
      <
    
      size;m
    
      ++
    
      )
 {
 delete sub[m];
 }
 
    
      return
    
       s;
}


    
      int
    
       main()
{
 
    
      int
    
       a[]
    
      =
    
      {
    
      -
    
      3
    
      ,
    
      5
    
      ,
    
      2
    
      ,
    
      1
    
      ,
    
      7
    
      ,
    
      -
    
      9
    
      ,
    
      5
    
      ,
    
      3
    
      ,
    
      23
    
      ,
    
      -
    
      111
    
      ,
    
      3
    
      ,
    
      7
    
      };
 SubMax s
    
      =
    
      maxsub(a,
    
      12
    
      );
 cout
    
      <<
    
      "
    
      连续子串最大的和：
    
      "
    
      <<
    
      s.sum
    
      <<
    
      endl;
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      s.start;i
    
      <=
    
      s.end;i
    
      ++
    
      )
 {
 cout
    
      <<
    
      a[i]
    
      <<
    
      "
    
       
    
      "
    
      ;
 }
 cout
    
      <<
    
      endl;
}