麻省理工学院公开课：算法导论。B站地址，网易公开课也有对应的资源。
https://www.bilibili.com/video/av1149902/?p=3

这节课主要讲解分治法解决各种问题的思路。
所谓分治法，大概分三个步骤：
1、分：把问题划分成若干个子问题
2、治：递归地解决每一个子问题
3、合并：把子问题的解，合并成整个大问题的解

归并排序

之前两节课程都提到的归并排序（这里就不详细写了）
1、把待排序的数组一分为二
2、分开处理每一部分
3、合并，时间复杂度为Θ(n)

每一个符合分治策略的算法，几乎都有相似形式的递归出现，如上节课学习的主定理（主方法）

练习——主定理应用到归并排序中
归并排序的递归表达式：T(n) = 2T(n/2) + Θ(n)
2T(n/2)中，第一个2表示子问题的数目，第二个2表示子问题的规模，Θ(n)表示合并需要的计算量。
根据上一节课的主定理可知：
n^log_ba = n^log₂2 = n
f(n) = n
即为第二种情况，整理的时间复杂度为T(n) = Θ(nlgn)

二分查找算法（Binary Search）

在一个已排序的数组中寻找元素x
1、分：把x和数组的中间元素进行比较
2、治：由上一步找到对应的子数组，然后重复1
3、合并（这里只是找到x即可，不需要合并，所以之类这一步可以省略）
这个问题的递归表达式：T(n) = T(n/2) + Θ(1)
根据上一节课的主定理可知：
n^log_ba = n^log₂1 = n⁰ = 1
f(n) = 1
即为第二种情况，整体时间复杂度为 Θ(lgn)

乘方问题

存在某数x，正整数n，求xⁿ
思路：
① 简单粗暴地直接算的话，就是把x连乘n次，然后得出结果。时间复杂度明显为Θ(n)
② 上面的思路说说而已啦啦，用分治法看下

1. 分：根据n为偶数/奇数，求不同的结果
   n为偶数时，xⁿ = x^n/2·x^n/2
   n为奇数时，xⁿ = x^(n-1)/2·x^(n-1)/2·x
2. 治：分别求出每一子项的结果
3. 合并：将每一子项的结果再合并起来，时间复杂度为Θ(1)

递归表达式为T(n) = T(n/2) + Θ(1)

之前在LeetCode刷过相同的题，题号50。这里要考虑的情况比较多，如n为负数的情况。下面是自己写的JavaScript版的答案：【挺久之前写的题了，当时想着不一定要递归分解到最后x²的情况再合并，所以写个getZhishu()来获取最优的分解，提交通过。】

/**
 * @param {number} x
 * @param {number} n
 * @return {number}
 */
var myPow = function(x, n) {
    // 要处理n为负数的情况
    var result = 1;
    var N = Math.abs(n);

    if(x===1){
        return 1;
    }
    // 把N拆解一下，
    var arr = getZhishu(N);
    var tmp = x;
    for(var i=0;i<arr.length;i++){
        // 要记得重置result的值
        result = 1;
        for(var j=1;j<=arr[i];j++){
            result *= tmp;
        }
        tmp = result;
    }
    return n>=0 ? result : 1/result;
};
// 把sum分解为多个数的乘积，要求所有元素的和为最小。
var getZhishu = function(num){
    var result = [];
    var _num = num;
    var middle = parseInt(_num/2, 10);
    for(var i=2;i<=middle;){
        if(_num%i === 0){
            // 如果可以除尽
            _num /= i;
            middle = parseInt(_num/2, 10);
            result.push(i);
            i = 2;
        }else{
            i++;
        }
    }
    // 把最后一个加进去
    result.push(_num);
    return result;
};

尝试用递归的方法处理一下，但是在一些边缘情况（如：x=0.00001，n=2147483647）的时候会超时，应该是陷入递归里面出不来，需要要做一些特殊处理。

/**
 * @param {number} x
 * @param {number} n
 * @return {number}
 */
var myPow = function(x, n) {
    // 要处理n为负数的情况
    var result = 1;
    var N = Math.abs(n);

    if(x===1){
        return 1;
    }

    result = getNum(x, N);
    
    return n>=0 ? result : 1/result;
};
var getNum = function(x, n){
    if(n===0){
        return 1;
    }
    if(n===1){
        return x;
    }
    if(n&1){
        return getNum(x, parseInt(n/2)) * getNum(x, parseInt(n/2)) * x;
    }else{
        return getNum(x, n/2) * getNum(x, n/2);
    }
}

斐波那契数

斐波那契数的定义为
F₀ = 0，n=0
F₁ = 1，n=1
F_n = F_n-1 + F_n-2，n≥2

求解斐波那契数有两种算法。
① 递归算法，一层一层往下递归计算，时间复杂度为指数级

