deploy

2026-07-07 21:24:18 +00:00 · 2026-04-14 18:06:19 +08:00
parent 17b2a0b630
commit cf0747ba3e
131 changed files with 604 additions and 609 deletions
@@ -4411,7 +4411,7 @@
 <p><img alt="Число способов подняться на 3-ю ступень" class="animation-figure" src="../intro_to_dynamic_programming.assets/climbing_stairs_example.png" /></p>
 <p align="center"> Рисунок 14-1 &nbsp; Число способов подняться на 3-ю ступень </p>

-<p>Цель этой задачи - вычислить количество способов. <strong>Поэтому можно попробовать использовать для ее решения метод поиска с возвратом</strong>. Если представить подъем по лестнице как последовательность решений, то мы начинаем от земли и на каждом раунде выбираем прыжок на <span class="arithmatex">\(1\)</span> или на <span class="arithmatex">\(2\)</span> ступени; всякий раз, когда достигаем вершины, увеличиваем число способов на <span class="arithmatex">\(1\)</span> , а если перескакиваем вершину, обрезаем эту ветвь. Код выглядит так:</p>
+<p>Цель этой задачи - вычислить количество способов. <strong>Поэтому можно попробовать использовать для ее решения метод поиска с возвратом</strong>. Если представить подъем по лестнице как последовательность решений, то мы начинаем от земли и на каждом раунде выбираем прыжок на <span class="arithmatex">\(1\)</span> или на <span class="arithmatex">\(2\)</span> ступени. Всякий раз, когда достигаем вершины, увеличиваем число способов на <span class="arithmatex">\(1\)</span> , а если перескакиваем вершину, обрезаем эту ветвь. Код выглядит так:</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:13"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><input id="__tabbed_1_13" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Kotlin</label><label for="__tabbed_1_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -4796,8 +4796,8 @@
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20backtrack%28choices%3A%20list%5Bint%5D%2C%20state%3A%20int%2C%20n%3A%20int%2C%20res%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%91%D1%8D%D0%BA%D1%82%D1%80%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3%22%22%22%0A%20%20%20%20%23%20%D0%9A%D0%BE%D0%B3%D0%B4%D0%B0%20%D0%BF%D0%BE%D0%B4%D1%8A%D0%B5%D0%BC%20%D0%B4%D0%BE%D1%81%D1%82%D0%B8%D0%B3%D0%B0%D0%B5%D1%82%20n-%D0%B9%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D0%B8%2C%20%D1%87%D0%B8%D1%81%D0%BB%D0%BE%20%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%20%D1%83%D0%B2%D0%B5%D0%BB%D0%B8%D1%87%D0%B8%D0%B2%D0%B0%D0%B5%D1%82%D1%81%D1%8F%20%D0%BD%D0%B0%201%0A%20%20%20%20if%20state%20%3D%3D%20n%3A%0A%20%20%20%20%20%20%20%20res%5B0%5D%20%2B%3D%201%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%B1%D0%BE%D1%80%20%D0%B2%D1%81%D0%B5%D1%85%20%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%B0%0A%20%20%20%20for%20choice%20in%20choices%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%9E%D1%82%D1%81%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%3A%20%D0%BD%D0%B5%D0%BB%D1%8C%D0%B7%D1%8F%20%D0%B2%D1%8B%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%20n-%D1%8E%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D1%8C%0A%20%20%20%20%20%20%20%20if%20state%20%2B%20choice%20%3E%20n%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20continue%0A%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BF%D1%8B%D1%82%D0%BA%D0%B0%3A%20%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%20%D0%B8%20%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C%20%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5%0A%20%20%20%20%20%20%20%20backtrack%28choices%2C%20state%20%2B%20choice%2C%20n%2C%20res%29%0A%20%20%20%20%20%20%20%20%23%20%D0%9E%D1%82%D0%BA%D0%B0%D1%82%0A%0A%0Adef%20climbing_stairs_backtrack%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9F%D0%BE%D0%B4%D1%8A%D0%B5%D0%BC%20%D0%BF%D0%BE%20%D0%BB%D0%B5%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B5%3A%20%D0%B1%D1%8D%D0%BA%D1%82%D1%80%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3%22%22%22%0A%20%20%20%20choices%20%3D%20%5B1%2C%202%5D%20%20%23%20%D0%9C%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%BF%D0%BE%D0%B4%D0%BD%D1%8F%D1%82%D1%8C%D1%81%D1%8F%20%D0%BD%D0%B0%201%20%D0%B8%D0%BB%D0%B8%202%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D0%B8%0A%20%20%20%20state%20%3D%200%20%20%23%20%D0%9D%D0%B0%D1%87%D0%B0%D1%82%D1%8C%20%D0%BF%D0%BE%D0%B4%D1%8A%D0%B5%D0%BC%20%D1%81%200-%D0%B9%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D0%B8%0A%20%20%20%20res%20%3D%20%5B0%5D%20%20%23%20%D0%98%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20res%5B0%5D%20%D0%B4%D0%BB%D1%8F%20%D1%85%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%20%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9%0A%20%20%20%20backtrack%28choices%2C%20state%2C%20n%2C%20res%29%0A%20%20%20%20return%20res%5B0%5D%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%204%0A%0A%20%20%20%20res%20%3D%20climbing_stairs_backtrack%28n%29%0A%20%20%20%20print%28f%22%D0%9A%D0%BE%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%BE%20%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BE%D0%B2%20%D0%BF%D0%BE%D0%B4%D0%BD%D1%8F%D1%82%D1%8C%D1%81%D1%8F%20%D0%BF%D0%BE%20%D0%BB%D0%B5%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B5%20%D0%B8%D0%B7%20%7Bn%7D%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D0%B5%D0%B9%20%3D%20%7Bres%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
 <h2 id="1411-1">14.1.1 &nbsp; Метод 1: полный перебор<a class="headerlink" href="#1411-1" title="Permanent link">&para;</a></h2>
