Bootstrap

连续子串的最大值(经典的DP问题)

【问题描述】 
在长度为N的整形数组中，求连续子串的和的最大值，要求复杂度为O(N)。
例如：1 2 3 -1 -20 100 34，结果为134。

【分析】 
[思路一] 
自己最初的想法，利用回溯的思想，从下标为0的元素开始遍历，用former保存当前最大的连续子集的和，当sum小于0的时候开始回溯，即删除这个元素，删除到已遍历数组最右边的那个正整数为止(用下标j标识)。事后觉得这个算法比较复杂，因为要维护下标j的指向，以及还要单独求出数组中的最大值，并最后与former进行比较。因此这个算法只是实现了功能，此算法的效率和代码量都不好。

  1. #include <cstdio>  
  2. #include <cassert>  
  3. int MaxAdjVal(int a[], int len)  
  4. {  
  5.     int sum=0, maxval=a[0], former=0;  
  6.     assert(len);// check  
  7.     for (int i=0,j=0,i_tmp,flag=true; i<len; ++i)  
  8.     {  
  9.         maxval<a[i] ? maxval=a[i] : NULL;// save biggest value  
  10.         if (a[i]<0 && flag)  
  11.         {  
  12.             j=i-1;// index of last positive number  
  13.             flag=false;  
  14.         }  
  15.         a[i]>0 ? flag=true : NULL;  
  16.         sum+=a[i];  
  17.         if (sum<=0)  
  18.         {  
  19.             sum-=a[i];// get rid of this element  
  20.             i_tmp=i;  
  21.             while (--i_tmp>j && sum>0)  
  22.             {  
  23.                 sum-=a[i_tmp];  
  24.             }  
  25.             if (former<sum)  
  26.             {  
  27.                 former=sum;  
  28.             }                 
  29.             sum=0;// reset  
  30.         }  
  31.     }  
  32.     return maxval>0 ? (sum>former? sum:former) : maxval;  
  33. }  
  34. int main()  
  35. {  
  36.     int a[100]={0}, i=0, res=0;  
  37.     printf("Enter some numbers (Ctrl+z to end):/n");  
  38.     while((1==scanf("%d",&a[i])) && ++i<100);  
  39.     rewind(stdin);  
  40.     res=MaxAdjVal(a,i);  
  41.     printf("%d/n",res);  
  42.     return 0;  
  43. }  

 

