分治策略 & 最大子数组的问题

　　刷LeetCode题目刷到第53题Maximum Subarray。意思是：给定一个数组，求一个和最大的子数组。例如给定[-2,1,-3,4,-1,2,1,-5,4], 那么可以求得连续子数组 [4,-1,2,1] 能取得最大和sum = 6. P.s子数组的意思是，数据要连续，子序列的意思就是顺序得按照原来数组来，但是不要求连续。
　　去翻阅了《算法导论》第三版，里面的第四章讲分治策略，恰好就是讲最大子数组问题。现记录一下。

分治策略

分治策略就是递归地求解一个问题，每层递归应用如下三个步骤：
-分解（Divide）：将原问题划分成一些子问题，子问题的形式与原问题一样，只是规模更小；
-解决问题（Conquer）：递归地求解子问题。如果子问题规模足够小，则停止递归，直接求解；
-合并（Combine）: 将子问题的解组合成原问题里的解。
注意：有时候除了与子问题完全一样的规模更小的子问题之外，还需要求解与子问题不完全一样的子问题，我们将这些子问题的求解看做合并步骤的一部分。

求解最大子数组问题

1. 首先想到的就是暴力求解，一个一个组合方式去试。这种花费的时间代价太大。
2. 利用分治策略来求解。
   分解步 ： 将数组分为两半，那么问题将会分解成【求左边的最大子数组，求右边的最大子数组，求“包含中间数”的跨越最大子数组】；
   解决问题： 递归求解上述的子问题；
   合并 : 求得【左边最大子数组，右边最大子数组，跨越最大子数组】中和最大的那个，即为解。
3. 线性的解法
   维持一个当前的已求最大子数组和一个累加器（当累加器得到结果为小于0的时候，累加器清零，重新往后累加，寻找更大的子数组的可能性）。

线性函数代码

//线性解法
int maxSubArray(vector<int>& array_List)
{
    int sum = 0;
    int ans = array_List[0];
    int a = 0;
    int b = 0;
    int c;
    for (int i = 0; i < array_List.size(); ++i){
        if (sum == 0)
        {
            c = i; //c为最新的累加开始的index
        }
        sum += array_List[i];
        ans = max(sum, ans);
        if (ans == sum)//当ans更新的时候，表示有更优的子数组
        {
            b = i;//b为当前最优子数组的结束位置
            if (a != c && c <= b) 
            {
                a = c;//a为当前的子数组的开始位置，当b>=c的时候，将a更新为c
            }
        }
        sum = max(sum, 0);

    }
    cout << a << " " << b << endl;
    return ans;
}

分治解法完整代码：

#include<iostream>
#include<vector>
using namespace std;

int cross_left_index;
int cross_right_index;
int findCrossSum(vector<int>& list, int low, int mid, int high)
{
    int left_sum = list[mid];
    int local_sum = list[mid];
    for (int i = mid-1; i >=low; i--)
    {
        local_sum += list[i];
        if (local_sum>left_sum)
        {
            left_sum = local_sum;
            cross_left_index = i;
        }
    }

    int right_sum = list[mid+1];
    local_sum = list[mid + 1];
    for (int i = mid+2; i <= high; i++)
    {
        local_sum += list[i];
        if (local_sum>right_sum)
        {
            right_sum = local_sum;
            cross_right_index = i;
        }
    }

    return left_sum + right_sum;

}


int left_index;
int right_index;
int findMaxSub(vector<int>& list, int low, int high)
{
    if (high == low)
        return list[low];
    else
    {
        int mid = (high + low) / 2;
        int left_sum = findMaxSub(list, low, mid);
        int right_sum = findMaxSub(list, mid+1, high);
        int cross_sum = findCrossSum(list, low, mid, high);

        /*int result = (left_sum > right_sum) ? left_sum : right_sum;
        result = (result > cross_sum) ? result : cross_sum;*/
        int result;
        if (left_sum>cross_sum&&left_sum>right_sum)
        {
            result = left_sum;
            left_index = low;
            right_index = mid;
        }
        else if (right_sum>left_sum&&right_sum>cross_sum)
        {
            result = right_sum;
            left_index = mid + 1;
            right_index = high;
        }
        else
        {
            result = cross_sum;
            left_index = cross_left_index;
            right_index = cross_right_index;
        }

        return result;
    }
}

int maxSubArray(vector<int>& array_List)
{
    int size = array_List.size();
    return findMaxSub(array_List, 0, size - 1);
}


int main()
{
    vector<int> a = { -2, 1, -3, 4, -1, 2, 1, -5,4};
    int result = maxSubArray(a);

    cout << result << endl;
    cout << "the left index is:" << left_index << endl;
    cout << "the right index is:" << right_index << endl;
    return 0;
}

暴力解法

//暴力搜索方法
int findMaxSub(vector<int>& array_List)
{
    int size = array_List.size();
    vector<int> sum_list;
    vector<int> index_list;
    sum_list.resize(size);
    index_list.resize(size);
    for (int i = 0; i < size; i++)
    {
        int local_sum = array_List[i];
        sum_list[i] = local_sum;
        for (int j = i+1; j <size ; j++)
        {
            local_sum += array_List[j];
            if (local_sum>sum_list[i])
            {
                sum_list[i] = local_sum;
                index_list[i] = j;
            }
        }
    }

    int max = sum_list[0];
    int max_low_index;
    for (int i = 0; i<size;i++)
    {
        if (sum_list[i]>max)
        {
            max = sum_list[i];
            max_low_index = i;
        }
    }
    cout << "the start index is :" << max_low_index<<endl;
    cout << "the end index is :" << index_list[max_low_index] << endl;
    return max;
}