带你吃透分治算法 (一)最大子数组

分治算法

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题,这些子问题相互独立且与原问题性质相同。求出子问题的解,就可得到原问题的解。就像归并排序的排序思想一样。

回忆一下归并排序的过程,我们在递归地求解一个问题时,在每层递归中应用了以下三个步骤:

  • 分解:将原问题划分为子问题,子问题的形式(性质)和原问题一样,只是规模变小了
  • 解决:当子问题的规模非常小了(如递归排序中排序元素只有一个时),则停止递归,直接进行求解。
  • 合并:将划分的两个子问题的解组合成原问题的解,不过有时我们会遇到需要求解与原问题不完全一样的子问题,我们也将其求解过程看做合并步骤的一部分。

因此,从上面的思路我就便定义了两种情况:

  • 递归情况:当子问题很大,需要递归求解的情况
  • 基本情况:子问题小到了一定的程度时(触底了),不再需要递归的情况

分治思想解最大子数组问题

最大子数组问题:给定一个整数数组,要求找出元素之和最大的子数组。即给你一个数组Arr[a1,a2,a3…,an],求下标j,k,使得sum = a(j)+a(j+1)+a(j+2)+…+a(k)为最大值。

首先我们知道,只有数组中包含负数时,最大子数组问题才有意义,如果所有的数组元素都是非负的,那么最大子数组便是其本身。

对于最大子数组问题,有许多解法,如暴力穷举法,动态规划法等等,我们因为是为了学习分治的思想,因此主要讲用分治思想解最大子数组,其他方法可以参考如下博文:最大子数组及其优化

使用分治策略的求解方法

加入给你如下数组A[13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7],则最大子数组如下图所示:

带你吃透分治算法 (一)最大子数组_第1张图片

下面我们来思考如何使用分治思想求解最大子问题,如过我们将原数组以其中心划分为两部分A[low,…,mid]和A[mid+1,…,high],则我们要寻找的最大子数组一定只有三种可能位置。

  1. 最大子数组完全位于左半边A[low,…,mid]。
  2. 最大子数组完全位于右半边A[mid+1,…,high]。
  3. 最大子数组两边都占据了一些位置。

如下图所示:
带你吃透分治算法 (一)最大子数组_第2张图片
带你吃透分治算法 (一)最大子数组_第3张图片

因此,我们可以递归地对前两种可能性求解,因为这两个子问题仍是最大子数组问题,只是规模相比较原数组更小,之后便是寻找跨越中点的最大子数组,然后在这三种情况中选取最大者。

对于跨越中点的最大子数组的求法,我们可以将这个数组A[i,…,mid,…,j]划分为两部分A[i,…,mid]和A[mid+1,…,j],当这两部分分别为两边的最大子数组时,那么其合并起来的A[i,…,mid,…,j]即为跨越两边的最大子数组。

C语言实现:

//结构类型定义
typedef int ElemType;

typedef struct MaxSubarray{
    int l_index,r_index;
    ElemType Sum;
}MaxSubarray;
//跨越两边的最大子数组求解
MaxSubarray Get_CrossMaxSubArray(ElemType arr[],int left,int mid,int right)
{
    MaxSubarray MSArray;
    ElemType Sum_temp = INT_MIN;
    ElemType Sum_l=0,Sum_r=0;
    for(int i=mid;i>=left;i--)//找左半部最大子数组
    {
        Sum_l += arr[i];
        if(Sum_l > Sum_temp)
        {
            Sum_temp = Sum_l;
            MSArray.l_index = i;
        }
    }
    MSArray.Sum = Sum_temp;
    Sum_temp = INT_MIN;
    for(int i = mid+1;i<=right;i++)//找右半部最大子数组
    {
       Sum_r +=arr[i];
        if(Sum_r > Sum_temp)
        {
            Sum_temp = Sum_r;
            MSArray.r_index = i;
        } 
    }
    MSArray.Sum += Sum_temp;
    return MSArray;
}

解决了这个问题,那么接下来就简单了,按照上面讲的不断划分直到“触底”,然后寻找跨越两边的最大子数组,将三者比较返回最大的子数组。

//分治策略求解最大子数组问题
MaxSubarray GetMaxSubArray_Divide(ElemType arr[],int left,int right)
{
    MaxSubarray MSArray_left,MSArray_mid,MSArray_right;
    if(left == right)
    {
        MaxSubarray TEMP;
        TEMP.l_index = left;
        TEMP.r_index = right;
        TEMP.Sum = arr[left];
        return TEMP;
    }else
    {
        int mid = (left + right)/2;
        MSArray_left = GetMaxSubArray_Divide(arr,left,mid);
        MSArray_right = GetMaxSubArray_Divide(arr,mid+1,right);
        MSArray_mid = Get_CrossMaxSubArray(arr,left,mid,right);

        if(MSArray_mid.Sum >= MSArray_left.Sum && MSArray_mid.Sum >= MSArray_right.Sum)//寻找最大值
            return MSArray_mid;
        else if(MSArray_left.Sum >= MSArray_right.Sum && MSArray_left.Sum >= MSArray_mid.Sum)
            return MSArray_left;
        else
            return MSArray_right;
    }
}

分治算法解最大子数组的时间复杂度为O(n*log n),但是实际上还存在一个线性时间的算法,可参考最大子数组问题及其优化

你可能感兴趣的:(算法设计与应用,数据结构,分治算法,算法)