最大子段和(分而治之求解)

本文介绍了一种使用递归方式寻找一维数组中最大子段和的算法实现。该算法通过左右子区间递归求解最大子段和,并考虑了跨越中点的最大子段和情况。
 

#include<iostream>

#include<vector>

 

using namespace std;

const int Min=-99999;

void MaxSum(const vector<int>&v,int &besti,int &bestj,int& sum,int low,int high)

{

       int i;

       if(low==high) //当low==high,递归截止,sum存放一个元素和

       {

              sum=v[low];

              return;

       }

       else if(low<high) //当low<high,产生递归

       {

              int mid=(low+high)/2; //mid是low...high区间的中值

              int lsum;

              MaxSum(v,besti,bestj,lsum,low,mid); //左区间递归,求low...mid区间最大子段和

              int rsum;

              MaxSum(v,besti,bestj,rsum,mid+1,high);//右区间递归,求mid+1...high区间最大子段和

              //最大子段和可能出现在i...j中,low<=i<=mid, mid<j<=high

              int lbestsum=Min; //lbestsum是i...mid区间最大子段和

              int s=0; //s用于求和

              int L_index; //L_index...mid区间是最大子段和区间

              for(i=mid;i>=low;i--) //求i...mid区间最大子段和

              {

                     s+=v[i];

                     if(s>lbestsum)

                     {

                            L_index=i;

                            lbestsum=s;

                     }

              }

              int rbestsum=Min; //rbestsum是mid+1...high区间最大子段和

              s=0;

              int R_index; //mid_1...R_index区间是最大子段和区间

              for(i=mid+1;i<=high;i++)

              {

                     s+=v[i];

                     if(s>rbestsum)

                     {

                            R_index=i;

                            rbestsum=s;

                     }

              }

              if(lsum>rsum && lsum>(lbestsum+rbestsum)) //最大子段和是出现在low...mid区间内

              {

                     besti=low;

                     bestj=mid;

                     sum=lsum;

              }

              else if(rsum>lsum && rsum>(lbestsum+rbestsum)) //最大子段和是出现在mid+1...high区间内

              {

                     besti=mid+1;

                     bestj=high;

                     sum=rsum;

              }

              else

              {

                     besti=L_index;

                     bestj=R_index;

                     sum=lbestsum+rbestsum;

              }

       }

}

 

void main()

{

       vector<int>v;

       int i,j,sum;

       sum=0;

       int e;

       const int end=-9999;

       cin>>e;

       while(e!=end)

       {

              v.push_back(e);

              cin>>e;

       }

       for(i=0;i<v.size();i++) cout<<i<<":"<<v[i]<<endl;

       MaxSum(v,i,j,sum,0,v.size()-1);

       cout<<"最大子段和从位置"<<i<<"到"<<"位置"<<j<<endl;

       cout<<"最大子段和是:"<<sum<<endl;

}

### 最大算法的时间复杂度分析 #### 暴力算法 暴力算法通过遍历所有可能的数组来找到具有最大的连续数组。对于长度为 \( N \) 的输入序列,该方法涉及三层嵌套循环:外层选择起始位置,中间层选择结束位置,内层计算当前选定区间的总并更新全局最大值。 这种实现方式导致其时间复杂度达到 O(),因为每次迭代都需要重新评估整个区间内的元素相加情况[^1]。 ```python def max_subarray_brute_force(arr): n = len(arr) best_sum = float('-inf') for i in range(n): # First loop over start index for j in range(i, n): # Second loop over end index current_sum = sum(arr[i:j+1]) # Third loop to compute the sum of subarray from i to j best_sum = max(best_sum, current_sum) return best_sum ``` #### 改进后的暴力算法 通过对上述过程稍作修改,在第二重循环过程中累积求而不是每次都调用 `sum()` 函数可以减少不必要的重复运算,从而降低至 O() 的时间开销。 这种方法避免了第三次显式的内部循环,而是利用变量保存临时的结果来进行比较操作[^2]。 ```python def improved_max_subarray_brute_force(arr): n = len(arr) best_sum = float('-inf') for i in range(n): temp_sum = 0 for j in range(i, n): temp_sum += arr[j] best_sum = max(best_sum, temp_sum) return best_sum ``` #### 分治算法 采用分而治之策略将原问题分解成更小规模相同类型的问题加以解决,并最终组合这些解决方案得到整体解答。具体来说就是把数列分成两半分别处理左半边的最大、右半边的最大以及跨越中心点两侧的最大三种情形中的最大者作为最后结果返回给上一层递归调用直至完成全部数据扫描工作为止。此方案能够有效地缩小搜索空间使得效率提高到了 O(n log n)[^3]。 ```python def divide_and_conquer_max_subarray(arr, low, high): if high == low: return (low, high, arr[low]) mid = (low + high) // 2 left_low, left_high, left_sum = divide_and_conquer_max_subarray(arr, low, mid) right_low, right_high, right_sum = divide_and_conquer_max_subarray(arr, mid + 1, high) cross_low, cross_high, cross_sum = find_max_crossing_subarray(arr, low, mid, high) if left_sum >= right_sum and left_sum >= cross_sum: return (left_low, left_high, left_sum) elif right_sum >= left_sum and right_sum >= cross_sum: return (right_low, right_high, right_sum) else: return (cross_low, cross_high, cross_sum) def find_max_crossing_subarray(arr, low, mid, high): left_sum = float('-inf') summation = 0 max_left = None for i in reversed(range(low, mid + 1)): summation += arr[i] if summation > left_sum: left_sum = summation max_left = i right_sum = float('-inf') summation = 0 max_right = None for j in range(mid + 1, high + 1): summation += arr[j] if summation > right_sum: right_sum = summation max_right = j return (max_left, max_right, left_sum + right_sum) ``` #### 动态规划算法 动态规划提供了一种线性的高效途径去解决问题——即只需要一次完整的遍历就能得出答案。核心思想在于维护一个记录截止当前位置之前所遇到过的最佳局部解的状态转移方程\[ dp[i]=\text{max}(dp[i−1]+a[i], a[i]) \] ,其中\( dp[]\) 表示以第i项结尾的最大。这样做的好处是可以在线性时间内获得全局最优解O(n)[^4]。 ```python def dynamic_programming_max_subarray(arr): n = len(arr) dp = [None]*n dp[0] = arr[0] for i in range(1,n): dp[i] = max(dp[i-1]+arr[i], arr[i]) return max(dp) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值