阿笨兔的小屋 - 博客

走进排序的世界

Fri, 30 Sep 2016 21:54:14 GMT

写在前面

我们先提出几个问题.

Problem 1.1
试用最快的方法找到给定五个两两不同的数的中位数.

Problem 2.1
试求基于比较的排序的时间复杂度的下确界.

Problem 3.1
现在有一个序列, 其只包含0, 1, 2三种元素. 那么, 在只允许额外申请常数空间的前提下, 试求最快的对这个序列排序的方法.

对Problem 1.1的思考有助于我们引入比较, 排列, 和排序的概念. 对于Problem 2.1来说, 我们将一般性地探讨一下基于比较的排序的原理和复杂度分析, 从而在得出结论的同时给出详细的说明.

我们将在本文的最后部分解决Problem 3.1这一个特殊的排序问题. 在此基础上, 我们将探讨一下不基于比较的排序的原理和复杂度分析, 以及适用范围.

复杂度(Complexity)

每当我们探讨一个算法时, 一个问题将会被自然而然地提及. 那就是, 给定输入数据, 这个算法会在多快的时间内运行完毕? 这个算法又会占用多少空间? 对算法需求的时间和空间资源的分析, 通称为复杂性分析(complexity analysis). 由于空间的复杂性分析相对时间较为简单, 所以在下文中我们以时间复杂性分析为例.

在计算理论中, 常数次的计算操作, 甚至常数倍的操作时间都会被认为是较为次要的因素, 而最重要的则是这个总计算次数/时间, 定义为T, 相对于输入数据的规模, 定义为n, 的函数的阶. 即, 我们更加关心这个函数是一个线性的, 平方级的, 指数级的, 或是对数级的, 等等.

这个原因不难解释. 当n不断膨胀时, 函数的阶往往成为运算次数/时间的最主要因素, 可以被认为是体现了这个函数的增长率. 我们把这个"增长率"定义为函数的时间复杂度(time complexity), 严格定义如下.

$$ f(n) = O(g(n)) \iff \exists c>0, n_0>0, s.t. f(n) \leq cg(n), \forall n \geq n_0. \ \\ f(n) = \Theta(g(n)) \iff \exists c>0, n_0>0, s.t. f(n) \geq cg(n), \forall n \geq n_0. \ \\ f(n) = \Theta(g(n)) \iff f(n) = O(g(n)) = \Omega(g(n)) $$

这个定义比较抽象, 叙述起来就是: 如果函数f(n)在n充分大的时候, 存在一个常数, 使得f(n)小于g(n)的常数倍, 则称f(n) = O(g(n)). 这样的话, g(n)就确定了f(n)的上界, 所以我们可以用O(g(n))来代表f(n). 通常我们选取比较简单的函数来作为代表, 比如O(n), O(log(n)), O(n^2)等等.

类似地, 我们可以定义下界Ω和确界Θ. 对于算法而言, 我们更关心的是其时间的函数上界, 所以O和Θ更为常用一些.

举一个简单的例子. 如果把一个长度为n的序列从头到尾遍历一遍, 那么其时间复杂度是O(n). 遍历两遍, 三遍也并不改变这个复杂度. 但如果遍历次数是n的一个函数的话, 比如遍历了n遍的话, 那么其时间复杂度就是O(n^2)了.

比较与排列(Comparing & Permutation)

我们现在引入排序这个概念. 先思考Problem 1.1, 如何在五个数中用最快的速度找到中位数.

在这个问题中, 我们先要定义什么是"快". 事实上, 计算机在"找第几大的数", "选择最大值/最小值", "排序"这几个操作中, 往往是不断地对数字进行两两比较, 而得出结果的. 在这个问题中, 我们且把速度定义为对数字的两两比较的次数.

Problem 1.1的分析
该问题等价于找到最小的比较次数k, 使得五个两两不同的数在不超过k次比较中可以找到中位数.

由于五个数的中位数要大于其中两个数而小于另外两个数. 所以这里出现了四个大小关系, 对应了我们至少要进行四次比较来得到中位数. 那么, 我们是否可以随机挑一个数x, 然后把x和其他四个数比较呢? 显然是不行的, 因为x如果不是中位数, 那么这个策略就失败了.

上面的分析给了我们两点基础结论. (1) k至少是4. (2) 如果只进行4次比较, 则不能在4次比较中都包含同一个元素. 事实上, (2)蕴含了一个结论, 最优解中必定存在四个不同元素, a和b. c和d比较过 (标记为结论*). 因为如果进行5次以上比较的话则显然; 如果进行4次, 而不能用(2)的比较方法的话, 这个结论也是成立的.

根据结论*, 我们假定对两个数做第一次比较, 把小的记做a, 大的记做b, 则有a
在这种情况下我们初步分析了如何进行比较的策略. 层层递推下去, 不难发现一个比较次数是6的解法. 我在这里做一个举例.

比较a和c, 由对称性得到 a

\begin{array}{ccccc} eacbd (A)&aecbd (A)&acebd (B)&acbed (C)&acbde (C)\\ eabcd (D)&aebcd (D)&abecd (E)&abced (C)&abcde (C)\\ eabdc (D)&aebdc (D)&abedc (E)&abdec (F)&abdce (F)\\ \end{array}

我们把这个15个排列用ABCDEF做标注. 第四步的比较将在b和e中进行, 这样我们就把ABD和CEF分开了.

对于剩下的两步来说, 只剩下我们可以
比较b和c分开ABD;
比较c和e分开AB;
比较c和e分开C和EF;
比较d和e分开E和F.

而对于ABCDEF每一个集合, 它们的中位数都是一致的. 这样我们就巧妙地利用6次比较, 找到了5个数的中位数.

这个解法看似比较复杂, 而实际上从白纸开始也不难推导出来.

首先前两次比较是一个比较显然的结论;
其次, 在之后的每一次比较中都以拿到最大的信息为目标逐步递进, 这样基本上就在正确的方向上了.

注意, 在这个问题中, 我们其实是在对5个数的全排列的集合做分割, 直到剩下的每一个集合中都只有唯一的中位数.

排列的分割(division on Permutations)

拿到一种排列方法之后, 一个问题就自然而然地产生了. 这个方法是最优的么? 会不会存在一种方法, 使用更少的比较次数而找到确切的中位数呢?

为了探究我们的方法是不是最优的, 我们必须对这个问题采用严谨的分析. 事实上, 上述的结论*是可靠的. 我们从结论*出发, 来推一下剩下情况的可能性.

第三个比较, b和e的比较实际上是必要的. 因为无论如何, 必定存在一个比较, 并且e参与其中. 那么, e和a,b,c,d比较是具有对称性的 (小于和大于也是对称的).所以, b和e的比较是一个对称性压缩的结果. 而仔细观察上表中的三次比较之后所剩的15个排列. 这15个排列中有5个不同的中位数, (BE一个, ACDF各一个), 而每一次比较只能将排列的集合分成两类, 所以两次比较不可能将这15个排列分成5类.

这样我们就证明了, 我们上述的解法是最优的.

Problem1.1的解
最少的比较次数是6次.
先比较两对数, 并标记a再比较b和e. 如果b大, 则依次比较bc和ce;
如果e大, 则依次比较ce和de.
上述论述证明了不存在比6次比较更少的比较次数.

事实上, 我们可以把这个找中位数的问题看做是一个和比较排序(comparison sort)类似, 但是较为简单的问题. 这两个问题有一个共同点: 它们的本质都是在对序列的全排列进行分割, 并且每次比较只能将现有的每一个集合分割成不超过两个. 基于这一点, 我们可以推导出比较排序的时间复杂度的下界.

排序问题的起始则是一个全排列的集合, 这个集合的势是n!. 其目标是将这个集合最终分割成n!个单元集合, 每个集合恰好包含这个序列的一个排列.

Problem2.1的解
比较排序的本质是将n个数的全排列分割成若干个集合, 每个集合里只有唯一的排列. 由于n个数的全排列最多有n!种, 而每一次比较最多可以将现有的每一个集合分割成不超过两个. 所以比较排序的时间复杂度的下界为 O(log(n!)) = O(n log(n)).
归并排序是一个时间复杂度为O(n log(n))的比较排序, 所以上述下界即为下确界.

对归并排序的时间复杂度分析见下文.

比较排序(Comparing Sort)

比较排序是一种排序方法的统称, 这些排序方法的共同特点是, 它们通过多次进行比较两个元素之间大小的方法来确定最终的序列. 我们在上文中得知, 比较排序所需的最少的比较次数是O(n log(n)), 那么, 一些典型的比较排序算法是怎么样实现排序的呢? 我们先讲几个简单的排序算法, 然后再结合分治法讲一些高效的排序算法.

我们知道, 在一个序列中找出其最小值/最大值, 是扫描一遍这个序列就可以得到的. 那么, 一个很自然的算法, 则是每次从序列中把最小值找出来, 然后将其删掉; 那么进行n次查找/删除操作之后得到的这个由找出来的元素构成的新的序列则是一个排好序的序列. 这种方法叫做选择排序(selection sort). 由于一次查找操作的时间复杂度是O(n), 所以选择排序的时间复杂度是O(n^2). (这里删除操作的时间复杂度被默认为O(1), 如果采用一般的随机存取线性数据结构来存储序列的话)

另一种办法则每次从序列中取一个元素出来, 然后将选出来的元素插入由已取出元素构成的排好序的序列, 直到所有的元素都被取出为止. 这种办法类似于玩扑克牌时的排序方法, 即每次抓一张牌, 然后把它插入已经抓好的, 排好序的牌中. 这里取元素操作占用O(1)的时间, 插入的时间则是O(n), 所以插入排序的时间复杂度是O(n^2). (仍然假定使用一般的随机存取线性数据结构)

