跳到主要内容

算法设计的常用思想

贪婪法​

贪婪法(greedy algorithm), 又称贪心算法, 用于寻找最优解问题的常用方法.

基本思想​

贪婪法的基本设计思想有以下三个步骤:
(1) 建立对问题精确描述的数学模型, 包括定义最优解的模型.
(2) 将问题分解为一些列子问题, 同时定义子问题的最优解结构.
(3) 应用贪心原则确定每个子问题的局部最优解, 并根据最优解的模型, 用子问题的局部最优解堆叠出全局最优解.

例子: 0-1 背包问题​

  • 问题: 有 N 件物品和一个承重为 C 的背包, 每件物品的重量是 w(i), 价值是 p(i), 求解将哪几件物品装入背包可使这些物品在重量综合不超过 C 的情况下价值总和最大.

背包问题(knapsack problem)是此类组合优化的 NP 完全问题的统称, 比如或相撞或问题, 货船载物问题等吗最初来源于如何选择合适的物品装在背包中而得名.

这里有一个隐含的条件, 就是限定每件物品只能选择 0 或 1 个, 因此被称为 0-1 背包问题.

看一个具体的例子: 有一个背包最多称重 C=150, 有 7 个物品,编号为 1~7, 重量为 w(i)=[35,30,60,50,40,10,25], 价值 p(i)=[10,40,30,50,35,40,30],选择一个或多个装入背包是价值最大.

对于本题, 常见的贪婪策略有三种.

  • 第一种策略是根据物品价值选择, 每次选择价值最高的物品, 据此,选择 4,2,6,5, w=130,p=165.
  • 第二种策略是根据物品重量徐娜则, 每次选最轻的物品, 据此, 选择 6,7,2,1,5,w=140,p=155.
  • 第三种策略是定义价值密度 s(i)=(p(i)/w(i)), 价值密度一次 s(i)=[0.286,1.333,0.5,1.0,0.875,4.0,12], 据此, 选择 6,,2,7,4,1, w=150, p=170.

JS 代码实例:

//背包问题(0-1背包问题)

//物品
let tagObejct = {
    weight: null, //重量
    price: null, //价值
    status: 0 //0:未选中,1:已选中,2:已超重,不可选
};

//背包
let tagKnapsackProblem = {
    objes: [],
    totalC: 150
};

//贪婪算法主体
function GreedyAlgo(problem, spfunct) {
    let idx;
    let ntc = 0;
    while ((idx = spfunct(problem.objes, problem.totalC - ntc)) != -1) {
        console.log(idx);
        if (ntc + problem.objes[idx].weight <= problem.totalC) {
            problem.objes[idx].status = 1;
            ntc += problem.objes[idx].weight;
        } else {
            problem.objes[idx].status = 2;
        }
    }

    PrintResult(problem.objes);
}

/**
 * 选择策略-价值最高优先
 * @param {*} objes 物品列表
 * @param {*} c 剩余承重
 */
function Choosefunc1(objes, c) {
    let index = -1;
    let mp = 0;
    for (let i = 0; i < objes.length; i++) {
        if (objes[i].status == 0 && objes[i].price > mp) {
            mp = objes[i].price;
            index = i;
        }
    }

    return index;
}

function PrintResult(objes) {
    console.log(objes);
}

(function main() {
    let wArray = [35, 30, 60, 50, 40, 10, 25];
    let pArray = [10, 40, 30, 50, 35, 40, 30];
    for (let i = 0; i < 7; i++) {
        let tempObj = {
            weight: wArray[i],
            price: pArray[i],
            status: 0
        };
        tagKnapsackProblem.objes.push(tempObj);
    }

    GreedyAlgo(tagKnapsackProblem, Choosefunc1);
})();

虽然这里是第三种策略得到了最好的结果, 实际上只是对这组数据的验证结果而已, 如果换一组数据, 结果可能完全相反. 对于一些可以证明贪婪法得到的就是最优解的问题, 应用贪婪法可以高效地求得结果, 比如求最小生成树的 Prim 算法和 Kruskal 算法.