-<p>Алгоритм поиска с возвратом обычно не раскладывает задачу явно на подзадачи; вместо этого он рассматривает решение как последовательность решений, используя попытки и обрезку для поиска всех возможных ответов.</p>
-<p>Попробуем посмотреть на задачу именно как на разложение подзадач. Пусть число способов добраться до ступени <span class="arithmatex">\(i\)</span> равно <span class="arithmatex">\(dp[i]\)</span> ; тогда <span class="arithmatex">\(dp[i]\)</span> - это исходная задача, а ее подзадачи включают:</p>
+<p>Алгоритм поиска с возвратом обычно не раскладывает задачу явно на подзадачи. Вместо этого он рассматривает решение как последовательность решений, используя попытки и обрезку для поиска всех возможных ответов.</p>
+<p>Попробуем посмотреть на задачу именно как на разложение подзадач. Пусть число способов добраться до ступени <span class="arithmatex">\(i\)</span> равно <span class="arithmatex">\(dp[i]\)</span>. Тогда <span class="arithmatex">\(dp[i]\)</span> - это исходная задача, а ее подзадачи включают:</p>
 <div class="arithmatex">\[
 dp[i-1], dp[i-2], \dots, dp[2], dp[1]
 \]</div>
@@ -5041,7 +5041,7 @@ dp[i] = dp[i-1] + dp[i-2]
 <p><img alt="Дерево рекурсии для подъема по лестнице" class="animation-figure" src="../intro_to_dynamic_programming.assets/climbing_stairs_dfs_tree.png" /></p>
 <p align="center"> Рисунок 14-3 &nbsp; Дерево рекурсии для подъема по лестнице </p>

-<p>Если посмотреть на рисунок 14-3, то видно, что <strong>экспоненциальная временная сложность порождается "перекрывающимися подзадачами"</strong>. Например, <span class="arithmatex">\(dp[9]\)</span> раскладывается в <span class="arithmatex">\(dp[8]\)</span> и <span class="arithmatex">\(dp[7]\)</span> , а <span class="arithmatex">\(dp[8]\)</span> - в <span class="arithmatex">\(dp[7]\)</span> и <span class="arithmatex">\(dp[6]\)</span> ; обе ветви содержат подзадачу <span class="arithmatex">\(dp[7]\)</span> .</p>
+<p>Как видно на рисунке 14-3, <strong>экспоненциальная временная сложность порождается «перекрывающимися подзадачами»</strong>. Например, <span class="arithmatex">\(dp[9]\)</span> раскладывается в <span class="arithmatex">\(dp[8]\)</span> и <span class="arithmatex">\(dp[7]\)</span> , а <span class="arithmatex">\(dp[8]\)</span> - в <span class="arithmatex">\(dp[7]\)</span> и <span class="arithmatex">\(dp[6]\)</span>. Обе ветви содержат подзадачу <span class="arithmatex">\(dp[7]\)</span> .</p>
 <p>Продолжая это рассуждение, мы видим, что подзадачи порождают все более мелкие перекрывающиеся подзадачи без конца. Подавляющая часть вычислительных ресурсов уходит именно на них.</p>
 <h2 id="1412-2">14.1.2 &nbsp; Метод 2: поиск с мемоизацией<a class="headerlink" href="#1412-2" title="Permanent link">&para;</a></h2>
 <p>Чтобы ускорить алгоритм, <strong>мы хотим, чтобы каждая перекрывающаяся подзадача вычислялась только один раз</strong>. Для этого объявим массив <code>mem</code> для хранения решения каждой подзадачи и будем обрезать повторные вычисления в процессе поиска.</p>