[思路二] 
思路二对算法进行了简化，不采用回溯，只用maxsum保存当前最大的连续子集的和，如果数组全为负数，找一个最大值就可以了。注意当cursum小于0的时候，要将cursum置为0。
一个无序的数组，找出相邻的任意个元素，使得其和最大。要得O(n)的复杂度，顺序读取，任意步骤都是当前读取的序列判断最优解，此谓联机算法。(参考：http://blog.csdn.net/hairetz/archive/2009/10/15/4676994.aspx )
用vector可以描述如下：

  1. int maxsubsum(const vector<int>& vec)  
  2. {  
  3.     int maxsum = 0, cursum = 0;  
  4.     for (int i = 0; i < vec.size(); ++i)   
  5.     {  
  6.         cursum += vec[i];  
  7.         if (cursum > maxsum)  
  8.             maxsum = cursum;  
  9.         else if (cursum < 0)  
  10.             cursum = 0;  
  11.     }  
  12.     return maxsum;  
  13. }  

用C语言描述如下：

  1. #include <cstdio>  
  2. #include <cassert>  
  3. int MaxAdjVal(int a[], int len)  
  4. {  
  5.     assert(len);// check  
  6.     int sum=0, max=a[0];  
  7.     for(int i=0; i<len; ++i)  
  8.     {  
  9.         sum+=a[i];  
  10.         if (sum>max)  
  11.             max=sum;  
  12.         if (sum<0)  
  13.             sum=0;  
  14.     }  
  15.     return max;  
  16. }  
  17. int main()  
  18. {  
  19.     int a[100]={0}, i=0, res=0;  
  20.     printf("Enter some numbers (Ctrl+z to end):/n");  
  21.     while((1==scanf("%d",&a[i])) && ++i<100);  
  22.     rewind(stdin);  
  23.     res=MaxAdjVal(a,i);  
  24.     printf("%d/n",res);  
  25.     return 0;  
  26. }  

【问题扩展】 
1. 问这样的子串有多少个。
2. 如果是首尾相连的，那么最大子串和是多少，有多少个。
3. 如果是首尾相连的，取两个不相交子串，那么最大子串和是多少。
4. 若存在多个最大子串和，则输出第一个最大子串和的起始和终止下标。

【参考】 
(1) 经典的DP问题。
请参考这道ACM题：http://acm.hdu.edu.cn/showproblem.php?pid=1003

  1. #include <iostream>  
  2. using namespace std;  
  3. void MaxSub(int *arr, int count, int &first, int &last, int ∑);  
  4. int main()  
  5. {  
  6.     int num, n, i, j;  
  7.     int *arr, first, last, sum;  
  8.     bool top = true;  
  9.     cin >> num;  
  10.     for(j=0;j<num;j++)  
  11.     {  
  12.         cin >> n;  
  13.         arr = new int[n];  
  14.         for(i=0;i<n;i++)  
  15.             cin >> arr[i];  
  16.         MaxSub(arr, n, first, last, sum);  
  17.         if(top)  
  18.             top = false;  
  19.         else  
  20.             cout << endl;  
  21.         cout << "Case " << j+1 << ":" << endl  
  22.             << sum << " " << first+1 << " "  
  23.             << last+1 << endl;  
  24.         delete [] arr;  
  25.     }  
  26.     return 0;  
  27. }  
  28. //求最大子序列之和，arr是原来的数组，count是数组的元素个数,  
  29. //first,last是所求子序列的第一个元素，最后一个元素的下标，sum是所求子序列的元素之和  
  30. void MaxSub(int *arr, int count, int &first, int &last, int ∑)  
  31. {  
  32.     //tFirst,tSum为临时的最大子序列的第一个元素与和  
  33.     int tFirst, tSum, i;  
  34.     //初始化  
  35.     first = tFirst = last = 0;  
  36.     sum = tSum = arr[0];  
  37.     //遍历该数组  
  38.     for(i=1;i<count;i++)  
  39.     {  
  40.         //如果tSum大于，则将它与相加，否则，arr[i]为子序列的第一个元素  
  41.         if(tSum >= 0)  
  42.             tSum += arr[i];  
  43.         else  
  44.         {  
  45.             tSum = arr[i];  
  46.             tFirst = i;  
  47.         }  
  48.         //如果临时的最大值大于实际的最大值，则更新子序列的first, last, sum  
  49.         if(sum < tSum)  
  50.         {  
  51.             sum = tSum;  
  52.             first = tFirst;  
  53.             last = i;  
  54.         }  
  55.     }  
  56. }  

(2) 一网友的几种解决方法：

  1. #include<iostream>  
  2. using namespace std;  
  3. #define NUM 10  
  4. template<class ElemType>  
  5. //普通2层循环时间复杂度 O(n*n)  
  6. void MaxSum(ElemType*p,int& beg,int& end,int& sum)  
  7. {  
  8.     ElemType count=0;  
  9.     sum=count;  
  10.     for(int i=0;i<NUM-1;i++)  
  11.     {  
  12.         count=0;  
  13.         for(int j=i;j<=NUM-1;j++)  
  14.         {  
  15.             count+=p[j];  
  16.             if (count>sum)   
  17.             {  
  18.                 beg=i;  
  19.                 end=j;  
  20.                 sum=count;  
  21.             }  
  22.         }  
  23.     }  
  24. }  
  25. //利用分治算法时间复杂度O(n)  
  26. template<class ElemType>  
  27. void MaxSum1(ElemType*p,int low,int high,int& beg,int& end,ElemType& sum)  
  28. {  
  29.     if(low==high)  
  30.     {  
  31.         sum=(p[low]>0)?p[low]:0;  
  32.     }  
  33.     else  
  34.     {  
  35.         int i;  
  36.         int mid=(low+high)/2;  
  37.         int leftStart,leftEnd; //左边区间最大子段的起止位置  
  38.         int rightStart,rightEnd; //右边区间最大子段的起止位置  
  39.         int leftSum=0; //左边区间的最大和  
  40.         int rightSum=0; //右边区间的最大和  
  41.         MaxSum1(p,low,mid,leftStart,leftEnd,leftSum);  
  42.         MaxSum1(p,mid+1,high,rightStart,rightEnd,rightSum);  
  43.         ElemType sumL=0; //跨越左右区间的左边部分的最大子段和  
  44.         ElemType curSum=0; //当前跨越左右区间的左边区间部分的子段和  
  45.         for(i=mid;i>=low;i--)  
  46.         { //处理左边区间  
  47.             curSum+=p[i];  
  48.             if (sumL<curSum)  
  49.             { //修改最大字段和和开始位置  
  50.                 sumL=curSum;  
  51.                 beg=i;  
  52.             }  
  53.         }  
  54.         ElemType sumR=0; //跨越左右区间的右边部分的最大子段和  
  55.         ElemType curSum1=0; //当前跨越左右区间的右边区间部分的子段和  
  56.         for(i=mid+1;i<=high;i++)  
  57.         { //处理右边区间  
  58.             curSum1+=p[i];  
  59.             if (sumR<curSum1)  
  60.             { //修改最大字段和和开始位置  
  61.                 sumR=curSum1;  
  62.                 end=i;  
  63.             }  
  64.         }  
  65.         sum=sumL+sumR; //跨越左右区间的最大字段和  
  66.         if (sum<=leftSum)   
  67.         {  
  68.             sum=leftSum;  
  69.             beg=leftStart;  
  70.             end=leftEnd;  
  71.         }  
  72.         if (sum<=rightSum)   
  73.         {  
  74.             sum=rightSum;  
  75.             beg=rightStart;  
  76.             end=rightEnd;  
  77.         }  
  78.     }  
  79. }  
  80. //利用动态规划时间复杂度也为O(n)  
  81. template<class ElemType>  
  82. void MaxSum2(ElemType*p,int& beg,int& end,ElemType& sum)  
  83. {  
  84.     sum=0;  
  85.     ElemType b=0; //上界为j的最大字段和  
  86.     int bStart,bEnd; //上界为j的最大字符段和的起止位置  
  87.     for(int j=0;j<NUM;j++)  
  88.     { //循环求最大字段和  
  89.         if (b>0)   
  90.         {  
  91.             b+=p[j];  
  92.             bEnd=j;  
  93.         }  
  94.         else  
  95.         {  
  96.             b=p[j];  
  97.             bStart=j;  
  98.             bEnd=j;  
  99.         }  
  100.         if (b>sum) //判断当前子段和，之前最大子段和的大小  
  101.         {  
  102.             sum=b;  
  103.             beg=bStart;  
  104.             end=bEnd;  
  105.         }  
  106.     }  
  107. }  
  108. void main()  
  109. {  
  110.     int p[NUM]={-4,2,4,2,-2,8,9,-4,3,-2};  
  111.     int beg,end,sum;  
  112.     beg=end=sum=0;  
  113.     // MaxSum<int>(p,beg,end,sum);  
  114.     // MaxSum1<int>(p,0,NUM-1,beg,end,sum);  
  115.     MaxSum2<int>(p,beg,end,sum);  
  116.     cout<<"开始下标为:"<<beg<<endl;  
  117.     cout<<"结束下标为:"<<end<<endl;  
  118.     cout<<"最大字段和为:"<<sum<<endl;  
  119. }  

(3) 参考《编程之美》
(4) 关于此问题的讨论。
http://topic.csdn.net/u/20100929/09/b9c84138-b5d2-4cfa-bcd4-140ffedfbc11.html?seed=1620195128&r=68870831#r_68870831

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
简易Token认证系统实现指南(Spring Boot - Vue)
基于java+springboot+vue实现的垃圾分类回收系统（文末源码+Lw）23-213
elementui中el-table表格根据不同的值设置单元格背景色
(动态规划)最长回文子序列、回文子序列个数
HTTP常见的14种状态码
深度学习方法在糖尿病视网膜病变诊断中的应用
如何设置tomcat管理员的用户名和密码
千万级数据库查询+分页优化
init.rc service 无法启动
OpenCV、PCL在Ubuntu下的快速安装
;