大多数情况下, 贪婪法只能得到比较接近最优解的近似的最优解. 但是作为一种启发式辅助方法, 常用雨其他算法中, 比如 Dijkstra 的单源最短路径算法.

事实上, 在任何算法中, 只要某个阶段使用了只考虑局部最优情况的选择策略, 都可以理解为使用了贪婪算法.

分治法​

分治, 顾名思义, 分而治之. 分治法的设计思想是将无法着手的解决的大问题分解成一系列规模较小的相同问题, 然后逐个解决. 分治法产生的子问题与原始问题相同, 只是规模减小, 反复使用分治法, 直到能够被直接求解为止.

应用分治法, 一般处于两个目的: 1. 通过分解问题, 是无法着手解决的大问题变成容易解决的小问题. 2. 通过见笑问题的规模, 降低解决问题的复杂度(或计算量).

基本思想​

分治法基本可以归纳为以下三个步骤:

  1. 分解: 将问题分解为若干个规模较小, 相互独立且与原问题形式相同的子问题, 确保各个子问题具有相同的子结构.
  2. 解决: 如果上一步分解得到的子问题可以解决, 则解决这些子问题, 否则, 对每个子问题使用和上一步相同的方法再次分解, 然后求解分解后的子问题, 这个过程可能是一个递归的过程.
  3. 合并: 将上一步解决的各个子问题的解通过某种规则合并起来, 得到原问题的解.

分治法的实现可以是递归的, 也可以是非递归的. 这里是几个例子:

  • 快速排序算法的分解思想是选择一个标兵数, 将待排序的序列分成两个子序列, 其中一个子序列中的树都小于标兵数,另一个子序列中的数都大于标兵数,然后分别对两个子序列排序,其合并思想就是将两个已经排序的子序列一前一后拼接在标兵数的前后, 组成一个完整的有序序列.

  • 快速傅里叶变换的分解思想是将一个 N 点离散傅里叶变换, 按照奇偶关系分成两个 N/2 点李轩傅里叶变换, 其合并思想就是将两个 N/2 离散傅里叶变换的结果按照蝶形运算的位置关系重新排列成一个 N 点序列.

例子: 大整数 Karatsuba 乘法算法​

  • 两个 n 位的大整数想成的时间复杂度为 O(n^2);
    Anatolii Alexeevitch Karatsuba 博士在 1960 年提出一种快速乘法算法, 时间复杂度为 O(3n^1.585)(1.585=log2(3)). 这就是 Karatsuba 乘法算法.

该算法利用分治法的思想, 将 n 位大整数分解成两个接近 n/2 位的大整数, 通过 3 次 n/2 位大整数的惩罚和少量假发操作, 避免了直接进行 n 位大整数惩罚计算, 有效降低了乘法计算的计算量.

Karatsuba 代码实现(没有考虑健壮性):

//Karatsuba大数乘法
class Karatsuba {
    caculateRes(mul1, mul2) {
        if (this.getBigNCount(mul1) == 1 || this.getBigNCount(mul2) == 1) {
            return mul1 * mul2;
        }

        let high1, high2, low1, low2;
        let k = Math.floor(
            Math.max(this.getBigNCount(mul1), this.getBigNCount(mul2)) / 2
        );

        low1 = mul1.toString().substr(-k) - 0;
        high1 = mul1.toString().substr(0, mul1.toString().length - k) - 0;
        low2 = mul2.toString().substr(-k) - 0;
        high2 = mul2.toString().substr(0, mul2.toString().length - k) - 0;

        if (isNaN(high1) || isNaN(low1) || isNaN(high2) || isNaN(low2)) {
            console.log("return error");
            return 0;
        }
        let z0 = this.caculateRes(low1, low2);
        let z1 = this.caculateRes(low1 + high1, low2 + high2);
        let z2 = this.caculateRes(high1, high2);

        let zk = z1 - z2 - z0;

        z2 = z2 * Math.pow(10, 2 * k);
        zk = zk * Math.pow(10, k);

        return z2 + zk + z0;
    }

