27-分治(Divide And Conquer)

分治(Divide And Conquer)

分治,也就是分而治之。它的一般步骤如下

  1. 将原问题分解成为若干个规模较小的子问题(子问题和原问题的结构一样,只是规模不一样)
  2. 子问题又被分解成规模更小的子问题,直到不能再分解(直到可以轻易计算出子问题的解)
  3. 利用子问题的解推导出原问题的解

所以,通过上面介绍的步骤,可以知道,分治策略非常使用于递归,因为前面在将原问题分解为若干个子问题时,子问题的结构与原问题是一样的,只是规模不一样,所以,很容易想到,这可以利用递归来进行解决。

不过,需要注意一点的是,子问题之间是相互独立的

归并的应用

  • 快速排序
  • 归并排序
  • Karatsuba算法(大数乘法)

主定理(Master Theorem)

分治策略通常遵守一种通用的模式

  • 解决规模为n的问题,分解成a个规模为n / b的子问题,然后再O(n^d)时间内将子问题的解合并起来

  • 所以,分治策略算法运行的时间有这样一个公式:T(n) = aT(n/b) + O(n^d),其中a > 0,b > 1,d≥0

    • d > logb(a),T(n) = O(n^d)
    • d = logb(a),T(n) = O(n^dlogn)
    • d < logb(a),T(n) = O(n^(logb()a))

    例如归并排序的运行时间是:T(n) = 2T(n / 2) + O(n),a = 2,b = 2,d = 1,所以T(n) = O(nlogn)

那么,为什么有些问题采用分治策略以后,性能会有所提升呢?

例如,前面在介绍冒泡排序,选择排序,插入排序时,都存在最坏时间复杂度,为n^2,但是后面使用快速排序,归并排序这些采用分治思想以后,发现算法的性能就会有所提升。

例如现在需要对n个数据进行排序,时间复杂度为O(n^2)

  1. 现在将n个数据平均分为2组,每一组的数据规模则为n / 2
  2. 现在对每一组数据进行单独排序,时间复杂度为O(n^2/4)
  3. 所以将两组数据进行排序,总共消耗的时间复杂度为O(n^2/2) + 合并需要的时间O(merge)
  4. 如果合并操作消耗的时间是小于O(n^2/2)的,这样得到的结果是小于对n个数据进行排序的

了解到了分治策略的基本原理以后,接下来就研究一下分治策略的几种应用场景

场景一:最大连续子序列和[Leetcode地址]

给定一个长度为n的整数序列,求它的最大连续子序列和

  • 比如-2,1,-3,4,-1,2,1,-5,4的最大连续子序列和是4 + (-1) + 2 + 1 = 6

    子序列:-2.4,2这样的序列,叫做子序列,不要求是连续的

    连续子序列(也称为子串,子数组,子区间):,4,-1,2,1;即连在一起的子序列叫做连续子序列

这个问题,也属于最大切片问题(最大区段,Greatest Slice)

方法一:暴力出奇迹

穷举出所有可能的连续子序列,并计算出它们的和,最后取出它们中的最大值。

  1. 定义一个begin指针,从0位开始依次往右进行遍历
  2. 定义一个end指针,从0开始依次往右进行遍历
  3. end指针的索引大于等于begin指针
  4. 计算end到begin之间所有元素的和

集合这个思路,可以得到如下的代码

static int maxSubarray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int max = Integer.MIN_VALUE;
    for (int begin = 0; begin < nums.length; begin++) {
        for (int end = begin; end < nums.length; end++) {
            int sum = 0;
            for (int i = begin; i < end; i++) {
                sum += nums[i];
            }
            max = Math.max(max,sum);
        }
    }
    return max;
}

这种算法的空间复杂度为:O(n^3),空间复杂度为:O(1)

很明显,上面这种算法有很多重复的计算,就在最内层的循环中,当begin指针不变时,end指针往右移动,往右移动的过程中,begin到end之间的的元素,其实是存在重复计算的,所以首先,可以从这里进行优化,优化后的结果如下

static int maxSubarray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int max = Integer.MIN_VALUE;
    for (int begin = 0; begin < nums.length; begin++) {
        int sum = 0;
        for (int end = begin; end < nums.length; end++) {
            sum += nums[end];
            max = Math.max(max,sum);
        }
    }
    return max;
}

这样,就可以将时间复杂度从O(n3)降为O(n2)。不过虽然这种方法也可以解决上面的问题,但是效率并不高,接下来用分治的方法进行尝试。

方法二:分治

将序列[begin,end)均匀得分割成2个子序列[begin,mid),[mid,end),其中mid = (begin + end) >> 1

现假设问题的解存在于区间[i,j)中,那么问题的解有以下三种可能

  1. [i,j)存在于[begin,mid)中
  2. [i,j)存在于[mid,end)中
  3. [i,j)一部分存在于[begin,mid)中,另一部分存在于[mid,end)中
    • 这种情况下[i,j) = [i,mid) + [mid,j)

最终,通过这种思路,得到的代码如下

static int maxSubarray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    return maxSubarray(nums,0,nums.length);
}