还有一种排序方法叫做冒泡排序. 如果从左到右地对每两个相邻的元素进行比较, 并且把大的放在右边的话, 那么一轮则一定可以把最大的元素放在序列的最右端. 这个操作被称之为冒泡, 每次通过尝试交换来最终确定一个最大的元素(最小的亦可), 而被冒出来的这个最大的元素则属于已经排好的序列. 这样, 不断地对未排好的部分进行冒泡, 则我们可以使用n-1次冒泡来完成排序. 冒泡排序的一次冒泡时间是O(n), 共进行n次冒泡, 所以其时间复杂度是O(n^2).

三种基础排序算法中, 由于选择排序的时间消耗是和原序列存储方式相关的, 而插入排序的时间消耗是和新的"已取出的元素构成的排好序的序列"的存储方式相关. 所以两个排序方法的时间效率可以因这两个序列的存储方式而优化.

比如, 在选择排序中, 如果先把原序列存进一个最大堆/最小堆中, (插入时间O(log(n)), 选择最大/最小值时间O(1), 取出/删除时间O(log(n)), 再逐个将最大/最小值取出的话, 那么它的时间复杂度则被优化为O(n(log(n)). 这个方法又叫做堆排序.

再如, 如果在插入排序中使用二叉树来存储取出元素(平均插入时间O(log(n)), 最坏插入时间O(n), 二叉树打印序列时间O(n)), 并在最后将其序列打印出来的话, 那么得到了一个平均时间复杂度O(n log(n))而最坏时间复杂度O(n^2)的排序方法. 这个方法叫做二叉树排序.

上述的二叉树排序可以用更高级的, 具有平衡操作的平衡二叉树来代替, 这样的话最坏插入时间也缩减到了O(log(n)), 整个排序的时间复杂度变成了O(n log(n)). 即平衡二叉树排序.

前文中所提及的一系列排序算法, 其每轮操作都是挑选出一个元素. (冒泡排序本质是一轮选出一个最值) 那么, 有没有更好的策略来对这个序列进行排序呢?

快排与归并排序(Quick-sort & Merge-sort)

我们在算法漫谈的第二节, 矩阵方幂与矩阵乘法这一个部分里, 提到了分治法(Divide and Conquer)来将主问题划归成多个子问题的策略. 事实上, 这个策略同样可以广泛应用于排序方法里.

在我们拿到一个序列之后, 一个很自然的分治思想是, 可否把这个序列分成两份, 而分别处理呢? 基于这个分治思想, 我们可以联系到两种不同的排序思想.

第一, 我们挑出一个元素, 把比这个元素小的所有元素作为一个子序列进行递归, 排好之后放在它左边; 把其它比这个元素相等或者大的所有元素作为一个子序列进行递归排序, 排好放在它右边.
第二, 我们把这个序列左边的一般进行递归, 使得其左边一半已经排好; 右边一半也这样做; 然后我们把排好的两个子序列进行合并, 这样就可以排好整个序列.

第一种方法对应快速排序, 第二种方法对应归并排序. 以归并排序为例, 一次合并操作所需要的时间是O(n), 而假设归并排序的时间复杂度是T(n)的话, 则可以得到T(n) = 2T(n/2)+O(n). 这个递推公式对应T(n) = O(n log(n)), 换而言之, 归并排序由于其分割的均匀性, 递归的层数会被恰好限制在O(log(n))层.

事实上, 如果完美利用分而治之的思想, 则我们总可以通过O(log(n))层递归来解决这个排序问题. 然而快速排序的时间复杂度分析则比归并排序要复杂很多. 注意, 在快速排序中存在一定概率, 使得挑选的这个元素恰好是最大值, 或最小值. 这样会导致"分而治之"的这两个序列一个是空的, 而另一个具有n-1的长度. 那么最坏情况下我们需要递归n-1层, 即快速排序的最坏时间复杂度为O(n^2).

那么快速排序的平均时间复杂度是多少呢? 我们可以认为快速排序中, 挑选的元素会把序列分成两份, 长度分别为 q 和 n-1-q, q在0到n-1上面均匀分布. 即:

$$ T(n) = O(n)+\Sigma_{q=0}^{n-1} (T(q) + T(n-1-q)) $$

经过一系列复杂的运算, 我们可以得到T(n) = O(n log(n)). 即, 快速排序的平均时间复杂度是O(n log(n))的.

这个快排平均时间复杂度的式子解起来不是很容易, 其大致思想是用两个O(n log(n))的函数来上下逼近T(n), 从而得到T(n) = O(n log(n))的结论.

有兴趣的读者可以参照算法导论的相关章节.

我们可以看到, 分治思想在排序算法中可以很大地提高排序的效率. 在不借助高级数据结构的情况下, 使用分治法进行快速排序/归并排序, 可以将其平均的递归层数限制到O(log(n))的级别上, 从而得到平均时间复杂度是O(n log(n))的排序策略.

两个性质(Two Properties)

我们再讨论一下比较排序算法的两个性质.

就地排序(inplace sorting)是指在只允许额外使用常数空间的情况下完成排序. 这种情况下不能额外建立一个新的序列, 或是一个高级数据结构. 冒泡排序是一种典型的就地排序; 朴素的, 不使用高级数据结构的选择排序和插入排序都可以实现成就地的排序; 快速排序可以通过大量的交换操作实现成就地排序.

我们的题目 Problem 3.1 就有就地排序的要求. 在后文中, 我们将采用一系列交换操作的策略, 来用就地排序的方式实现对这个问题的解答.

稳定排序(stable sorting)是指如果一个序列中有若干个大小相同的元素, 则他们在排序算法中相对位置不发生改变. 在算法的运行过程中, 对未排好序的序列进行远距离元素交换, 是导致排序算法不稳定的重要原因.

冒泡排序如果大小相同的相邻元素不交换, 则为稳定排序; 选择排序和插入排序则可以实现成稳定排序; 归并排序可以实现成稳定排序; 朴素的, 就地的快速排序是不稳定排序, 但快速排序有实现成稳定排序的空间.

Problem 3.1的解(Solution to Problem 3.1)

显然, 使用一种时间复杂度为O(n log(n))的就地排序即可将Problem 3.1解决. 但是这个算法不一定满足最快的条件. 因为Problem 3.1中的序列只有0, 1, 2三种元素, 相比于一般的序列排序, 其全排列的个数只有3^n. 对这个全排列取对数, 即最小分割次数的话, 我们得到O(n log3) = O(n). 也就是说, Problem 3.1中的序列的排序时间复杂度下界是O(n), 我们有了充分的理由去探索线性的排序方法.

我们先考虑一个更简单的情况. 假如在Problem 3.1中, 只有0, 1两种元素的话, 我们可以如何排序.

答案比较简单, 一个不难想到的线性的排序方法即可实现. 假定我们采用一个指针a. 在任意时刻, 如果a对应的元素是0, 则让a一直右移. 我们清晰地看到, a左边的序列部分, 一定全部都是元素0.

那么, 如果a遇到1之后应该如何操作呢? 事实上, 我们需要找到一个右边的某个0与其交换(这里可以假设为是右边离a最近的0), 并且将a右移一格. 这样, 我们只要再使用一个指针a'就可以了.

一般地, a'是独立于a的另一个指针. 也是从左开始. 如果a向右移动超过了a', 则a'跟着向右移动, 保证其在a右面. 每当a遇到一个1时, a'不断向右移动, 直到找到第一个0, 那么这个0就是右边离a最近的0. 把这个0与a上的1交换, 并且将a右移一格.

这样我们保证了两个性质. 一个是前面提过的, a左边通通为0; 另一个则由于a'在寻找右边离a最近的0, 所以a和a'之间一定都是1. 这样的话, 当a'扫描完整个数组时, 则排序就完成了. 这个算法对序列从左到右只扫描了两次, 所以其复杂度为O(n).

现在我们解决了一个Problem 3.1的问题的简单版. 那么, 在有三个元素而不是两个的时候, 我们能否用类似的方法解决呢?

答案是肯定的, 我们只需要同样地使用两个指针b和b', 从序列的右端开始就可以了.

Solution 3.1
当n充分大时, 序列的全排列有3^n个, 所以其比较排序的时间复杂度下界是O(log(3^n)) = O(n). 我们下面提出一种O(n)的算法.
初始化4个指针, a, a', b, b'. 一开始a,a'都在序列的最左端, b,b'都在序列的最右端.
1) a遇0则向右移动; 如果a'在a左边或重合, 则a'也向右移动, 保证在a的右边;
2) b遇2则向左移动; 如果b'在b右边或重合, 则b'也向左移动, 保证在b的左边;
3) 当a遇到了非0, 且b遇到了非2时, 则a'和b'向中心移动: a'和b'跳过所有的1, 并在0或2的地方停下来. 如果a'和b'直到相遇都没有遇到0或者2, 则排序完成, 算法结束;
4) 如果a'和b'停了下来, 那么a'和b'指向的元素中, 必有0或者必有2; 如果有0, 则用0和a指向的元素交换. a继续右移; 如果有2, 则用2和b指向的元素交换, b继续左移.
5) 反复进行上述四个步骤, 直到a'和b'相遇, 则算法结束, 排序完毕.

桶和基数排序(Bucket-sort & Radix-sort)

我们观察到, 当数域缩小到一定范围时, 例如Problem 3.1, 我们的排序速度可以加快. 一般地, 对于一个数域范围为m的长度为n的序列, 当n充分大时, 其全排列的个数是m^n. 那么, 我们可以得知其排序时间复杂度的下界是O(log(m^n)) = O(n log(m)).