    getBigNCount(mul) {
        //mul为大整数
        let numStr = mul.toString();
        return numStr.length;
    }
}

(function main() {
    let kara = new Karatsuba();
    let res = kara.caculateRes(34534521, 328962);
    console.log(res);
    console.log(34534521 * 328962);
})();

动态规划​

基本思想​

动态规划(dynamic programming)是解决多阶段决策问题常用的最优化理论. 该理论提出后在数学, 计算机科学, 经济管理和工程技术领域得到了广泛的应用, 例如最短路线, 库存管理, 资源分配, 设备更新, 排序, 装在等问题, 用动态规划方法往往比朴素的方法更高效.

动态规划方法的原理就是把多阶段决策过程转化为一系列的但阶段决策过程问题, 利用各个阶段之间的递推关系, 逐个确定每个阶段的最优化决策, 最终堆叠出多阶段决策的最优化决策结果.

每种方法都有自身的局限性. 动态规划适合求解多阶段(状态转换)决策问你的最优解, 也可用于含有线性或非线性递推关系的最优解问题. 但是这些问题都必须满足最优化原理和子问题的"无后向性":

  • 最优化原理: 最优化原理其实就是问题的最优子结构的性质, 如果一个问题的最优子结构是不论过去状态和决策如何, 对前面的决策所形成的的状态而言, 其后的决策必须构成最优策略, 也就是说, 不管之前决策是否是最优决策, 都必须保证从现在开始的决策时在之前决策基础上的最有决策, 则这样的最优子结构就符合最优化原理.
  • 无后向性(无后效性): 所谓"无后向性", 就是当各个阶段的子问题确定以后, 对于某个特定阶段的子问题来说, 它之前的各个阶段的子问题的决策只能影响该阶段的决策, 对该阶段之后的决策不产生影响, 也就是说, 每个阶段的决策仅收之前决策的影响, 但是不影响之后各阶段的决策.

使用动态规划一把需要四个步骤, 分别为定义最优子问题, 定义状态 定义决策和状态转换方程以及确定边界条件.

  1. 定义最优子问题

定义最优子问题, 也就是确定问题的优化目标以及如何决策最优解, 并对决策过程划分阶段. 所谓阶段, 可以理解为一个问题从开始到解决所需经过的环节, 这些环节前后关联, 划分阶段没有固定的方法, 根据问题的结构可以按照时间顺序划分阶段, 也可以按照问题的状态划分阶段. 阶段划分以后, 对问题的求解就变成对各个阶段分别进行最优化决策.

以装配站问题为例, 装配站问题的阶段划分比较清晰, 把工件从一个装配站移到下一个装配站就可以看作是一个阶段, 其子问题就可以定义为从一个装配站转移到下一个装配站. 知道最后一个装配站完成工作组装.

  1. 定义状态

状态既是决策的对象, 也是决策的结果. 对于每个阶段来说, 对起始状态施加决策, 使得状态发生改变, 得到决策的结果状态. 初始状态经过每一个阶段的决策之后, 最终的到的状态就是问题的解. 只有一个决策序列能得到最优解. 状态的定义建立在子问题定义的基础上, 状态必须满足"无后向性".

装配站问题的实质就是在不同的装配线之间选择装配站, 使得工件装配完成的事件最短, 其状态s[i,j]就可以定义为通过第i条装配线的第j个装配站所需要的最短时间.

  1. 定义决策和状态转换方程

定义决策和状态转换方程. 决策就是能使状态发生转变的选择动作, 如果选择动作有多个, 则决策就是取其中能使得阶段结果最优的哪一个. 状态转换方程是描述状态转换关系的一系列等式, 也就是从 n-1 阶段到 n 阶段演化的故意率. 状态转换取决于子问题的堆叠方式, 如果状态定义的不合适, 就会导致子问题之间没有重叠, 也就不存在状态转换关系了. 没有状态转换关系, 动态规划也就没有意义了, 实际算法就退化为像分治法那样的朴素递归搜索算法.

