动态编程

动态编程指的是一种解决问题的方法，在这种方法中，我们预先计算和存储更简单的、类似的子问题，以建立一个复杂问题的解。它类似于递归，计算基本情况允许我们感应地确定最终值。当新值仅取决于先前计算的值时，此自下而上的方法很好。

通过动态编程解决的问题的一个重要属性是它应该具有重叠的子问题。这是区分DP的形式划分和征服其中存储更简单的值并不需要。

为了表明该技术的强大，这里是通过动态编程通常接近的一些最着名的问题：

1. 背包问题：给出了一套具有已知价值观和权重的宝藏，您应该选择哪一个，以最大限度地提高您的利润，而不会损坏您的背包有固定的容量？
2. 鸡蛋滴：下降的最佳方式是什么？ $N$来自A.的鸡蛋 $m$- 下台建筑物弄清楚爆裂时鸡蛋的最低高度？
3. 最长的常见子序列：考虑到两个序列，这是两者中共同的最长的子序列？
4. 子集合问题：给定一个和一个值 $n，$是否存在一个子集，其元素的和是 $n？$
5. 斐波纳契号：是否有更好的方法来计算比平原递归的斐波纳契数？

在一个比赛环境中，无论参赛者如何熟悉，动态编程几乎总是出现（通常以令人惊讶的方式）。

什么是值的最小数量 $v_1，v_2，v_3，\ ldots，v_n$需要总共的金额 $v？$

您可以多次使用面额。

最佳子结构

这一问题的最重要方面鼓励我们通过动态编程来解决这个问题是它可以简化为较小的子问题。

让 $f（n）$表示价值所需的最小硬币数量 $N$．

可视化 $f（n）$作为一堆硬币。堆栈顶部的硬币是什么？它可能是任何一个 $v_1，v_2，v_3，\ ldots，v_n$．如果它是 $v_1.$，剩下的堆栈将相当于 $n-v_1;$或者如果是 $v_2.$，剩下的堆栈将相当于 $n-v_2.$， 等等。

我们如何决定是什么？果然，我们还不知道。我们需要查看哪些最小化所需的硬币数量。

根据上述论点，我们可以将问题表述如下:

$f（v）= \ min \ big（\ big \ {1 + f（v - v_1），1 + f（v-v_2），\ ldots，1 + f（v-v_n）\ big \} \ big）．$

因为堆叠顶部的硬币也被称为一个硬币，然后我们可以看看其余部分。

重叠的子问题

很容易看到子问题可以重叠。

例如，如果我们试图使用$1、$2和$5来创建一个由$11组成的堆栈，我们的查找模式将是这样的:

$\ begin {对齐} f（11）＆= min \ big（\ big \ {1 + f（10），\ 1+ f（9），\ 1 + f（6）\ big \} \ big）\\＆= \ min \ big（\ big \ {1+ \ min {\ small \ led（\ {1 + f（9），1+ f（8），1 + f（5）\}}，\ 1+ f（9），\ 1 + f（6）\ big \} \ big）。\结束{对齐}$

很清楚，我们需要使用价值 $F（9）$几次。

优化我们的算法的最重要方面之一是我们不会重新计算这些值。为此，我们计算并存储所有值 $F$从1开始，潜在的未来使用。

边缘案例

递归在某处换句话说，换句话说，在它可以开始的已知价值。

对于这个问题，我们需要照顾两件事：

• 零：这很清楚 $f（0）= 0$由于我们不需要任何硬币，以使堆栈相当于0。

• 负值和不可达值：处理此类价值的一种方法是将它们标记为Sentinel值，以便我们的代码以特殊方式处理它们。一个好的选择哨兵是 $\ infty.$，由于可达值之间的最小值和 $\ infty.$永远不会是无限的。

算法

让我们总结一下这些想法，看看我们如何将其作为一个实际的算法来实现:

1 2 3 4 5 6 7 8 9

＃v =我们想要的值，v =可用数额列表defcoinschange.（V.那V.）：d=[漂浮（“inf”）*（V.+1）d[0.]=0.为了一世在Xrange.（1那V.+1）：为了VI.在V.：如果（一世-VI.）> =0.：d[一世]=闵（d[一世]，1+d[一世-VI.]）返回d[V.]

我们已经声称，Naive递归是解决重叠子标数问题的不良方式。这是为什么？主要是因为所涉及的所有重新计算。

另一种避免此问题的方法是首次计算数据并以自上而下的方式将其存储在一起。

让我们来看看如何以备忘方式解决先前的硬币改变问题。

1 2 3 4 5 6 7 8 9 10 11 12

defcoinschange.（V.那V.）：备忘录={}def改变（V.）：如果V.在备忘录：返回备忘录[V.]如果V.==.0.：返回0.如果V.<0.：返回漂浮（“inf”）备忘录[V.]=闵（[1+改变（V.-VI.）为了VI.在V.]）返回备忘录[V.]返回改变（V.）

通过缓存动态编程vs递归

我们会尝试在动态程序的帮助下解决这个问题，其中状态或描述问题的参数，包括两个变量。

首先，我们设置了一系列二维数组DP [开始] [结束]每个条目都解决了所指示的序列的问题开始和结尾包括的。

我们试着想想当我们遇到一个新的结尾价值，并需要在先前解决的子问题方面解决新问题。以下是所有可能性：

• 什么时候结束<=开始，没有有效的子序列。
• 什么时候b [end] <= k，即，最后一个条目是一个开放式括号，没有有效的子序列可以以其结束。有效地，如果我们根本没有包含最后一个条目，结果是相同的。
• 什么时候b [end]> k，即，最后一个条目是一个结束括号，一个人必须找到最佳匹配，或者只是忽略它，以最大化总和的方式。

你可以用这些想法来解决这个问题吗？

通常，动态编程有助于解决要求我们在隐式图形设置中找到最有利可图（或最低昂贵）路径的问题。让我们尝试用一个例子来说明这一点。

您应该从数字三角形的顶部开始，并通过在向左或向右下方的数字之间选择您的数字来选择您的通道。

您的目标是最大化符合您路径中的元素的总和。

例如，在下面的三角形中，红色路径最大化总和。

看看最佳子结构和重叠的子问题请注意，每次我们从顶部到右下方或左下方移动时，我们仍然留下较小的数字三角形，就像这样：

我们可以以类似的方式打破每个子问题，直到我们到达边缘案例在底部：

在这种情况下，解决方案是a + max（b，c）．

自下而上的动态编程解决方案是分配一个数字三角形，该三角形存储最大可达金额如果我们从该职位开始．使用该事实可以轻松地从底行计算数字三角形。

$\ text {最佳从这一点} = \ text {这个点} + \ max（\ text {最好从左边，从右边的最佳}）。$

让我通过迭代来证明这一原则。

迭代1：

1

8 5 9 3

迭代2：

1 2	10 13 15 8 5 9 3

迭代3：

1 2 3.

20 19 10 13 15 8 5 9 3

迭代4：

1 2 3 4

23 20 19 10 13 15 8 5 9 3

所以，我们可以从顶部做的有效最好的是23，这是我们的答案。