1.分治法

基本概念

字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……

基本思想及策略

• 基本思想：将一个问题，分解为多个子问题，递归的去解决子问题，最终合并为问题的解
• 策略：对于一个规模为n的问题，若该问题可以容易解决则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立与原问题形式相同，递归地解决这些子问题，然后将各子问题的解合并得到原问题的解

适用情况

1. 问题分解为小问题后容易解决
   2.问题可以分解为小问题，即最优子结构
2. 分解后的小问题解可以合并为原问题的解

3. 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。

   第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；

第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；、

第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。

第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。

一般框架

分治法在每一层递归上都有三个步骤：

• step1 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
• step2 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题

• step3 合并：将各个子问题的解合并为原问题的解。
  它的一般的算法设计模式如下：

  Divide-and-Conquer(P)

  1. if |P|≤n0

  2. then return(ADHOC(P))

  3. 将P分解为较小的子问题 P1 ,P2 ,…,Pk

  4. for i←1 to k

  5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi

  6. T ← MERGE(y1,y2,…,yk) △ 合并子问题

  7. return(T)

  其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0时直接用算法ADHOC(P)求解。算法MERGE(y1,y2,…,yk)是该分治法中的合并子算法，用于将P的子问题P1 ,P2 ,…,Pk的相应的解y1,y2,…,yk合并为P的解。

依据分治法设计程序时的思维过程

实际上就是类似于数学归纳法，找到解决本问题的求解方程公式，然后根据方程公式设计递归程序。
1、一定是先找到最小问题规模时的求解方法
2、然后考虑随着问题规模增大时的求解方法
3、找到求解的递归函数式后（各种规模或因子），设计递归程序即可。

案例分析

1.最大子数组问题

问题：一个包含n个整数（有正有负）的数组A，找出和最大的非空连续子数组。（例如：[0, -2, 3, 5, -1, 2]应返回9，[-9, -2, -3, -5, -3]应返回-2。）

基本解法：暴力求解找出所有子数组（$\Theta (n^2)$），对每个子数组求和（$\Theta (n)$），总复杂度是$\Theta (n^3)$。在遍历过程中，这些子数组的和是有重复计算的。下标i与j的区间和sum[i][j] = sum[i][j - 1] + A[j]，所以子数组求和变为$\Theta (1)$，时间复杂度降为$\Theta (n^2)$。

分治解法：要寻找A[left…right]的最大子数组，可以在中点mid处将A一分为二成A[left…mid]和A[mid+1…right]。A[left…right]的最大子数组必定是以下三者之一：

完全位于A[left…mid]
完全位于A[mid+1…right]
跨越了中点，即最大子数组的左边界落在left和mid之间，右边界落在mid和right之间
1和2两种情况可以通过递归调用来查找最大子数组，所以关键是3这个“合并”的步骤。因为跨越中点的子数组都由两个子数组A[i…mid]和A[mid…j]组成，所以我们可以从mid这个位置开始，分别向前和向后查找两个以mid为界的最大子数组，最后把这两个子数组合并成A[i…j]这个跨越中点的最大子数组即可。最后，问题的解就是上述三种情况里面和最大的那个子数组

package com.test;

import java.util.ArrayList;
import java.util.List;

public class MyTest02 {
    public static void main(String[] args) {
        int[] a = { 13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7 };
        int[] s = getMaxSummary(a, 0, 15);
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
    }

    /**
     * 程序主入口
     * @param A
     * @param low
     * @param high
     * @return
     */
    public static int[] getMaxSummary(int[] A, int low, int high) {
        if (low == high) { // 如果長度就一個，那麼就把這個取出來
            int[] result = { low, high, A[low] };
            return result;
        } else {
            int middle = (int) Math.floor((low + high) / 2); // 获取中间值
            int[] left = new int[3]; // 保存左边部分返回结果
            int[] right = new int[3]; // 保存右边部分返回结果
            int[] cross = new int[3]; // 返回交叉部分返回结果
            left = getMaxSummary(A, low, middle);
            right = getMaxSummary(A, middle + 1, high);
            cross = getMaxCrossMid(A, low, high, middle);
            if (left[2] >= right[2] && left[2] >= cross[2]) {   // 那部分大就用了那部分
                return left;
            } else if (right[2] >= left[2] && right[2] >= cross[2]) {
                return right;
            } else {
                return cross;
            }
        }
    }

    /**
     * 獲取最大子數組（一部分在左邊，一部分在右邊）
     * 
     * @param A
     * @param low
     * @param high
     * @param middle
     * @return
     */
    public static int[] getMaxCrossMid(int[] A, int low, int high, int middle) {
        int leftSum = Integer.MIN_VALUE;
        int sum = 0; // 保存和的
        int left = 0; // 记录左边位置
        for (int i = middle; i >= low; i--) {
            sum = sum + A[i];
            if (sum > leftSum) { // 证明所加数字为正数，那么符合条件（因为最大子数组内正数越多指定越大）
                leftSum = sum;
                left = i;
            }
        }

        int rightSum = Integer.MIN_VALUE;
        int sum2 = 0;
        int right = 0; // 记录右边位置
        for (int i = middle + 1; i <= high; i++) {
            sum2 = sum2 + A[i];
            if (sum2 > rightSum) {
                rightSum = sum2;
                right = i;
            }
        }

        int[] result = new int[3];
        result[0] = left;
        result[1] = right;
        result[2] = leftSum + rightSum;
        return result;
    }




}