对于装配站问题, 其决策就是选择在当前在工作线上的下一个工作站继续装配, 或者花费一定的开销将其转移到另一条工作线上的下一个工作站继续装配. 如果定义a[i,j]为第i条工作线的第j个装配站需要的装配之间, k[i,j]为另一条工作线转移到第i条工作线的第j个装配站所需要的转移开销, 则装配站问题的状态转换方程可以描述为:

s[(1, j)] = min(
    s[(1, j - 1)] + a[(1, j)],
    s[(2, j - 1)] + k[(1, j)] + a[(1, j)]
);
s[(2, j)] = min(
    s[(2, j - 1)] + a[(2, j)],
    s[(1, j - 1)] + k[(2, j)] + a[(2, j)]
);
  1. 决定边界条件

对于递归加备忘录方式(记忆搜索)实现的动态规划方法, 边界条件时间上就是递归终结条件, 无需额外的计算. 对于使用地推关系直接实现的动态规划方法, 需要确定状态转换方程的递推式的初始条件或边界条件, 否则无法开始递推计算.

对于装配站, 初始条件就是工件通过第一个装配站的时间, 对于两条装配线磊说,工件通过第一个装配站的时间虽然不相同, 但是都是确定的值, 就是移入装配线的开销加上一个装配站的装配时间, 因此装配站问题的边界条件就是:

s[(1, 1)] = k[(1, 1)] + a[(1, 1)];
s[(2, 1)] = k[(2, 2)] + a[(2, 2)];

例子: 字符串的编辑距离​

  • 我们把两个字符串的相似度定义为: 将一个字符串转换成另外一个字符串时需要付出的代价. 转换可以采用插入, 删除和替换三种编辑方式, 因此转换的代价就是对字符串的编辑次数. 字符串转换的方法不唯一, 不同转换的方法需要编辑的次数也不一样, 最少的那个编辑次数就是字符串的编辑距离(edit distance).

我们先展示一下使用普通的递归法来实现这个算法:

function EditDistance(srcArr, destArr) {
    if (srcArr.length == 0 || destArr.length == 0)
        return Math.abs(srcArr.length - destArr.length);
    if (srcArr[0] == destArr[0]) {
        return EditDistance(srcArr.slice(1), destArr.slice(1));
    }

    let edIns = EditDistance(srcArr, destArr.slice(1)) + 1; //插入字符
    let edDel = EditDistance(srcArr.slice(1), destArr) + 1; //删除字符
    let edRep = EditDistance(srcArr.slice(1), destArr.slice(1)) + 1; //替换字符

    return Math.min(Math.min(edIns, edDel), edRep);
}

对于朴素的递归算法, 事件复杂度是 O(3^n). 当字符串的长度非常大的时候, 这个算法将变得无法接受.

现在考虑用动态规划的方法对这个算法进行改进, 这个问题的阶段划分不是很明显, 我们首先定义出问题的状态, 从状态转换关系开始定义阶段和子问题的递推关系.

假设source字符串有 n 个字符, target字符串有 m 个字符. 如果将问题定义为求解将source的[1...n]个字符转换为target的[1...m]个字符所需要的最少编辑次数, 则其子问题定义为将source的前[1...i]个字符所需要的最少编辑次数. 这就是本问题的最优子结构, 因此我们将状态d[i,j]定义为从子串source[1...i]到子串target[1...j]之间的编辑距离.

根据状态的定义, 两个长度是 5 的字符串最多可以有 25 个状态, 朴素递归方法之所以递归的次数达到了 3^5 数量级, 就是因为大量的状态是重复计算的, 没有剪枝优化. 现在采用动态规划的思想对朴素递归算法进行改造, 首先映入状态的概念, 递归接口增加状态标志参数 i和j, 其次是引入备忘录概念, 用一个二维表记录每个状态的值, 递归过程中优先进行查表. 所有的状态记录在一个二维表中, 二维表的每个元素定义:

memo[i][j] = {
    distance: null, //编辑距离
    refCount: 0 //0表示没有状态的记录.
};

调整后的算法如下所示:

