分治策略学习（二）

如果对分治策略不懂的可以先看下这个：分治策略学习（一）

回顾一下分治策略的三步骤：
1. 分解步骤：将问题划分为一些子问题，子问题的形式与原问题一样，只是规模更小。
2. 解决步骤：递归求解出子问题。如果子问题的规模足够小，则停止递归，直接求解。
3. 合并步骤：将子问题的解组合成原问题的解。

当子问题足够大，需要递归求解时，我们称之为递归情况。当子问题变得足够小，不再需要递归时，我们说递归已经“触底”，进入了基本情况。

全排列问题

问题

给定n(n>=1)个元素组成的集合，输出该集合的所有可能的排列。例如，集合 {a，b，c} 的所有的可能的排列为{（a，b，c），（a，c，b），（b，a，c），（b，c，a），（c，a，b），（c，b，a）}

解法

当我们运用分治策略的思想来解决这个问题的时候，你会发现问题变得很简单。

首先是第一步：分解问题

我们考虑一下集合中存在4个元素的时候，例如{a，b，c，d}，排列的组合如下：
1. 以a开头后面跟着{b，c，d}的所有排列
2. 以b开头后面跟着{a，c，d}的所有排列
3. 以c开头后面跟着{a，b，d}的所有排列
4. 以d开头后面跟着{a，b，c}的所有排列

此时，你会发现我们将问题从原来求解4个元素的全排列问题变为求解3个元素的全排列问题，而这只需要一个for循环就可以达到目的

这里我们拿（1）来说明问题，对于{b，c，d}，排列的组合如下
1. 以b开头后面跟着{c，d}的所有排列
2. 以c开头后面跟着{b，d}的所有排列
3. 以d开头后面跟着{b，c}的所有排列

此时又由求解3个元素的全排列问题变为求解2个元素的全排列问题，问题进一步变小。

然后是第二步：解决问题
什么时候子问题变得最小？当只剩下一个元素的时候，问题变得最小，此时停止递归，直接求解。这里又引发一个问题，如何求解？你或许会想，这里只有一个元素，直接输出就行了，但是你可能忘了，在第三步合并问题的时候，元素从一个变为两个时（或者更多的时候），不作为显然是错误的。对于全排列问题，从观察上，我们知道，如果不分解问题，只需要两两元素之间进行位置交换，我们就能得到所有的排列组合。因此，我们采取swap的方式。

最后是第三步：合并问题
将子问题组合成原问题

代码

/*
    全排列问题
*/
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

void FullArrangement(vector<char>& vec, int begin, int end)
{
    // 达到递归结束条件
    if(begin == end) {
        for(int i = 0; i <= end; ++i) {
            cout << vec[i] << " ";
        }
        cout << endl;
    }
    else {
        for(int i = begin; i <= end; ++i) {
            std::swap(vec[begin], vec[i]);
            FullArrangement(vec, begin + 1, end);
            std::swap(vec[begin], vec[i]);
        }
    }
}

int main(int argc, char const *argv[])
{
    vector<char> vec = {'a', 'b', 'c'}; 
    FullArrangement(vec, 0, vec.size() - 1);
    return 0;
}

延伸

本题目可以拓展为：去除重复的排序。例如{a, a, b}，它的全排列为{a, a, b}，{a, b, a}，{b, a, a}，留给大家思考。

二分搜索算法

二分搜索算法是一个很简单的算法，它的解释如下

在计算机科学中，二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

实现二分搜索算法的方法有很多，常用的通过while循环或者for循环（由于过于简单，这里代码就不贴出来了），又或者递归实现，这里我们讲递归实现的二分搜索算法。

解法

对于二分搜索，我们的目的是查找该数组是否存在某个值，如果运用分治方法，我们首先考虑它的三个步骤：

1. 分解步骤
   假设数组为{1, 3, 4, 6, 7, 8, 10, 13, 14}，我们要查找{4}这个元素，根据二分的思路，将数组分为两部分

2. 解决步骤
   比较当前中间值是否等于所需要查找的值，再根据比较结果进行分解

3. 合并步骤
   通过解决子问题的解，返回原问题的解

步骤如下图所示：

代码

/*
    二分搜索算法
*/
#include <iostream>
#include <vector>
using namespace std;

// 返回val所在的下标
int binary_search(const vector<int>& vec, int begin, int end, int val)
{
    if (begin > end) {
        return -1;
    }

    int mid = begin + (end - begin) / 2;
    if (vec[mid] > val) {
        return binary_search(vec, begin, mid - 1, val);
    }
    else if (vec[mid] < val) {
        return binary_search(vec, mid + 1, end, val);
    }

    return mid;
}

int main(int argc, char const *argv[])
{
    vector<int> vec = {1, 3, 4, 6, 7, 8, 10, 13, 14};
    cout << binary_search(vec, 0, vec.size(), 4) + 1 << endl;
    return 0;
}

可使用分治法求解的一些经典问题

1. 二分搜索
2. 大整数乘法
3. Strassen矩阵乘法
4. 归排序
5. 快速排序
6. 汉诺塔