//计算[begin,end),最大连续子序列的和
static int maxSubarray(int[] nums,int begin, int end) {
    if (end - begin < 2) return nums[begin];
    int mid = (begin + end) >> 1;
    int leftMax = Integer.MIN_VALUE;
    int leftSum = 0;
    for (int i = mid - 1; i >= begin; i--) {
        leftSum += nums[i];
        leftMax = Math.max(leftMax,leftSum);
    }
    int rightMax = Integer.MIN_VALUE;
    int rightSum = 0;
    for (int i = mid; i < end; i++) {
        rightSum += nums[i];
        rightMax = Math.max(rightMax,rightSum);
    }
    int max = leftMax + rightMax;
    return Math.max(max,Math.max(maxSubarray(nums,begin,mid),maxSubarray(nums,mid,end)));
}

通过这种优化,空间复杂度为O(logn),时间复杂度为O(nlogn)

场景二:大数乘法

在平时开发中,大家可能都是利用这种方式进行乘法计算的

int a = 10;
int b = 20;
int c = 2 * c;

使用符号*来进行运算。

但是,如果需要对两个超大的数(如100位的数组),就不能再利用*符号直接相乘了。因为

  1. 本来大操作树,现在在内存中就已经溢出了,在当前编程语言提供的基本数据类型中,不足以存储这么大数值的数字
  2. 相乘以后的结果可能会溢出

所以,一般来讲,如果要存储这么大的数据的话,首先采用字符串来进行存储,所以,最终计算出来的结果,依然是字符串

那么,2个超大是数相乘,应该 如何进行呢?

其实,可以按照小学学习的乘法运算,例如对36 * 54进行计算,按照小学的乘法运算,计算步骤如下

得到这些结果以后,然后将这些结果分别进行相加,得到结果如下

但是,需要注意,在进行大数乘法时的相加不是直接相加,如下图

现在假设上图是两个大数进行相乘,如果相乘后的每一位结果依然是直接相加的话,依然会导致内存溢出,所以应该每一位的结果单独相加,这样才能保证不会内存溢出。

而且,通过上面的简单试可以看出,2位数与2位数之间的相乘,进行了4次个位数的相乘,推导出3位数与3位数之间相乘,进行了9次个位数的相乘,所以在进行n位数与n位数之间的相乘时,需要大约进行n^2次个位数的相乘。所以相乘的每一步,可以利用分治思想来进行解决,所以模拟两个树进行相乘的示意图如下

通过这种方式进行计算的消耗的时间表达式为T(n) = 4T(n/2) + O(n),所以时间复杂度为O(n^2)

大数乘法优化

Anatolii Alexeevitch Karatsuba于1960年提出Karatsuba算法,提高了大数乘法的效率

在前面,利用分治思想计算大数的话,基本思路如上图,Karatsuba算法基于数学公式进行了优化,公式为B * C + A * D = A * C + B * D - (A - B) * (C - D),通过这个数学公式,进行计算会得到怎样的优化呢?

结合上面的公式,就可以将上面的BC + AD进行拆解,最终拆解的结果如下

通过这样的优化,就可以减少两个大数相乘的次数,因为AC,BD的计算结果可以得到复用

所以,现在通过这种方式进行计算的话,消耗的时间表达式为T(n) = 3T(n/2) + O(n),利用主定理可以推导出时间复杂度为O(n^1.585)。这样就降低了复杂度

所以,大数乘法也是分治的一种应用,并且可以发现,如果一个问题一旦可以使用分治来进行解决的话, 大多数情况下,都是可以降低复杂度的。

demo下载地址

完!

推荐阅读更多精彩内容

  • 什么是分治法 在昨天的文章《漫谈数据库中的join》的最后,提到Grace hash join和Sort-merg...
    LittleMagic阅读 1,969评论 2 14
  • 算法和数据结构 [TOC] 算法 函数的增长 渐近记号 用来描述算法渐近运行时间的记号,根据定义域为自然数集$N=...
    wxainn阅读 460评论 0 0
  • 大O,大,大 大O 大O表示一个函数f(x)在大于某一个数时,存在一个正数,使得存在,即函数的上界函数 大 大O表...
    Black_Eye阅读 174评论 0 1
  • 分治策略 本文包括分治的基本概念二分查找快速排序归并排序找出伪币棋盘覆盖最大子数组 源码链接:https://gi...
    廖少少阅读 1,166评论 0 7
  • 一个查询,通常就是一个select语句,但如果一个select查询语句中,又嵌套了select查询语句,其后者就称...
    kangyiii阅读 945评论 0 8
  • 相信大多数人都已经能够很清楚的了解KVC了,但是我依旧要给大家简单的解释一下,避免有不太清楚的小伙伴看不懂.KVC...
    为什么划船不靠桨阅读 306评论 2 3
  • 面对不公平,我还是要学会一一面对,所以,我还是要继续强颜欢笑
    南枳垚垚阅读 87评论 1 1
  • 导读:本文分享了故里小姐在民宿创业苦逼奋斗的一些感受,希望对广大民宿主人有一定的启发。 美宿养成记是基于民宿培训的...
    故里小姐阅读 93评论 0 0