@@ -5381,9 +5381,9 @@ dp[i] = dp[i-1] + dp[i-2]
 <p align="center"> Рисунок 14-4 &nbsp; Дерево рекурсии для поиска с мемоизацией </p>

 <h2 id="1413-3">14.1.3 &nbsp; Метод 3: динамическое программирование<a class="headerlink" href="#1413-3" title="Permanent link">&para;</a></h2>
-<p><strong>Поиск с мемоизацией - это метод "сверху вниз"</strong> : мы начинаем с исходной задачи (корня), рекурсивно раскладываем более крупные подзадачи на меньшие, пока не достигнем наименьших подзадач с уже известным ответом (листьев). Затем в процессе возврата постепенно собираем решения подзадач и тем самым получаем решение исходной задачи.</p>
-<p>Напротив, <strong>динамическое программирование - это метод "снизу вверх"</strong> : начиная с решений наименьших подзадач, мы итеративно строим решения для более крупных подзадач, пока не получим ответ на исходную задачу.</p>
-<p>Поскольку в динамическом программировании нет этапа возврата, для его реализации достаточно обычных циклов, без рекурсии. В приведенном ниже коде мы инициализируем массив <code>dp</code> для хранения решений подзадач; он выполняет ту же роль, что и массив <code>mem</code> в мемоизированном поиске:</p>
+<p><strong>Поиск с мемоизацией - это метод «сверху вниз»</strong> : мы начинаем с исходной задачи (корня), рекурсивно раскладываем более крупные подзадачи на меньшие, пока не достигнем наименьших подзадач с уже известным ответом (листьев). Затем в процессе возврата постепенно собираем решения подзадач и тем самым получаем решение исходной задачи.</p>
+<p>Напротив, <strong>динамическое программирование - это метод «снизу вверх»</strong> : начиная с решений наименьших подзадач, мы итеративно строим решения для более крупных подзадач, пока не получим ответ на исходную задачу.</p>
+<p>Поскольку в динамическом программировании нет этапа возврата, для его реализации достаточно обычных циклов, без рекурсии. В приведенном ниже коде мы инициализируем массив <code>dp</code> для хранения решений подзадач. Он выполняет ту же роль, что и массив <code>mem</code> в мемоизированном поиске:</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:13"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><input id="__tabbed_4_13" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Python</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Java</label><label for="__tabbed_4_4">C#</label><label for="__tabbed_4_5">Go</label><label for="__tabbed_4_6">Swift</label><label for="__tabbed_4_7">JS</label><label for="__tabbed_4_8">TS</label><label for="__tabbed_4_9">Dart</label><label for="__tabbed_4_10">Rust</label><label for="__tabbed_4_11">C</label><label for="__tabbed_4_12">Kotlin</label><label for="__tabbed_4_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -5628,7 +5628,7 @@ dp[i] = dp[i-1] + dp[i-2]
 <p><img alt="Процесс динамического программирования для подъема по лестнице" class="animation-figure" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
 <p align="center"> Рисунок 14-5 &nbsp; Процесс динамического программирования для подъема по лестнице </p>

-<p>Как и в поиске с возвратом, в динамическом программировании используется понятие "состояние" для обозначения некоторого этапа решения задачи; каждое состояние соответствует одной подзадаче и ее локально оптимальному решению. Например, в задаче о лестнице состояние определяется текущим номером ступени <span class="arithmatex">\(i\)</span> .</p>
+<p>Как и в поиске с возвратом, в динамическом программировании используется понятие «состояние» для обозначения некоторого этапа решения задачи. Каждое состояние соответствует одной подзадаче и ее локально оптимальному решению. Например, в задаче о лестнице состояние определяется текущим номером ступени <span class="arithmatex">\(i\)</span> .</p>
 <p>На основе сказанного можно подвести несколько часто используемых терминов динамического программирования.</p>
 <ul>
 <li>Массив <code>dp</code> называют <u>таблицей dp</u>, а <span class="arithmatex">\(dp[i]\)</span> обозначает решение подзадачи, соответствующей состоянию <span class="arithmatex">\(i\)</span> .</li>