② 自下而上递归算法，从0，1开始向上递归解决，时间复杂度为Θ(n)，但这还不是最优解。【下面LeetCode的70题是同样的思路。】

之前在LeetCode刷过相同的题，题号70和746。均为JavaScript版本。

// 第70题，爬楼梯
/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    if(n===1 || n===2){
        return n;
    }
    var a = 1;
    var b = 2;
    for(var i=3;i<n;i++){
        var tmp = a+b;
        a = b;
        b = tmp;
    }
    return a+b;
};

③ 可以运用上面求乘方（朴素平方递归式）的方法来求
时间复杂度为lgn，但因为各种原因这个方法在现实中的机器上是不能实现的。但是可以运用斐波那契数的特性，用另一种方式来实现平方递归。
即
用矩阵来计算，时间复杂度为lgn（同前面的乘方问题，只是x换成了矩阵），因为矩阵相乘的时间复杂度为常数，所以整体时间复杂度为Θ(lgn)。

这是定理

使用归纳法来证明上面的定理：
首先，基础情况

进一步归纳

也就是

矩阵乘法

A和B都是n x n的矩阵，A = [a_ij]，B = [b_ij]，其中1 ≤ i,j ≤ n。两者的乘积C = [c_ij] = A*B
C中的某一项的值如下：

求取矩阵C的算法，时间复杂度为Θ(n³)。因为C一共有n²项需要求取，而且求取每一项c_ij的时间复杂度，根据上面的公式可得，为Θ(n)，所以总的时间复杂度为Θ(n³)。

代码如下：

for(var i=0;i<n;i++){
    for(var j=0;j<n;j++){
        c[i][j] = 0;
        for(var k=0;k<n;k++){
            c[i][j] += a[i][k]*b[k][j];
        }
    }
}

现在要对矩阵乘法进行优化。

斯特拉森算法（Strassen's Algorithm）
首先，前面用分治法的场景大多是把规模为n的问题分解为2个规模为n/2的问题，然后再分开求解合并。但是这里，矩阵的规模是n²。
用矩阵分块来处理，第一步先把矩阵分解成2x2块规模为(n/2)*(n/2)的子矩阵。
对ABC三个矩阵都进行分割，如图：

C = A * B

先不关心r、s、t、r这些模块内部详细的结果。把它简单化为一个2*2的矩阵
其中根据矩阵的乘法，可得：

r = ae + bg
s = af + bh
t = ce + dg
u = cf+dh

递归表达式描述为 T(n) = 8T(n/2) + Θ(n²)
Θ(n²) 为以上矩阵求和（如ae+bg）的时间复杂度。

根据上节课的主定理，n^log_ba = n^log₂8 = n³，f(n) = n²，岁时间复杂度为 T(n) = Θ(n³)。

下面用斯特拉森算法来讲。斯特拉森算法的原理在于减少乘法的次数，把8T(n/2) 变为7T(n/2)。
两个2x2的矩阵在求乘积的时候，一共需要进行8次乘法。

P₁ = a(f-h)
P₂ = (a+b)h
P₃ = (c+d)e
P₄ = d(g-e)
P₅ = (a+d)(e+h)
P₆ = (b-d)(g+h)
P₇ = (a-c)(e+f)

r = P₅ + P₄ - P₂ + P₆
s = P₁ + P₂
t = P₃ + P₄
u = P₅ + P₁ - P₃ - P₇

其中，验证一下u的值是否正确
u = P₅ + P₁ - P₃ - P₇
.. = (ae+ah+de+dh) + (af-ah) - (ce+de) - (ae+af-ce-cf)
.. = dh + cf

同上面的计算结果一致，这里省略r s t的证明。
用分治法来看一下这个算法：

1. 分：
   要计算出所有的P_i内各种加减法的值，需要消耗n²的时间。
2. 治
   递归求出所有P_i的值，共进行7个乘法。
3. 合并
   分别求出r s t u，都是加减法，时间n²。

所以递归表达式为T(n) = 7T(n/2) + Θ(n²)，求得时间复杂度为Θ(n^lg7)，即Θ(n^2.81)。

VLSI（超大规模集成电路）问题

问题可简化为：有个完全二叉树，共n个叶节点，要在网格上占据最小的空间，应该如何进行布局。
这里讲解了两个方法
① 朴素算法
② 复杂度为Θ(n)的算法

朴素算法

在线画电路图比较麻烦，所以上传手动图。
这棵树的高度H(n) = lgn，宽度W(n) = n，所以其面积Area = Θ(nlgn)。

复杂度为Θ(n)的算法
因为Area = H * W，所以要使Area = Θ(n)，可以让H和W都分别为根号n。
那么根据上节课的主方法，逆推一下，可得b = a²，假设a=2，那么其递归表达式应为T(n) = 2T(n/4) + O(n^(1/2)-ε)。画出其递归树如下：