算法导论笔记——分治算法

分治算法算是以递归为基础的算法。大致的思想为将一个大问题纷争几个规模较小的子问题，递归的求这些子问题，然后再合并这些子问题得到原来的解。

分治算法大概由三个步骤“分” “治” “合”

分：将原问题分解成若干个小的子问题

治：解决这些规模较小的子问题

合：合并这些子问题的解成原问题的解

这里可以拿归并排序算法来举个例子

分：分解待排序的n个元素的序列成各具n/2各元素的两个子序列

治：使用归并排序递归的排序两个子序列。

合：合并两个已排序的子序列产生以排序的答案

现在就通过题目来一步步了解分治算法吧

书中的第一个问题是求最大子数组，这道题目最好的做法其实是使用动态规划，但是今天我们主要讲分治算法。

这里可以看力扣的第53题

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

首先，看到这样的题目我们的第一反应应该是暴力求解，求出这串字符的每一种组合，然后依次比较大小，从而得到最大的那一个

#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
using namespace std;
int MaxSum(int a[] , int n) {
	int sum = -10000;
	int maxsum = 0;
	for (int i = 0; i < n; i++) {
		maxsum = 0;
		for (int j = i; j < n; j++) {
			maxsum += a[j];
			if (maxsum > sum) {
				sum = maxsum;
			}
		}
	}
	return sum;
}
int main() {
	int a[] = {5,4,-1,7,8};
	int b = MaxSum(a, 5);
	cout << b;
	return 0;
}

大家可以简单的看一下这段代码，这里的i是来模拟从那位数开始计算，j是模拟从第i位开始的每一种组合，如果此时小于我们当前所得到的最大值，那么就将此时算得的数组和代替最大字数和。但是这段代码看着非常简单，但是他的时间复杂度其实是O（N^2）的，如果遇到一个非常长的数组，此时我们所需花费的时间是非常长的，因此大家可以看一下我们接下来所使用的方法。

接下来同过我们的分治思想来看一下这道题目。首先我们应该将这道题划分成两个规模相等的子问题，我们可以这样想。假设我们的数组为5  4  -1  7  8

我们应该先将数组划分为两个规模较小的数组，这里我们可以将数组一分为二，

这样分成两块，那么重点来了，如果要找到最大的子数组和，那么这各最大子数组有三种出现情况，1、这个数组全部都在左侧，2、这个数组全部都在右侧，3、这个数组包括中点，左侧区间内有一部分，右侧区间内有一部分，三个数组进行比较，找出最大得，就是我们要寻找的最大数组。现在就需要我们的递归知识了， 我们如果想求得左边和右边的的最大子数组，就应该将左边继续划分成两个小数组，再次求出其中的最大子数组和。

现在我们就开始coding吧

从简单的开始，先求出包括中间的最大子数组

        int mid = (start + end) >>1;
        int leftsum = 0;
        for(int i = mid; i<= start ;i--){
            leftsum += nums[i];
            left = max(leftsum , left);
        }
        int right = nums[mid + 1];
        int rightsum = 0;
        for(int i = mid+1 ; i<= end ; i++){
            rightsum += nums[i];
            right = max(rightsum , right);
        }

 现在将将leftsum+ rightsum就是我们所求的包括mid的最大子数组和

 这里有一点我小插一嘴（mid = start + end）>>1 向右移动一位可以理解为/2

        int allmax = leftmax + rightmax;

现在我们递归求得左边的最大的子数组，右边最大的子数组

        int leftmax = MAX(nums , start , mid);
        int rightmax = MAX(nums , mid + 1 , end);

现在我们只要返回这三个中的最大值就行了，这里我就把我写的leetcode的答案放在下面，希望大家可以理解，对递归理解不是很深的童鞋可以画一个递归的树状图

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        return MAX(nums,0,nums.size()-1);
    }
    int MAX( vector<int> nums,int start , int end){
        if(start == end){
            return 0;
        }
        int mid = (start + end) >>1;
        int leftmax = MAX(nums , start , mid);
        int rightmax = MAX(nums , mid + 1 , end);
        int left = INT_MIN;
        int leftsum = 0;
        for(int i = mid; i<= start ;i--){
            leftsum += nums[i];
            left = max(leftsum , left);
        }
        int right = nums[mid + 1];
        int rightsum = 0;
        for(int i = mid+1 ; i<= end ; i++){
            rightsum += nums[i];
            right = max(rightsum , right);
        }
        int allmax = leftmax + rightmax;
        return max(allmax , max(rightmax , leftmax));
    }
};