算法六：分治算法

分治算法（divide and conquer）

核心思想其实就是四个字，分而治之 ，也就是将原问题划分成 n 个规模较小，并且结构与原问题相似的子问题，递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

分治算法是一种处理问题的思想，递归是一种编程技巧。

分治算法一般都比较适合用递归来实现。

• 分治算法的递归实现中，每一层递归都会涉及这样三个操作：
  • 分解：将原问题分解成一系列子问题；
  • 解决：递归地求解各个子问题，若子问题足够小，则直接求解；
  • 合并：将子问题的结果合并成原问题。
• 分治算法能解决的问题，一般需要满足下面这几个条件：
  • 原问题与分解成的小问题具有相同的模式；
  • 原问题分解成的子问题可以独立求解，子问题之间没有相关性，这一点是分治算法跟动态规划的明显区别；
  • 具有分解终止条件，也就是说，当问题足够小时，可以直接求解；
  • 可以将子问题合并成原问题，而这个合并操作的复杂度不能太高，否则就起不到减小算法总体复杂度的效果了。

分治算法的应用

#!/usr/bin/python
# -*- coding: UTF-8 -*-

inversion_num = 0


def merge_sort_counting(nums, start, end):
    if start >= end:
        return

    mid = (start + end)//2
    merge_sort_counting(nums, start, mid)
    merge_sort_counting(nums, mid+1, end)
    merge(nums, start, mid, end)


def merge(nums, start, mid, end):
    global inversion_num
    i = start
    j = mid+1
    tmp = []
    while i <= mid and j <= end:
        if nums[i] <= nums[j]:
            inversion_num += j - mid - 1
            tmp.append(nums[i])
            i += 1
        else:
            tmp.append(nums[j])
            j += 1

    while i <= mid:
        # 这时nums[i]的逆序数是整个nums[mid+1: end+1]的长度
        inversion_num += end - mid
        tmp.append(nums[i])
        i += 1

    while j <= end:
        tmp.append(nums[j])
        j += 1

    nums[start: end+1] = tmp


if __name__ == '__main__':
    print('--- count inversion number using merge sort ---')
    # nums = [5, 0, 4, 2, 3, 1, 6, 8, 7]
    nums = [5, 0, 4, 2, 3, 1, 3, 3, 3, 6, 8, 7]
    print('nums  : {}'.format(nums))
    merge_sort_counting(nums, 0, len(nums)-1)
    print('sorted: {}'.format(nums))
    print('inversion number: {}'.format(inversion_num))

Pow(x, n)

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，x^n ）。

class Solution:
    def myPow(self, x: float, n: int) -> float:
        # 1.调用库函数 O(1)
        # 2.暴力解决 O(N)
        # 3.分治算法 O(logn)
        if not n:
            return 1
        if n < 0:
            return 1/self.myPow(x, -n)
        if n % 2:
            return x * self.myPow(x, n-1)
        return self.myPow(x * x, n/2)
        # 4.非递归