注意一点区别. 在对Problem 3.1解答时, 我们虽然使用了排序, 但是并没有任何比较操作. 我们进行的其实是一种比"比较"更简单的操作, 即看一个元素是不是0, 是不是1, 或是不是2.

这样的排序不属于比较排序的范畴. 同理, 我们现在所谈及的基数排序也不是比较排序的范畴.

根据如上分析, 我们得到一种新的, 不基于比较的排序策略. 我们将数域m映射到log(m)个维度上, 则每一个维度的数域都是常数. 扫描整个序列 log(m) 次, 得到每个元素在每一个维度上的值. 上述过程即完成了对这个序列的排序.

为了弄清楚这个排序的过程, 我们举一个具体的例子. 假如我们有0到9的一堆数, 那么我们可以准备十个桶. 对于每一个数, 把它按照数值装进对应的桶内(插入时间O(1)), 之后我们按照桶0到桶9的办法把所有的数值收集下来(打印时间O(n)). 那么, 这个排序就完成了, 其时间复杂度为O(n). 这个排序叫做桶排序(bucket sort).

通常来讲, 桶排序的时间复杂度是O(nm), 就像上述例子一样, 不对数域m进行映射. 不过这个时间可以优化到O(n log(m)), 即基数排序(radix sort), 或者多维的桶排序. 这log(m)维的空间的每一维对应基数排序概念中的基数.

比如我们现在有一些自然数, 在0 ~ 9,999,999之间. 那么现在这个自然数数域有7位, 我们就打算对它们递归地排7轮. 第一轮观察它们的最高位, 即百万位, 准备10个桶, 分桶装好后得到10组数, 这10组数的组组之间已经排序完毕.

之后我们递归地对十万位进行桶排序, 排好后继续递归, 直到每一位都排序完毕. 之后用O(n)的时间打印出来. 这个对不超过7位的自然数的, 时间复杂度为O(n log(m))的排序, 就是一个典型的基数排序.

当然了, 基数排序对属于要求比较苛刻, 更不能用于一些无限数域的元素之间的排序. 往往只有在数域范围远远小于序列的长度时, 才使用这个方法, 否则得不偿失.

"算法精讲"系列之开篇词

Fri, 30 Sep 2016 21:38:45 GMT

我的博客的上一个系列, 即"算法漫谈"系列, 于两年前的夏天已经完结. 此后繁忙于诸事, 亦无暇打理博客空间. 偶有读者反馈一些问题, 我便逐个修复.

然而近两年, 助教工作已成为我工作中不可少的一部分. 我助教的课程涵盖Programming Languages (内容主要涵盖编程语言的类型化定义和函数式类型方法, 区别于'学习一门编程语言'的课程), 计算机理论, 编译原理, 和算法, 受众也从本科生, 硕士生涵盖到博士生. 这时我便有一种想法, 即把助教工作中的一些知识点和自己对数据结构与算法的认识结合起来, 写一些东西放在博客上.

加之近日, 身边有不少同学和朋友也在频繁更新博客. 我在浏览他们的文章同时, 再次感到书写博客对于梳理一些心情杂感, 或是强化对一些知识点的认识, 亦或是与身边的同学朋友的交流, 都是有一定帮助的.

闲暇之余, 我决定再重新开启一个系列, 名为"算法精讲"系列, 从自己几年来的助教经验以及对数据结构和算法的知识出发, 谈一谈在计算机领域应用比较广泛的几类算法, 也顺便解答几道算法题目, 希望可以与同在计算机领域学习或工作的读者产生一些共鸣.

超图模型与"分析树"

Mon, 30 Jun 2014 01:55:27 GMT

在前文中, 我们谈到了定义在半环上的动态规划及其适用范围, 以及动态规划在图模型中的一些应用。本文我们将沿着这个思路继续探索, 并把目光从图模型转向树结构. 我们首先提出以下几个问题:

Problem 1.1
试判定一个字符串是否属于一个上下文无关文法生成的语言.

Problem 1.2
给定一个字符串和一个随机上下文无关文法 (PCFG) , 则按照 PCFG 中的某个生成方式生成该字符串会有一个概率 p . 试求 p 的最大值.

本文将对上述问题展开讨论. 在涉及分析树的内容之前, 我们先对前文的内容做一个小小的总结, 之后我们解决上述的两个问题. 除此之外, 我们还将提及一个数据库系统中的查询模型. 笔者的研究不涉及数据库领域的很多内容, 对这个模型的理解也比较粗浅, 在这里只是提供一个树结构上的算法思路.

Problem 2.1
现在有一个数据库系统, 其中不同的机器存储不同的数据. 试设计一个查询系统, 使得用户可以在最短的时间内查询到特定的数据被存储在哪个机器.

Problem 2.2
弱化Problem 2.1的需求. 现在我们查询特定的数据后, 允许得到一个机器的列表, 只要列表中存在一个机器存有我们所需的数据即可. 试优化这个查询系统.

超图(Hypergraph)

我们已经在“ 舞动在半环上的 ‘动态规划’ ” 和 “从动态规划到 ‘k最优Dijkstra算法’ ”两篇文章中详细地探讨了动态规划在半环上的定义及适用范围, 以及动态规划的一些应用. 现在我们把之前谈及的几个算法按照模型的结构做一个简单的分类.

第一类是基于列表结构的动态规划, 主要的例子有最长公共子序列 (LCS) 等. 在这种结构下我们可以非常清晰地看到拓扑顺序, 在其上设计一个状态转移(状态合并)的方法即可. 我们再举几个典型的问题, 供大家思考. 注意在设计算法时, 要保证状态合并前后单调性仍然保持.

Problem 3.1.1
试求两个字符串的最长公共上升子序列 (LICS) .

Problem 3.1.2
给定三个字符串, 试求前两个字符串的最长公共子序列, 要求该子序列 s 不含第三个字符串作为 s 的子序列. (LCS w/o. subseq)

Problem 3.2.1
试求一个数组中连续 k 个数的和的最大值.

Problem 3.2.2
试求一个矩阵中行列连续的子矩阵中数的和的最大值.

第二类是基于复合链式模型的动态规划, 主要包括维特比 (Viterbi) 算法适用的一些问题, 主要包括求最优链的问题. 这类问题中不同的链有一些公共的节点, 但是整个空间仍然保持拓扑结构, 因此可以使用 Viterbi 算法按照拓扑层次求解. 从路径的角度来讲, 任意一个没有前驱的节点都可以作为起点, 任意一个没有后继的节点都可以作为终点. 这是一个典型的交错链表.

第三类是基于图模型的动态规划, 主要包括计算最短路径 (第 k 短路径) 和最小生成树的一些算法. 注意这类问题的本质有所区别. 一部分是定义在优幂等半环上的问题 ("事情总是会变得越来越差"), 另一部分模型不具有优幂等的属性, 因此设计状态转移时会略微复杂一些, 以保证状态合并不改变单调性. 有负权边的最短路径问题属于后者.

现在我们继续扩展, 给出超图的定义. 一个超图 (hypergraph) 的节点和图的节点类似, 超图的边 (hyperedge) 是多个节点的集合. 也就是说, 在图中每条边只连接两个节点, 图是一种特殊的超图. 在有向超图中, 每条边的节点被严格划分为两类, 一类点是这条超图边的起点, 另一类点是终点.

举一个例子, 一个典型的有向超图中每条超图边都有一些起点和一个终点. 在这个超图中, 我们仍然可以求一个点集到另一个点集的"最短路径". 如果这个超图本身满足严格的拓扑结构, 我们可以把维特比算法在这个超图上做一个拓展, 用广义维特比算法 (Generalized Viterbi Algorithm) 来求解这个问题. 这一点是比较好理解的.

当上述超图不满足拓扑结构时, 我们仍然可以把图模型中的一些算法引申过来. 打个比方, Dijkstra 算法把图中的节点分为两个类, 起初第一类只有起点 s , 根据其可达的最近节点不断拓展而得到终点 t . 在超图中我们用相同的方法, 从起点集开始探索其可达的最近节点, 直到得到终点集中的一个节点终止. 这种把 Dijkstra 算法拓展到超图模型的情形叫做 Knuth 算法. 类似地, k 最优 Dijkstra 算法可以拓展为 k 最优Knuth 算法.

事实上, 这个典型的有向超图是超图中应用最广泛的例子. 我们用一个非常直观的问题来解释它.

派生树(Derivation Tree)

我们在很多领域会涉及到一些基本的推导 (deduction) 或者证明 (proof) . 从给定的条件(condition) 或者规则 (rule) 出发, 推出我们所需要的结论. 打个比方, 我们现在有如下的三条规则:

\begin{aligned} r_1 &: A \to B \\ r_2 &: Bt \to v \\ r_3 &: \frac{t_1 \to t_1'}{t_1t_2 \to t_1't_2} \end{aligned}

那么我们可以通过一个简单的推导过程来推导式子"AC". 我们采用竖式写法来表示其推导过程 (deduction) , 用树形结构来表示其派生过程 (derivation) . 其中, 派生树 (derivation tree) 又被称之为证明树 (proof tree).

Deduction: \begin{aligned} & A \to B \ (r_1) \cr \Rightarrow & AC \to BC \ (r_3) \ * \cr & Bt \to v \ (r_2) \cr \Rightarrow & BC \to v \cr \Rightarrow & AC \to v (*) \cr \end{aligned} Derivation: $$ \Large \frac{\frac{(r_3), (r_1)A \to B}{AC \to BC}, (r_2)Bt \to v}{AC \to v}$$

现在我们思考一个很直观的问题. 为什么这个推导过程会产生一个树形结构的派生树, 而不是链式结构?事实上我们在竖式中也看到了, 很多步骤推导需要借助其他步骤的结论, 因此竖式推导也并不是一个链式结构.