@@ -5636,7 +5636,7 @@ dp[i] = dp[i-1] + dp[i-2]
 <li>Рекуррентную формулу <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> называют <u>уравнением перехода состояния</u>.</li>
 </ul>
 <h2 id="1414">14.1.4 &nbsp; Оптимизация пространства<a class="headerlink" href="#1414" title="Permanent link">&para;</a></h2>
-<p>Внимательный читатель мог заметить, что <strong>поскольку <span class="arithmatex">\(dp[i]\)</span> зависит только от <span class="arithmatex">\(dp[i-1]\)</span> и <span class="arithmatex">\(dp[i-2]\)</span> , нам не нужен весь массив <code>dp</code> для хранения ответов всех подзадач</strong> ; достаточно двух переменных, которые будут "перекатываться" вперед. Код имеет вид:</p>
+<p>Внимательный читатель мог заметить, что <strong>поскольку <span class="arithmatex">\(dp[i]\)</span> зависит только от <span class="arithmatex">\(dp[i-1]\)</span> и <span class="arithmatex">\(dp[i-2]\)</span> , нам не нужен весь массив <code>dp</code> для хранения ответов всех подзадач</strong>. Достаточно двух переменных, которые будут «перекатываться» вперед. Код имеет вид:</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="5:13"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><input id="__tabbed_5_13" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Python</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Java</label><label for="__tabbed_5_4">C#</label><label for="__tabbed_5_5">Go</label><label for="__tabbed_5_6">Swift</label><label for="__tabbed_5_7">JS</label><label for="__tabbed_5_8">TS</label><label for="__tabbed_5_9">Dart</label><label for="__tabbed_5_10">Rust</label><label for="__tabbed_5_11">C</label><label for="__tabbed_5_12">Kotlin</label><label for="__tabbed_5_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -5835,7 +5835,7 @@ dp[i] = dp[i-1] + dp[i-2]
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20climbing_stairs_dp_comp%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9F%D0%BE%D0%B4%D1%8A%D0%B5%D0%BC%20%D0%BF%D0%BE%20%D0%BB%D0%B5%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B5%3A%20%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5%20%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%20%D1%81%20%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9%20%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8%22%22%22%0A%20%20%20%20if%20n%20%3D%3D%201%20or%20n%20%3D%3D%202%3A%0A%20%20%20%20%20%20%20%20return%20n%0A%20%20%20%20a%2C%20b%20%3D%201%2C%202%0A%20%20%20%20for%20_%20in%20range%283%2C%20n%20%2B%201%29%3A%0A%20%20%20%20%20%20%20%20a%2C%20b%20%3D%20b%2C%20a%20%2B%20b%0A%20%20%20%20return%20b%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%209%0A%0A%20%20%20%20res%20%3D%20climbing_stairs_dp_comp%28n%29%0A%20%20%20%20print%28f%22%D0%9A%D0%BE%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%BE%20%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BE%D0%B2%20%D0%BF%D0%BE%D0%B4%D0%BD%D1%8F%D1%82%D1%8C%D1%81%D1%8F%20%D0%BF%D0%BE%20%D0%BB%D0%B5%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B5%20%D0%B8%D0%B7%20%7Bn%7D%20%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD%D0%B5%D0%B9%20%3D%20%7Bres%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
 <p>Из кода видно, что после отказа от массива <code>dp</code> пространственная сложность уменьшается с <span class="arithmatex">\(O(n)\)</span> до <span class="arithmatex">\(O(1)\)</span> .</p>
-<p>Во многих задачах динамического программирования текущее состояние зависит лишь от ограниченного числа предыдущих состояний. Тогда можно сохранять только действительно нужные состояния и за счет "уменьшения размерности" экономить память. <strong>Этот прием оптимизации памяти называют "скользящими переменными" или "скользящим массивом"</strong>.</p>
+<p>Во многих задачах динамического программирования текущее состояние зависит лишь от ограниченного числа предыдущих состояний. Тогда можно сохранять только действительно нужные состояния и за счет «уменьшения размерности» экономить память. <strong>Этот прием оптимизации памяти называют «скользящими переменными» или «скользящим массивом»</strong>.</p>

 <!-- Source file information -->