function EditDistance(src, dest, i, j) {
    // console.log(memo[i][j]);
    //查表, 直接返回
    if (memo[i][j].refCount != 0) {
        memo[i][j].refCount++;
        return memo[i][j].distance;
    }

    let distance = 0;

    if (src.substr(i).length == 0) {
        distance = dest.substr(j).length;
    } else if (dest.substr(j).length == 0) {
        distance = src.substr(i).length;
    } else {
        if (src[i] == dest[j]) {
            distance = EditDistance(src, dest, i + 1, j + 1);
        } else {
            let edIns = EditDistance(src, dest, i, j + 1) + 1; //插入字符
            let edDel = EditDistance(src, dest, i + 1, j) + 1; //删除字符
            let edRep = EditDistance(src, dest, i + 1, j + 1) + 1; //替换字符
            distance = Math.min(Math.min(edIns, edDel), edRep);
        }
    }

    memo[i][j].distance = distance;
    memo[i][j].refCount = 1;

    return distance;
}

现在已经定义了状态, 并且 EDitDistance()函数中也体现了状态转换关系和状态的边界条件, 接下来我们可以直接给出状态递推关系方式的动态规划算法. 根据决策方式, d[i,j]的递推关系, 分为两种情况, 分别是 source[i]等于 target[j]和 source[i]不等于 target[j]. 两种情况下, d[i,j]的递推关系如下:

  • d[i,j]=d[i,j]+0; source[i]等于target[j]
  • d[i,j]=min(d[i,j-1]+1,d[i-1,j]+1),d[i-1,j-1]+1); source[i]不等于 target[j].

当其中一个字符串为空字符串, 编辑距离相当于另一个字符串的长度. 所以得到边界条件:

  • d[i,0]=source.length
  • d[o,j]=target.length

确定了递推关系和边界条件, 就可以给出直接利用状态递推关系实现的动态规划算法.

function EditDistance(src, dest) {
    let i = 0;
    let j = 0;
    let d = [];
    for (let i = 0; i <= src.length; i++) {
        d[i] = [];
        for (let j = 0; j <= dest.length; j++) {
            if (i == 0) {
                d[i][j] = j;
            } else if (j == 0) {
                d[i][j] = i;
            } else {
                if (src[i - 1] == dest[j - 1]) {
                    d[i][j] = d[i - 1][j - 1]; //不需要编辑操作
                } else {
                    let edIns = d[i][j - 1] + 1; //source 插入字符
                    let edDel = d[i - 1][j] + 1; //source 删除字符
                    let edRep = d[i - 1][j - 1] + 1; //source 替换字符

                    d[i][j] = Math.min(Math.min(edIns, edDel), edRep);
                }
            }
        }
    }
    //   console.log(d);
    return d[src.length][dest.length];
}

虽然动态规划比较抽象, 但是只要确定了问题的实质, 按照上面给出的四个步骤逐步分析, 实现动态规划也不是很困难的事. 如果直接用递推方式很难写出的算法实现, 不妨考虑采用带备忘录的递归方式, 也可以叫动态规划不是吗.

解空间的穷举搜索​

穷举法(穷举搜索法) 的解空间, 又称状态空间, 是所有可能是解的候选解的集合, 之所以特别强调在解空间内穷举搜索, 就是想要传达, 穷举并不是漫无目的的查找, 它是一种在有限的解空间内按一定策略进行查找的算法. 有时候, 也叫枚举.

穷举通常被称为"最后的办法", "不是办法的办法", 然而它是很多问题的唯一解决方法.

基本思想:

  1. 确定问题的解的定义, 解空间的范围和正确解的判定条件.
  2. 根据解空间的特点选择搜索策略.

解空间搜索策略:​

  1. 盲目搜索法

常见的盲目搜索算法有广度优先搜索和深度优先搜索等.

  1. 启发式搜索算法

当问题到达一定规模, 盲目搜索算法就因为低效而不可接受. 利用搜索过程中出现的额外信息直接跳过一些状态避免盲目, 机械式的搜索, 就可以加快搜索算法的收敛, 就是死启发式搜索.

  1. 剪枝策略