这是因为, 绝大多数的推理过程, 都存在"多个条件推出一个式子"的中间过程. 这个过程的产生源于两个方面. 第一, 很多推理系统中存在一些规则, 支持由多个条件推出一个式子, 比如上述规则中的 r3, 就只能结合另一个条件 t1 -> t1' 来一起使用; 另一方面, 我们需要用多对一的方式来实现推理的传递性, 比如上式中我们推出了 AC -> BC, BC -> v, 我们需要一个"二对一"的方法来把这两条规则结合成一条规则.

这样的话, 推理结构就很自然地形成了一个超图结构. 考虑我们前述的典型超图模型, 每条边都可以有一个或者很多个起点和一个终点. 派生树在超图模型中的每一个节点是一个式子 (term), 每一条超图边表示推理的方向. 推理系统的应用非常广泛, 我在之后的文章里面会提到.

上下文无关(Context Free)

我们现在试图关注另一个推理系统. 注意到, 上面的推理系统中每一个节点是一个式子, 而超图边只代表推理的方向, 超图边的本身并没有实际意义. 那么, 一个很自然的想法就是, 如果我们使用了规则 A -> B 的话, 能否做一个建模, 使得我们可以用一条边来连接 A 和 B 呢?

答案是否定的. 注意上面的例子. 我们可以用规则 r1 来推导出 A -> B, 但是在 AC 这样一个式子中, 必须借助 r3 这样一条规则才能够推导出 BC. 加入我们现在的式子是 CA, 那么根据上文的推理系统是无法退出 CB 的. 换而言之, 如果有上下文限制, 那么子串的推导规则就不能用在母串中. 上下文限制决定了在这个规则系统中无法用节点来表示字符单位, 超图边来承接规则.

一般的推理系统中需要设计一些诸如 r3 的规则来帮助一些子规则运用到上下文环境中. 一般地, 这样的规则称为一致性规则 (congruence rule), 而诸如 r1, r2 这类直接的推导规则叫做计算性规则 (computation rule).

根据上面的分析我们可以得知, 对于上下文无关的规则系统, 我们可以用一套更直观的超图结构来表示它: 每一个节点是当前字符单位, 我们称之为符号(symbol), 每一个超图边代表了一个规则. 在上下文无关环境中没有一致性规则, 只有计算性规则, 每个计算性规则都可以被超图结构中的超图边所表示. 上下文无关的推理系统尽管是广义推理系统的子集, 但是应用却非常非常的广泛. 数学算式, 绝大多数编程语言和其它非自然语言, 都是在上下文无关环境中构建出来的.

语言 (language) 是由文法 (Grammar) 定义的. 文法类似于一套推理系统, 但是更侧重在字符串上的定义. 一套文法可以生成句型 (sentential form) , 句子 (sentence), 从而生成语言.

而字符串的每一个字符属于一个字母表(alphabet), 因此文法都是定义在字母表上的.

文法 (Grammar) 是定义在一个字母表 A 上的集合 G = {Vt, Vn, S, P}. 其中 Vt 是终结符号 (terminal symbol) 的集合, Vn 是非终结符号 (non-terminal symbol) 的集合, S 是开始符号 (start symbol) 的集合, P 是规则(产生式)的集合 (production) .

语言学家 Avram Noam Chomsky 在1956年提出了一个形式文法的分类谱系, 把文法分成四种类型.

0型文法是没有任何限制的文法, 可以生成可枚举的语言;
1型文法是上下文相关文法 (Context Sensitive Grammar), 它的规则形如 aAb -> aA'b, 依照上下文可以从 A 推出 A';
2型文法是上下文无关文法 (Context Free Grammar), 在该文法中箭头左边只能有一个非终结符号, 任何规则都不需要依赖上下文即可应用;
3型文法是正则文法 (Regular Grammar), 它的规则形如 A -> a 或 A -> aB, 箭头右边只能向一个方向进行单链递归.

此外, 和图灵机一样, 文法还有很多变种, 包括随机文法 (Probabilistic Grammar) . 在随机文法中每一个产生式都有一个概率. 随机文法通常用来找到一个字符串对应的最大概率的产生方式.

我们在本文中讨论的是上下文无关文法 (CFG) 和随机上下文无关文法 (PCFG).

分析树(Parse Tree)

我们定义了上下文无关环境和其对应的超图模型, 那么根据这个模型我们会推出不同于派生树的一个树形结构, 我们称之为分析树(parse tree). 在分析树中, 每一个点代表一个符号, 包括终结符号和非终结符号; 每一条超图边由若干个符号指向一个非终结符号, 如 A -> aBb 这样的规则在分析树上表现为 a, B, b 三个顶点用一个超图边指向 A. 注意上下文无关环境中一个字符串中的不同字符分属于不同的顶点, 这是分析树的一个特点.

现在有这样一个问题. 我们描述的分析树是一个树形结构, 但却不是一个二叉树. 事实上, 几乎所有的上下文无关文法都可以对规则进行一些整理, 使得它们的规则只有 A -> BC (一个非终结符号分成两个非终结符号, 我们称这样的规则为二对一规则, binary rule) 和 A -> a (一个非终结符号变成一个终结符号, 我们称之为一对一规则, unary rule) 两种形式. 我们称这样的文法为 Chomsky 范式 (Chomsky Normal Form).

考虑到实际应用中会出现诸如 A -> B 的规则, 我们也可以把它算进 Chomsky 范式的一种规则, 无伤大雅. 本质上, Chomsky 范式只是保证了两点比较好的分析树的性质:

叶子节点全是终结符号, 非叶子节点全是非终结符号;
所有的超图边均有一个或者两个起点, 使得整个树的结构是一个准二叉树结构.

另外, 我们提到几乎所有的上下文无关文法都可以转化为 CNF. 事实上, 只要该 CFG 不含空串规则, 就一定能转化为 CNF.

现在我们整理出了一个很漂亮的超图结构. 我们知道, 给定一个文法, 我们可以任意地去让它派生出各种不同的字符串; 那么, 给定一个字符串, 我们如何判断它是否属于这个文法生成的语言呢? 这是我们在 Problem 1.1 中提出的问题, 结合 Problem 1.2, 我们介绍一些分析算法 (parsing algorithm), 来回答这个问题.

CKY算法(CKY Algorithm)

为了了解给定的字符串与一个文法的关系, 我们通常会根据文法来尝试地对该字符串构造分析树, 这种方法叫做分析 (parsing). 构造分析树所使用的算法统称为分析算法 (parsing algorithm).

首先我们来看一下 Chomsky 范式的性质. 首先, 一个长度为 n 的字符串中的每一个字符, 在分析树的最下层总会通过一个一对一规则转化成共计 n 个非终结符号. 其次, 这 n 个非终结符号一定会通过 n-1 个二对一规则来结合成开始符号. 如果非终结符号间存在一对一规则, 我们则需要对单一的非终结符号的自迭代.

考虑一个字符串s[1, n]在 Chomsky 文法下的某一个分析树. 在分析树的顶端是一个开始符号 S . 如果n>1, 那么 S 一定会分两个非终结符号 A 和 B, 它们分别是 s[1,j] 和 s[j+1, n] 的子树根. (严格来说这两个子树不是分析树因为树根不是开始符号 , 我们暂且称其为分析子树) 此外, 由于文法的二义性, s[i, j] 可能会归结为不同的非终结符号, 于是我们需要在它的子树根上枚举可能被归结的非终结符号.

一般地, 对一个字符串 s[1, n] 可以进行一个自底向上的分析算法. 我们以子串 s[i, j] 的长度为顺序. 首先对于s[i, i], 我们只需把终结符号用一对一规则转成非终结符号; 其次, 对于s[i, j], 假定长度比其小的s[i', j']已经分析完毕, 那么我们可以枚举其所有的断点 k , 通过搜索是否存在二对一规则结合 s[i,k] 和 s[k+1, j] 来找到s[i, j] 的可能非终结符号.

当我们所求的不是所有分析树, 而是一个分析树或者概率最高的分析树 (对于PCFG而言), 我们就可以在上述模型中加入合并策略, 从而进行动态规划. 考虑到s[i, k] 和 s[k+1, j] 归结到 s[i, j] 这一过程, 我们不需要知道两个分析子树的内部情况, 只需要知道它们可能的非终结符号(及其概率)即可. 因此, 归结 s[i, j] 时, 我们可以合并相同的非终结符号即可. 这种运用了动态规划的分析算法叫做 CKY 算法(CKY algorithm), 又称 CYK 算法.

CKY 算法, 又称 CYK 算法, CKY 分析算法 (CKY parsing algorithm), 是Cocke, Younger, Kasami三人于1965年合作研究出来的分析算法. 该算法可以适用于一切CFG, 用来判断一个字符串是否属于一个 CFG; 以及一切 PCFG, 用来寻找一个字符串在该 PCFG 下的最大概率.

CKY 算法的描述非常简单. 按照子串长度从小到大枚举每一个子串(共计 O(n^2) 个子串), 对于每一个子串s[i, j] 而言, 枚举所有的断点( O(n) )和所有的规则( O(R), R是规则的个数 ), 来更新 s[i, j] 的子树根上的非终结符号(及其概率). CKY算法的时间复杂度是 O(R*n^3).

我们用CKY算法可以直接回答 Problem 1.2.

Answer 1.2
使用 CKY 算法对该字符串进行分析, 可得最大概率及其对应的分析树.

