常用算法 - 分治

​
​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…

1.概述

在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。
任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。n=2时，只要作一次比较即可排好序。n=3时只要作3次比较即可，…。而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。

2. 步骤

它的一般步骤是
① 将原问题分解成若干个规模较小的子问题（子问题和原问题的结构一样，只是规模不一样）
② 子问题又不断分解成规模更小的子问题，直到不能再分解（直到可以轻易计算出子问题的解）
③ 利用子问题的解推导出原问题的解
◼ 因此，分治策略非常适合用递归
◼ 需要注意的是：子问题之间是相互独立的

3. 应用

快速排序
归并排序
Karatsuba算法（大数乘法）

4.练习

最大连续子序列和

问题如下：
◼ 给定一个长度为 n 的整数序列，求它的最大连续子序列和
比如 –2、1、–3、4、–1、2、1、–5、4 的最大连续子序列和是 4 + (–1) + 2 + 1 = 6

思路如下：
◼ 将序列均匀地分割成 2 个子序列
[begin , end) = [begin , mid) + [mid , end)，mid = (begin + end) >> 1
◼ 假设 [begin , end) 的最大连续子序列和是 S[i , j) ，那么它有 3 种可能
[i , j) 存在于 [begin , mid) 中，同时 S[i , j) 也是 [begin , mid) 的最大连续子序列和
[i , j) 存在于 [mid , end) 中，同时 S[i , j) 也是 [mid , end) 的最大连续子序列和
[i , j) 一部分存在于 [begin , mid) 中，另一部分存在于 [mid , end) 中
✓ [i , j) = [i , mid) + [mid , j)
✓ S[i , mid) = max { S[k , mid) }，begin ≤ k ＜ mid
✓ S[mid , j) = max { S[mid , k) }，mid ＜ k ≤ end

实现如下：

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

    public static void main(String[] args) {
        int[] nums = {-2,1,-3,4,-1,2,1,-5,4};
        int i = maxSubArray1(nums);
        System.out.println(i);
    }

    /**
     * 方法1：暴力求解，
     */
    public static int maxSubArray1(int[] nums) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i <nums.length; i++) {
            int cur = 0;
            for (int j = i; j < nums.length; j++) {
                if ((cur += nums[j]) > max) max = cur;
            }
        }
        return max;
    }

    /**
     * 方法二：分治求解
     */
    public static int maxSubArray2(int[] nums) {
        return maxSub(0, nums.length, nums);
    }

    public static int maxSub(int left, int right, int[] nums) {
        // 只有一个元素时结束递归
        if (right - left < 2) return nums[left];
        // 分
        int mid = (left + right) >> 1;
        int leftMax = maxSub(left, mid, nums);
        int rightMax = maxSub(mid, right, nums);
        int leftMidMax = Integer.MIN_VALUE;
        int rightMidMax = Integer.MIN_VALUE;
        int tmp = 0;
        for (int i = mid - 1; i >= left; i--) {
            if ((tmp += nums[i]) > leftMidMax) leftMidMax = tmp;
        }
        tmp = 0;
        for (int i = mid; i < right; i++) {
            if ((tmp += nums[i]) > rightMidMax) rightMidMax = tmp;
        }
        int midMax = leftMidMax + rightMidMax;
        return Math.max(midMax, Math.max(leftMax, rightMax));
    }

}