对解空间穷举搜索时, 对一些状态节点可以进行排除, 跳过此状态节点的遍历, 将极大的提高算法的执行效率, 这就是剪枝策略.

  1. 搜索算法的评估和收敛

当解空间的规模大到无法对解空间进行完整的搜索, 这时候就需要对搜索算法进行评估, 并确定一些收敛原则. 收敛原则就是只要能找到一个较好的解就返回, 并根据解的评估判断时候需要继续下一次搜索. 很多棋类游戏就利用了这种算法.

例子: Google 方程式​

  • 有一个由字符组成的等势:WWWDOT - GOOGLE = DOTCOM , 每个字符代表一个 0~9 之间的数字, WWWDOT,GOOGLE,DOTCOM 都是合法的数字, 不能以 0 开头. 请找出一组字符和数字的对应关系, 使它们相互替换, 并且替换后的数字能够满足等式.

现在来考虑一种解决这种字符方程问题的通用解法. 从数据结构定义上, 首先要避免使用固定 9 个字符的方法, 因此定义一个可变化的字符元素列表, 每个字符元素包含 3 个属性: 字母本身, 字母代表的数字, 是否是数字的最高位:

let tagCharItem = {
    c: "",
    value: -1,
    leading: false
};

对于此题, 可以初始化列表:

//字母的数据结构
function tagCharItem(c, value, leading) {
    this.c = c;
    this.value = value;
    this.leading = leading;
}

//用来表示数字是否已经被使用的数据结构
function tagCharValue(used, value) {
    this.used = used;
    this.value = value;
}

let chatItem = [
    new tagCharItem("W", -1, true),
    new tagCharItem("D", -1, true),
    new tagCharItem("O", -1, false),
    new tagCharItem("T", -1, false),
    new tagCharItem("G", -1, true),
    new tagCharItem("L", -1, false),
    new tagCharItem("E", -1, false),
    new tagCharItem("C", -1, false),
    new tagCharItem("M", -1, false)
];

let charValue = [
    new tagCharItem(false, 0),
    new tagCharItem(false, 1),
    new tagCharItem(false, 2),
    new tagCharItem(false, 3),
    new tagCharItem(false, 4),
    new tagCharItem(false, 5),
    new tagCharItem(false, 6),
    new tagCharItem(false, 7),
    new tagCharItem(false, 8),
    new tagCharItem(false, 9)
];

搜索主体算法如下:

let max_char_count = charItem.length;
let max_num_count = charValue.length;

function SearchingResult(ci, cv, index, callback) {
    if (index >= max_char_count) {
        callback(ci);
        return;
    }

    for (let i = 0; i < max_num_count; i++) {
        if (isValueValid(ci[index], cv[i])) {
            cv[i].used = true;
            ci[index].value = cv[i].value;
            SearchingResult(ci, cv, index + 1, callback);
            cv[i].used = false;
        }
    }
}

评估函数如下:

function isValueValid(ci, cv) {
    if ((cv.value == 0 && ci.leading) || cv.used) {
        return false;
    } else {
        return true;
    }
}

回调函数:

function onCharListReady(ci) {
    let minuend = "WWWDOT";
    let subtrahead = "GOOGLE";
    let diff = "DOTCOM";

    let m = makeIntegerValue(ci, minuend);
    let s = makeIntegerValue(ci, subtrahead);
    let d = makeIntegerValue(ci, diff);

    if (m - s == d) {
        console.log(`${m} - ${s} = ${d}`);
    }
}

转换函数:

function makeIntegerValue(ci, str) {
    let t_str = str.toString().split("");
    let p_number = [];
    for (let i = 0; i < t_str.length; i++) {
        for (let j = 0; j < ci.length; j++) {
            if (t_str[i] == ci[j].c) {
                p_number.push(ci[j].value);
            }
        }
    }
    return parseInt(p_number.join(""));
}

对于本题, 合法的答案如下:

  • 777589 - 188103 = 589486
  • 777589 - 188106 = 589483

参考​