对于Problem 1.1, 我们考虑到 CKY 算法的复杂度较高. 有一种特殊的上下文无关文法 -- 无二义性文法, 在无二义性文法中一个字符串最多只有一个分析树. 无二义性文法更加规范一些, 可以采用时间复杂度很低的分析方法, 在编译领域有广泛运用. 比较典型的有 LR 分析器, LALR 分析器等. 此处不再赘述.

Answer 1.1
考虑该上下文无关文法是否属于一些更规范的文法, 如 LR(k) 文法等. 如是, 则可以用该文法对应的低时间复杂度的分析器. 否则, 一切上下文无关文法都可以采用 CKY 算法来分析.

树(Tree)

我们在前面讲了两个典型的超图模型的应用实例. 现在我们用典型的超图模型把树结构定义一下.

树 (tree) 是一个具有拓扑结构的超图,它的每一个超图边都只有一个终点, 且每一个节点至多被一个超图边所指向. 树中存在一个唯一的拓扑顺序最靠后的节点, 我们称之为树根. 特殊地, 如果每一个超图边均有两个起点, 则我们称之为二叉树.

注意树在有向图上的定义. 两个定义的区别在于图认为一个父亲与 k 个儿子的关系是用 k 条边表示的, 每条边只表示一个简单的父子关系; 而超图把一个父亲和其所有的儿子用一个超图边来表示. 两个定义是相通的.

特殊地, 二叉树 (binary tree) 所对应的超图的每条边有至多两个起点和一个终点. 在 Chomsky 文法之下每一个分析树都是二叉树.

在分析 (parsing) 的领域中 hypergraph 的运用非常的广泛. 有兴趣的读者可以参阅UC Berkeley 的 Dan Klein 与 Stanford University 的 Chris Manning 合作的文章 "Parsing and Hypergraphs".

我在前文提及的文章"Advanced Dynamic Programming in Semiring and Hypergraph Framework" 中也对超图上的动态规划方法进行了一个总结.

树结构有一个天然的"合并"过程, 我们可以把它看做是 n 个叶子经过一系列超图边合并到一个根节点的过程. 因此, 自底向上地在树结构上运用动态规划方法是一个一般化的方法. Problem 2.2 是一个数据库上的查询优化问题. 我仿照上述的一般化方法提出了一个优化策略, 跟某大牛做过一些讨论, 因此想把它写出来.

线段树(Segment Tree)

我们不妨用二叉搜索树来实现 Problem 2.1中的查询系统. 如果将每一个非叶子节点采用区间表示的话, 那么我们就得到了一个线段树.

线段树(segment tree)是一种数据结构, 它是基于区间的二叉搜索树. 对于一个父亲节点所表示的区间[a, b], 存在一个该区间中的数 c, 使得两个儿子节点分别表示 [a, c] 和 [c, b]. 一般来说 c 会取 a 和 b 的平均值.

Answer 2.1
对每一个数据的查询字串 (key) 进行一个编码, 并采用线段树来实现这个查询系统. 在这个查询系统中, 除了叶子节点以外的部分与线段树类似, 叶子节点则分别存储该对应的数据所在的机器编号.

现在我们考虑对这个查询系统做一个优化. 考虑在一个实际的数据库系统中, 由于查询系统只能存储在一个主机上, 而成千上万的查询都需要通过这个主机来得到其数据所在的机器. 那么, 我们希望并非每一个查询都要搜索到线段树的底部, 从而来减少主机的负担.

一个可行的办法就是, 考虑到数据存储在不同的机器上, 对不同机器做查找的过程是可以并行的. 那么我们便尝试对这个二叉搜索树进行一个比较浅的查找, 使得我们可以得到 k 个机器的一个集合, 其中我们所要的数据一定存在某个机器上. 拿到这个集合之后, 我们便可以分别向这 k 个机器去获取数据, 这样的话便可以通过较低的查询代价和较高的获取代价来得到我们所要的数据.

我们提出了一种预处理+启发式搜索的方法来解决这个问题.

Answer 2.2
对于这个查询系统, 我们在每一个非叶子节点上记录一个集合, 代表以该叶子节点为根的子树中所有的数据所在的机器的集合. 如下即是初始化, 查询和维护操作.

初始化: 自底向上进行一次动态规划. 默认叶子节点表示的机器即为该节点的集合. 对于一个超图边, 合并两个起点的集合从而得到终点所在的集合. 我们可以规定一个深度 d, 并只对深度不低于 d 的节点进行初始化. (考虑到深度过低的节点集合中的元素比较密集)

查询: 采用一个启发式搜索的方法, 对该线段树自顶向上进行查找. 可以通过当前所在节点的集合的势, 以及当前所在节点的深度, 甚至查询系统的繁忙程度来决定搜索深度, 只要深度不小于 d 即可. 查找停止之后, 便对该集合的所有机器获取数据, 这样必有一个机器会给出所需数据.

维护: 对于数据插入, 数据删除, 数据修改, 只需要进行一个 O(D) (D 为树的深度)的操作, 更新其所有祖先的集合即可. 对于数据插入和修改, 如果看到一个祖先早已有其所在机器则停止; 对于数据删除, 则需要更新每一个祖先的同时查看其另一个儿子.

注意到, 这个方法在预处理中也用到了一些动态规划的思想. 总体来说, 树结构的自底向上的动态规划, 其对节点和超图边的访问顺序大体上是相似的.

启发式搜索中的寻路问题 -- 一篇课程报告

Fri, 16 May 2014 05:30:22 GMT

最近在这门课的课程论文上写了一个 survey , 主要涉及了一些常见的寻路问题, 包括寻找最短路径的若干问题,寻找第 k 短路径的若干问题以及未知全局的寻路问题. 本来想把论文的内容翻译出来贴在博客上, 后来发现和之前的几篇博文有一部分重复的地方, 只有几个算法在博客中没有提到. 于是决定把摘要目录翻译一下, 另直接把文章贴出来和大家分享.

原文章使用英文撰写, 题目是. 内容上主要以讲算法的动机, 内容和效率为主, 也有一些不同算法之间的比较. 翻译如下.

题目: 关于启发式决策中寻路问题的求解框架之调查

摘要: 寻路问题及其求解策略在人工智能及其之外的领域有着重要而广泛的应用. 自20世纪70年代以来, 便出现了大量的总结性工作, 试图把不同种类的寻路问题求解算法归纳在一个统一框架里. 该文在这些工作中作了一系列调查研究, 并通过一个逻辑主线在不同问题的求解策略之间建立了联系. 该文主要围绕这些方法的动机, 适用性和性能进行探讨, 一些典型的应用和扩展也会被涉足.

目录:
1. 引言
2. 图模型中的寻路问题
2.1 有向无环图中的基本寻路策略
2.2 有环图中的基本寻路策略
3. 基于搜索顺序的启发式决策
3.1 有向图模型中的启发式搜索
3.2 优先队列与搜索顺序
3.3 有向图模型中的改进
3.4 无向图模型中的启发式搜索
3.5 几种策略间的比较
4. 复杂需求上的启发式方法
4.1 方块剪枝与复杂寻路
4.2 复杂寻路问题上的 k 最优启发式搜索
5. 在线搜索中的启发式方法
6. 拓展与讨论
7. 致谢

文章用的LaTeX模板不是很好, 以后考虑改进一下. 原文链接如下:

PDF file in Google Drive

欢迎大家批评指正!

从动态规划到"k最优Dijkstra算法"

Sat, 12 Apr 2014 05:23:56 GMT

写在前面

我们先提出与"回路"有关的几个问题.

problem 1.1
试分析存在回路的状态空间对动态规划是否具有适用性.

problem 2.1
在一个无负回路的图中有两个节点 s, t, 试求两点间的第 k 短路径.

对于第一个问题, 我们将沿着半环上的动态规划继续走下去, 探讨一下非幂等半环上的动态规划问题, 从而给出动态规划的一个更为广义的适用范围; 对于后面一个问题, 我们将从 Dijkstra 算法的适用性谈起, 并分析几个典型的最短路径问题的算法, 最后给出一个普适的求前 k 短路径的算法和一个非常漂亮的 k 最优 Dijkstra 算法, 来完成这个问题的解答.

维特比算法(Viterbi's Algorithm)

在 <舞动在半环上的"动态规划"> 一文中我们谈到, 对于幂等半环, 我们可以从偏序关系出发, 构建出状态空间的一个拓扑结构, 从而进行动态规划. 注意这里我们有两个不同的偏序关系的概念: 第一个是幂等半环中元素之间的偏序关系, 第二个是状态空间上的拓扑结构上的偏序关系.

那么, 如果元素之间不存在偏序关系, 我们能不能构造出这样的拓扑结构呢? 我们先举一个例子, 考虑一般的维特比问题.

假定现在我们有 k+1 层节点 V[i][j], 其中 i = 0, 1, ... k, 每一个节点存在一个权重 w ; 此外, 当且仅当两个节点处于相邻的两层时, 它们之间存在一条边V[i][j1] -> V[i+1][j2], 这条边也存在一个权重 e .

考虑一个半环 , 这里 (+) 和 (*) 是泛指. 现在我们对一个路径也定义一个权重, 这条路径的权重就是该路径上所有的点和所有的边的权重进行 (*) 运算的结果, 注意仅有一个节点的路径也是有权重的. 考虑任意一个节点, 对于它来说, 有很多条从第 0 层出发的路径抵达它, 每一条路径都有一个权重, 我们把这些权重进行 (+) 运算, 记为该节点的得分. 维特比问题就是求一个节点的得分的问题.

例如, 就是在这个图中求一个最短路径的问题. 再如, 就是求从第 0 层出发, 抵达一个节点的所有路径的权重之和, 其中一个路径权重是点和边的权重的积. 注意在这两个例子中, 前者是幂等半环, 而后者不是. 两者却都可以通过维特比算法进行动态规划.

维特比算法, 即用动态规划方法求解维特比问题的一种算法. 根据上面对维特比问题的定义, 我们很容易找到一个节点得分之间的状态转移方程.

$$ s(i, j) = \begin{cases} w(i, j) & i = 0 \\ w(i, j) * (+_{V(i-1, k) \in G} t(i, k, j)) & i > 0\end{cases} $$ $$ t(i, k, j) =s(i-1, k) * e(i-1, k, i, j) $$

之后, 我们可以从第 0 层出发, 按照层的顺序 (实际上就是拓扑顺序) 来求每一个节点的得分, 直到得到目标节点的得分为止.

关于维特比问题, 我们注意其中两点. 第一, 这个例子说明了只要状态之间存在拓扑结构, 我们就可以做动态规划, 而与半环本身是否幂等无关. 事实上, 对于幂等半环来讲, 我们很容易对元素间的偏序关系和状态间的偏序关系建立直观的联系, 这也是幂等半环易于构建算法且易于理解的原因之一.

第二, 维特比问题本身就已经给出了一个拓扑结构, 而实际问题中大多拓扑结构需要自己构造. 事实上, 对已经给定拓扑结构的问题, 采用动态规划方法是容易而且直观的, 我们只需关注效率问题(如何合并会更快); 而动态规划的难点在于如何构建一个拓扑结构.

回路(cycle)

现在我们对于动态规划适用性的理解扩充了. 只要状态空间存在拓扑结构, 其一定适用动态规划. 下面我们讨论一个状态空间中的复杂结构, 从而给出 problem 1.1 的解.

假定状态空间中存在回路, 即有 k 个状态 S, S[1] 指向 S[2], S[2] 指向 S[3], ... S[k] 指向 S[1]. 我们举个例子. 考虑一个图中的最短路径问题, 我们现在要求点 A 到点 B 的最短路径. 现在有 k 个点之间存在一个回路, 试问我们所要求的最短路径是否存在.

一个很显然的结论是如果这个回路遍历一周的权重是负数, 我们的最短路径肯定不存在. 因为, 在原有路径的基础上, 我们只需要沿着这个回路再走一遍, "最短路径"一定可以变的更短, 从而没有下限. 我们把这样的回路叫做负权回路, 或者负回路. 轻松可知, 存在负回路的图中不存在任意两点的最短路径, 只要这两点和这个负回路连通.

考虑另一种情况, 即这个图中不存在负回路. 事实上, 如果图中不存在负回路的话, 我们可以通过几种典型的动态规划策略来求解最短路径. 例如 Bellman-Ford 算法, 其优化后的 SPFA 算法, 以及 O(n^3) 就可以求出任意两点间最短路径的 Floyd 算法. 这些算法我们会在下面详细讨论.

我们关心这样一个问题, 就是对一个回路迭代有限次后, 其结果是否会收敛. 一般地, 对于任意一个半环和一个固定的正整数 k , 如果 (+) 运算迭代 k 次以上之后结果不会再变化, 我们则称这样的半环为 k-封闭半环.

的作者, 纽约大学的教授 Mehryar Mohri(森) 早在2002年的时候发表了一篇文章 , 其中包含了 k-封闭半环的内容.

有兴趣的读者可以参考一下.

从狭义上讲, 对于任意一个 k-封闭半环, 我们总可以通过拆分状态的方法把它转化成一个幂等半环. 对广义而言, 我们不必把简单模型复杂化, 直接对 k-封闭半环的结构构建动态规划算法即可.

Answer 1.1
如果存在一个正整数 k , 对于该状态空间的任意一个回路和任意一个大于 k 的正整数 k', 满足在该回路上进行 k' 次 (+) 迭代和进行 k 次 (+) 迭代的结果相同, 那么这个状态空间上是适用动态规划模型的. 反之, 如果找不到这样的 k (该回路对于 (+) 运算是发散的) , 那么这个状态空间对动态规划不适用.

最短路径(shortest path)

现在我们尝试解决problem 2.1. 在上文中我们提到了求最短路径问题的几个经典算法, 下面我们把这些算法梳理一下. 首先, 对于存在负回路的图, 一定不存在两点间的最短路径, 只要这两点和某个负回路连通.

一般地, 对于一个无回路的图 G 和 G 中的两个节点 s 和 t , s 和 t 之间存在若干路径. 最短路径问题就是求解这些路径中长度最小的. 其中, 一条路径的长度是该路径中所有边的长度之和.

现在我们讲一个最短路径上的重要性质, 这个性质是构建最短路径问题上几乎所有算法的出发点. 考虑 s 到 t 的最短路径 P(s, t) , 假定这条最短路径上经过了另一个节点 u , 我们则可以从 P(s, t) 中截取一段 P(s, u). 那么, P(s, u) 是点 s 到点 u 的一条最短路径吗?

这个问题为我们提供了一个分治策略的可能性. 假如 P(s, u) 一定是 s 到 u 的一条最短路径, 那么我们就可以类似地得到 P(u, t) 也一定是 u 到 t 的一条最短路径. 这样的话, 我们就可以把一个求最短路径的母问题分解为子问题了.

事实上, 我们可以在这条性质中得到一条关于松弛操作(relaxation)的信息, 并利用它建模求解最短路径问题. 我们分情况讨论.

假定图中的每一条边的权重都是正数. 那么, P(s, u) 一定是 s 到 u 的最短路径. 考虑反证法. 如果 P(s, u) 不是其最短路径, 那么必有另一条路径 Q(s, u) < P(s, u). 如果 Q(s, u) 不经过 t 的话, 我们得到了一个矛盾, 因为 Q(s, u) + P(u, t) < P(s, t), 因此 P(s, t) 不是 s 到 t 的最短路径; 如果 Q(s, u) 经过 t 的话, 我们把它拆成 Q(s, t), Q(t, u), 则我们有 Q(s, t) + Q(t, u) < P(s, u) < P(s, t), 进而得到 Q(s, t) < P(s, t), 矛盾. 因此 P(s, u) 一定是 s 到 u 的一条最短路径. 相似地, 我们可以得到, P(u, t) 一定是一条 u 到 t 的最短路径.

注意, 仅当每一条边的权重都是正数的时候上述不等式成立.

进而, 我们考虑另一种情况. 图中的边的权重可能是负数. 现在假定 P(s, u) = 3, P(u, t) = -1, 图中存在另一条不经过 u 的路径 Q(s, t) = 3, 以及一条 t 到 u 的路径 Q(t, u) = -1 (无向图不需此前提). 那么, 我们知道 P(s, u) 不是 s 到 u 的最短路径, 因为 Q(s, t) 不经过 u, 我们可以用 Q(s, t) + Q(t, u) 来作为 s 到 u 的一条更短的路径. 因此在有负权的边的时候, 这个问题的回答是否定的.

我们进一步考虑 s, u, t 这三个点的关系. 假如我们上述的几个路径之外不存在其他路径, 那么我们可以观察得知, s 到 t 的最短路径经过 u, s 到 u 的最短路径经过 t . 这是因为我们引入了 P(u, t) 和 Q(t, u) 两条负边. 这样的话, P(s, u) 被另一条路径 Q(s, t) + Q(t, u) 更新了.

我们加入时间顺序来考虑这个问题. 由于最短路径具有反向有界性, 我们会先把 s 到 u 的最短路径的上限设为一个极大值. 在我们找到了 P(s, u) 之后, 我们把这个上限更新成 P(s, u) ; 之后我们找到了另一条路径 Q(s, t) + Q(t, u), 我们继续更新这个上限. 每一次更新, 我们都把 s 到 u 的最短路径满足的一个上限做了一次强化, 类似于不等式中的松弛( a < 5 是 a < 3 的一个松弛, 所以两个条件同时存在时我们可以抛弃前者), 我们把一次更新称为一次松弛操作(relaxation).

总结一下我们讨论的两个情况. 对于每条边权值都为正的图, 最短路径的子路径也一定是一条最短路径; 对于存在负边的情况, 我们这个性质不成立, 但我们依然可以通过松弛操作来求解最短路径. 于是我们把这类最短路径问题分为两种, 一种是正权图的最短路径, 另一种是一般图的最短路径(无负权环皆可).

我们把现在讨论的问题称为"一类"最短路径问题. 因为基于不同结构的图(非简单图, 超图等等), 最短路径问题的变种有很多. 即便是对于一个简单图, 我们对第 k 短路径也有不同的定义. 比如另一种第 k 短路径考虑长度排序时相异值的第 k 短. 举个例子, 所求的第二短路径一定要比最短路径长, 第三短路径一定要比第二短路径长, 等等.

本文所讨论的最短路径和第 k 短路径是最一般化的定义.

迪科斯彻算法(Dijkstra's algorithm)

现在我们考虑正权图. 在正权图中, 最短路径的子路径一定是最短路径. 考虑一个点 s 到所有点的最短路径, 那么, 这些最短路径一定只有两种存在方式: 第一, 该最短路径 P(s, t) 只有一条边; 第二, 该最短路径 P(s, t) 是另一个最短路径 P(s, u) 再加上一条边 E(u, t) 构成的. 换言之, 首先我们可以找 s 出发, 只有一条边的最短路径; 其次, 给定从 s 出发, 有 k 条边的最短路径之后, 我们可以求出有 k+1 条边的最短路径. Dijkstra算法就是基于这个原则的一种贪心法.

贪心法, 是一种从局部最优出发, 每一步都选取局部最优, 从而试图达到全局最优的算法. 一切基于贪心策略的算法都必须有一个理论支持, 证明局部最优一定可以一步一步达到全局最优.

我们继续考虑最短路径问题在正权图上的重要性质. 注意, 从 s 出发的最短的一条边 E(s, v), 生成的单边路径 P(s, v) 一定是一条最短路径, 因为 s 经过其他点抵达 v 所花费的代价一定比它高. 进一步而言, 考虑一个包含 s 的子图 G', 它的点集是 s 和一些点, s 到这些点的一条最短路径包含在 G' 中. 那么, 从 G' 中任意一个节点出发的到 G' 之外的最短的一条路径 P(s, v) = P(s, u) + E(u, v) 一定是一条最短路径, 其中 u 在 G' 中但是 v 不在, P(s, u) 是一条 s 到 u 的最短路径. 这个原因和上面相同, 因为 s 经过其他点抵达 v 所花费的代价一定比 P(s, v) 高.

Dijkstra 算法便是利用上面的性质来不断地扩展子图 G', 直到 G' = G. 这个性质保证了局部最优一定可以达到全局最优, 因而 Dijkstra 算法所采用的贪心策略是正确的. 注意, G' 进行拓展之后, 只需要把新添加的点拿来对其相邻节点进行松弛操作就可以了, 这样做就可以不断更新 s 到 G' 之外的一个节点的最短路径.

1) s 到 s 的距离初始化为 0 , s 到其他点的距离利用反向有界性初始化;
2) G' 只包含 s , 用 s 对 s 到 s 的相邻节点最短距离的上界进行松弛操作;
3) 循环以下操作, 直至 G' = G: 找到 G' 之外的一个节点 u, 使得 P(s, u) 是最小的; 之后把 u 添加进 G' , 用 u 对 s 到 u 的相邻节点最短距离的上界进行松弛操作.

一遍 Dijkstra 算法执行下来之后, 就可以求出正权图中 s 到所有节点的最短路径.

迪科斯彻算法 (Dijkstra's Algorithm) 是一种典型的贪心策略. 该算法由荷兰计算机科学家 Dijkstra 于1956 年提出, 并于1959 年发表. 此后, Dijkstra 于1972 年获得图灵奖.

在荷兰语中 ijk 三个字符的音节发音类似英语的 like 中 ike 的发音, 因此把荷兰计算机科学家 Dijkstra 翻译成"迪杰斯特拉"不甚准确. 本文避开这个翻译问题.

Dijkstra 算法的空间复杂度是O(n), 我们只需要存储 n 个最短路径的上限, 对其更新即可. 时间复杂度分析牵扯到一些相对复杂的数据结构, 我们先分析一下它的开销, 之后解释这个事情.设图 G 中的边数是 E , 点数是 V , 则这个算法的开销总共有两个地方: 第一, 对于每一个 G' 的拓展, 我们都需要寻找一个 G' 之外路径长度最小的节点, 假定它的时间代价是O(find_min) 或 O(extract_min) ; 第二, 我们拿到一个新的节点之后需要利用它的所有临边进行松弛操作, 它的时间代价记为 O(update) . 对于后者来说, 我们考虑 Dijkstra 的整体过程, 每一条边都会被用来做一次松弛操作, 因此总共只会执行 E 次的松弛操作. 因此, Dijkstra 算法的时间复杂度 C 如下.

$$ C = O(V * findmin + E * update) $$

现在我们就可以解释为什么 Dijkstra 算法的时间复杂度分析牵扯到很多复杂的数据结构了. 如果我们用一个线性存储空间来存储 s 到所有点的最短路径的上界, 那么 find_min = V, update = 1. C = O(V^2).

可以看到, 当图比较稀疏的时候这个复杂度是偏高的, 因为 E 往往达不到 V^2 的数量级. 我们需要一种动态的数据结构, 既可以用低于线性的时间来取出最小值, 又可以降低一次更新的开销. 因而我们需要优先队列.

当前最好的方法是采用一种用 Fibonacci 堆实现的优先队列来存储这样 V 个需要维护的最短路径的上界, 在 Fibonacci 堆之下, update = 1, find_min = log V. 因此, Dijkstra算法的复杂度被优化到了 O(V log V + E).

这里的难点在于数据结构要求是动态的. 因为 G' 之外的点的集合在不断缩小, 因此每次弹出一个节点之后都需要维护这个数据结构, 使得下一次找最小值的开销依然会很低. 优先队列可以进行插入, 弹出和维护操作.

优先队列有不同的实现方法, 比如堆, 二项堆, Fibonacci堆等. 不同的数据结构对不同的操作的时间代价不同, 有优有劣. 仅考虑弹出最小值和更新节点这两个操作的话, 时间代价最低的是 Fibonacci 堆.

早在1987年, UCSD的教授 Michael Fredman 和 Tarjan (Tarjan 算法的发明者) 合作了一篇文章, 首创性地提出了 Fibonacci 堆, 并用它优化了一系列的算法, 其中包括 Dijkstra 算法.

有兴趣的读者可以参考一下.

松弛(Relaxation)

下面我们考虑第二种情况, 即有负权但是无负回路的图中的最短路径. 注意这种情况下虽然我们不满足之前提出的重要性质, 但是我们依然可以通过松弛操作来找到最短路径. 考虑到最短路径问题也是在一个半环的模型下进行的, 所以我们尝试做动态规划, 并且在这个过程中尽可能合并更多的状态.

注意到 Dijkstra 的本质是利用贪心策略合并了一系列的状态, 把状态空间压缩到了 O(V) 上面. 引入负权之后, 单调性不再保持, 因此我们需要对状态空间进行维度拓展以保证单调性. 未经优化的状态空间是所有的路径的集合, 我们需要从中找到一条最短路径.

现在假定我们有一个子图 G', 在子图中我们得到了所有点到所有点的最短路径. 现在在这个子图中新增加了一个点 v 以及 v 与 G' 中的节点的连边, 我们把这个新图设为G''. 那么我们需要多少次更新之后, 就可以得到 G'' 中所有点到所有点的最短路径?

注意, 尽管在 G'' 中路径的个数仍是指数级的, 但是我们可以利用 G' 中所有点间的的最短路径. 事实上, 我们并不需要考虑 G' 中边的分布, 仅考虑 G' 中所有点间的最短路径即可. 换言之, 在 G'' 中 s 到 t 的最短路径可以由一些路径 P 累计而成: P 是一条相邻于 v 的边; P 是 G' 中某两点间的最短路径. 这个结论可以由反证法轻松得到, 只需考虑新路径中 v 的分布即可. 那么, 我们从 G' 中所有点到所有点间的最短路径更新到 G'' 中所有点到所有点间的最短路径, 仅花了多项式时间的代价, 因为 G' 中指数级的路径个数被优化到了n^2条最短路径.

事实上, 我们并不需要选取 G' 之外的点 v. 对于一个图 G , 我们定义 R(V') 为 G 中任意两点间的最短路径, 其中这些路径只能经过V'中的节点, 不能经过其他节点. 那么, 我们通过上述方法可以在 O(n^2) 的时间从R(V') 到 R(V' + v) 过渡, R(V) 就是任意两点间的最短路径.

Floyd-Warshall 算法就是基于这个理论构建的. 我们用数字编号来表示所有节点, 假定O(i, j, k) 是从节点 i 出发到节点 j 出发只经过节点 1..k 的路径中的最短路径, 那么 O(i, j, k) 满足状态转移方程如下.

$$ o(i, j, 0) = e(i, j) $$ $$ o(i, j, k+1) = min( o(i, j, k), t) $$ $$ t = o(i, k+1, k) + o(k+1, j, k) $$

t 的本质是用 k+1 这个点对 P(i, j) 做一次松弛操作. 我们在实现的时候把 k 按照自然序从小到大做 n 次迭代, 每次迭代对全局任意两点间的最短路径做松弛操作即可. 其中 n 是 G 中点的个数.

Floyd 算法的本质是利用一个子问题的最短路径的集合来代替其边的集合, 从而把指数级的路径数量合并成多项式级, 进而完成动态规划. 它的时间复杂度是 O(n^3), 空间复杂度是 O(n^2).

负权回路(negative cycle)

通过上面的分析我们可以知道, Dijkstra 算法可以处理正权图中一个点到所有点的最短距离; Floyd-Warshall 算法可以处理有负边无负环的图中所有点到所有点的最短距离. 这样的话, 考虑 problem 1.1 中 k = 1 的情况 (即最短距离), 我们便可以做出解答了.

我们再介绍一种在有负边无负环的图中一个点到所有点的最短距离的算法, Bellman-Ford 算法. 弄懂了 Floyd-Warshall 算法的原理之后, 这个算法就很好理解了. 我们用每一条边来对 s 到所有点的最短距离做松弛操作, 这样的话 n-1 轮松弛操作之后, 就一定可以得到 s 到所有点的最短距离. 这个算法的复杂度是 O(VE).

为什么n-1次对所有边做松弛操作之后必定收敛呢? 因为一个最短路径的边的个数不超过 n-1, 我们对任何一个边的个数不超过 k 的最短路径可以通过 k 次松弛操作得到. 具体证明的思路和上述的方法类似.

1994年, 来自西安交通大学的段凡丁用优先队列改进了这个算法, 在这里提及一下. 改进后的算法叫做Shortest Path Faster Algorithm 算法(SPFA), 时间复杂度为 O(kE), 其中 k 在大多数图中是一个不超过 2 的常数.

解决实际问题时推荐使用SPFA来代替Bellman-Ford算法.

现在我们关心的问题是, 这几种典型的最短路径算法能否判断出一个图是否有负权回路呢?

首先我们可以肯定 Dijkstra 算法做不到, 因为它在有负边的时候就挂掉了. 考虑 Bellman-Ford 算法, 一个负权回路可以在每次迭代之后优化一条连通的最短路径, 因此我们只需要继续进行第 n 轮松弛操作就可以了: 如果第 n 轮操作中有任何一个最短路径被更新了, 那么这个图中一定有负权回路.

对于 SPFA 算法, 类似地, 我们只需要记录一下每个节点入队的次数即可. 如果一个节点的入队次数超过了一个值(最大可能的更新次数), 那么这个图中即有负权回路.

下面考虑 Floyd 算法. 事实上, 在这几种算法中, Floyd 算法判定负权回路是最方便的. 考虑到我们对所有点之间的最短路径进行了 n 轮的松弛操作, 而且存在一个负权回路的边长个数不超过 n , 因此我们在 n 轮的松弛操作之后, 这个负权回路上的点对自己的最短距离一定是一个负数. 换言之, 如果 i 在某一个边长为 k 的负权回路上, 那么 k 轮迭代之后就有 P(i, i) < 0. 这样一来, 我们只需要在 Floyd 算法中观察是否有P(i, i) 被更新就可以了.

总而言之, 这几种可以求有负边的图的最短路径的算法都可以判定该图中是否存在负权回路. Dijkstra 算法不能判断负权回路.

次短路径(second shortest path)

我们尝试解决 problem 2.1 . 在此之前, 我们先看一个简单的问题, 次短路径问题.

Problem 2.2
在一个无负回路的图中有两个点 s, t, 试求两点间的第二短路径.

我们进一步分析, 假定一个图中有一条最短路径 P(s, t), 另有一条次短路径 Q(s, t), 那么 P 和 Q 有什么联系呢? 答案是它们必有至少一条边不相同. 换言之, 在 P(s, t) 上总存在一条边, 使得 Q(s, t) 不经过这条边.那么, 我们把这条边去掉之后再求整个图的最短路径, 这个路径的长度是不是和 Q(s, t) 相同呢? 答案是肯定的. 用反证法可以证明.

在我们对 Problem 2.2 作出回答之前, 我们对这个算法做一个优化. 假定这个图是一个无负权图, 我们可以用 Dijkstra 算法求解最短路径. 当前删掉的边假定是 E(u, v), 于是 P(s, t) 在删掉边之后保留了一个前缀 P(s, u), 出于对称性我们暂时不考虑后缀. 用相同的反证法我们可以得出, 一条长度等于Q(s, t) 的次短路径可以在枚举每一个 E(u, v) 的前提下由 P(s, u) 加上 u 到 t 的最短路径求得. 而且, 在考虑 u 到 t 的最短路径的时候不仅不包含 E(u, v), 而且可以删掉 P(s, u) 涉足的所有节点, 相当于对一个子图求最短路径, 节省了很多冗余计算.

这个优化是 Yen's algorithm 的一部分, 由 Jin Y. Yen 于1971年提出.

Yen 算法就是在 Dijkstra 的基础上用上述方法迭代 k 次, 每次删边的时候保留前面的路径结果, 并且只对后面的子图做最短路径就可以了.

我们后面讲到的普适的优先队列的方法也可以把这个优化加上去.

Answer 2.2
对于存在负权边的图, 我们先用 SPFA 求出一条最短路径 P(s, t), 然后枚举 P(s, t) 中的每一条边, 求出很多条删边后的最短路径. 这些路径中最短的即为所求.

对于不存在负权边的图, 我们先用 Dijkstra 算法求出一条最短路径 P(s, t), 然后枚举 P(s, t) 的每一条边 E(u, v), 求出不包含 E(u, v) 也不包含 P(s, u) 上任意一个节点的 u 到 t 的最短路径 Q(u, t), 把 P(s, u) + Q(u, t) 作为删边后的最短路径. 这些路径中最短的即为所求.

这样我们就解决了 Problem 2.2. 那么, 我们如何利用这个思路去求第 k 短路径呢? 我们先提出一个普适的算法.

前面我们提到, P(s, t) 删掉每一条边都可以求出一个"准次短路径", 我们把所有的"准次短路径" 添加到一个备选集(candidates)里面. 在求次短路径的时候, 我们我们从备选集里弹出了一个最优值, Q(s, t). 那么, 第三短路径会是一个怎样的构造呢? 我们知道, 它有可能仍然在备选集里, 它也有可能是 Q(s, t) 删掉一条边之后所得的一条路径. 因此, 求第 k 短路径需要维护一个备选集(candidates), 因此我们需要构建一个优先队列.

一般地, 我们把优先队列初始化为只有 P(s, t) 的一个队列. 求 s 到 t 的第 k 短路径, 就是进行 k 次如下的迭代: 从优先队列里弹出最优的结果, 作为第 k 短路径; 之后把这个新的结果通过删边操作得到的"准次短路径"插入这个优先队列中.

我们简单提一下这个算法的一个重要优化. 对于这个优先队列, 我们在记录每一个最短路径的同时, 还需要记录该路径所删掉的边的集合. 在我们拿到第 k 短路径之后准备依次删边求新的"准次短路径"的时候, 如果删完边之后与优先队列中某个删掉边的集合重复了, 那我们就直接放弃它, 不再重新求一遍最短路径.

这个剪枝类似于另外一个问题. 给定两组各 k 个排好序的数, 求它们的和的第 k 大的数.

假定a(i, j) 是第一组中第 i 大的数与第二组中第 j 大的数的和. 显然 a(1, 1) 会是最大的数, 去掉它之后我们留下了两个备选, a(1, 2) 和 a(2, 1). 那么, 每次拿走一个第 k 大的数之后都会增添两个备选吗? 显然不是的. 如果我们第二次和第三次拿走了 a(1, 2) 和 a(2, 1) 的话, 我们无需向优先队列里添加两次 a(2, 2).

我们所使用的优化和这个问题同理.

到这里为止, 我们就把求第 k 短路径的算法完全构建起来了. 利用每一个第 x 短路径可以生成第 x+1 短路径的备选, 我们通过一个优先队列来维护这些备选, 直至找到我们所需的最短路径.

k最优迪科斯彻算法(k-best dijkstra's algorithm)

最后我们介绍一种更高效的求正权图第 k 短路径的算法, 以补全对 problem 2.1 的回答.

先用另一个视角回顾一下 Dijkstra 算法. 我们做一次 Dijkstra 算法的过程, 就是扩展子图 G' 的过程. 考虑在扩展子图的时候维护一个队列 Q, 那么原始的 Dijkstra 算法中, 我们会在初始的时候把 s 放进队列, 第一步把 s 弹出, 把所有 s 的邻边放进这个队列; 之后, 我们每次都弹出一个节点, 并把这个节点更新掉的节点放进这个队列. 由于曾经被这个队列弹出的节点不会在被更新, 因此这个队列只是走遍了所有的节点而已.

我们假设现在有一个节点 u, 该节点曾作为备选(candidate) 出现在了这个队列中, 之后它被弹出了. 现在队列弹出了一个新的节点 v, 那么 v 会用一个更长的路径上限去更新 P(s, u), 从而更新失败. 现在我们思考一个问题, P(s, u) 的第二短路径从何而来呢? 通过上面的分析我们可以知道, 这个第二短路径是某个 v 来更新 P(s, u) 所用的值. 虽然这个值比我们已经得到的 P(s, u) 稍大, 但是它们中的最小值一定是 s 到 u 的第二短路径.

我们现在规定已经被弹出的节点也可以被放进队列里来, 而且节点被队列弹出之后我们就把它所记录的一个贪心得到的最短路径抹掉, 即记录在别的地方, 并用反向有界性初始化成一个极大值. 那么, 我们可以知道, 当所有的点恰好被这个队列弹出 k 次的时候, 我们就得到了 s 到所有点的前 k 短路径. 其时间复杂度为 k 乘以 Dijkstra 算法的时间复杂度.

这个算法叫做 k-best Dijkstra's algorithm, 我们把它叫做 K-最优迪科斯彻算法.

根据黄亮大神在2005年的一篇未发表的文章提到, 这个 k-best Dijkstra algorithm 疑似起源于20世纪60年代的一个民间传说. (Dijkstra本人把 Dijkstra's algorithm 发表于 1959 年).

Mohri 和 Riley 于2002年发表了一篇文章, 这篇文章的.ps版本可以在Mohri大神的主页上找到. 该文记载了这个算法, 但是没有把它命名为 k-best dijkstra's algorithm. 本文沿用了黄亮大神的命名.

有兴趣的读者可以参考一下.

K-最优 Dijkstra 算法允许一个节点弹出 k 次, 并且每次弹出这个节点的时候要抹掉该点当前的最优值. 因而我们在维护优先队列的同时, 需要维护两个表. 第一个表记录每一个节点被弹出的次数, 用来控制每个节点最后恰好只弹出 k 次; 第二个表用来记录 s 到所有点的前 k 短距离, 每次弹出节点的时候要在这里记录之后方可抹掉.

现在 k 最优 Dijkstra 算法已经描述完毕.

k 最优 Dijkstra 算法的本质是反复运用贪心策略. 注意它和 Dijkstra 算法的适用范围相同, 都只能适用在正权图上. 而它相比前面所述的普适算法, 不仅时间代价小了很多, 而且可以求出一个点到所有点的前 k 短路径. 我们利用之前的普适算法和这个算法, 来给出一个 problem 1.1 的完整解答.

Answer 1.1
一般地, 如果该图存在负权的边, 那么我们就采用上述的前 k 短路径的普适算法来求解. 我们使用 SPFA 算法来做单次的最短路径, 并且用上述的删边方法来维护一个优先队列. 该队列弹出的前 k 个结果, 就是 s 到 t 的前 k 短路径.

特殊地, 如果该图是一个正权图, 那么我们采用 k 最优 Dijkstra 算法即可得到 s 到所有点的最短路径.

完.