<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="ru">
		<id>http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=%D0%97%D0%B0%D0%B1%D1%8B%D0%BB%D0%9F%D0%B0%D1%80%D0%BE%D0%BB%D1%8C</id>
		<title>Викиконспекты - Вклад участника [ru]</title>
		<link rel="self" type="application/atom+xml" href="http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=%D0%97%D0%B0%D0%B1%D1%8B%D0%BB%D0%9F%D0%B0%D1%80%D0%BE%D0%BB%D1%8C"/>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F:%D0%92%D0%BA%D0%BB%D0%B0%D0%B4/%D0%97%D0%B0%D0%B1%D1%8B%D0%BB%D0%9F%D0%B0%D1%80%D0%BE%D0%BB%D1%8C"/>
		<updated>2026-08-06T09:34:13Z</updated>
		<subtitle>Вклад участника</subtitle>
		<generator>MediaWiki 1.30.0</generator>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BD%D0%BA%D1%83%D1%80%D1%81_%D0%B4%D0%BB%D1%8F_%D0%B1%D0%BE%D0%BB%D0%B5%D0%B5_%D1%83%D0%B4%D0%B0%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_URL_%D1%81%D0%B0%D0%B9%D1%82%D0%B0_%D0%B2%D0%B8%D0%BA%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BE%D0%B2&amp;diff=17932</id>
		<title>Конкурс для более удачного URL сайта вики-конспектов</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BD%D0%BA%D1%83%D1%80%D1%81_%D0%B4%D0%BB%D1%8F_%D0%B1%D0%BE%D0%BB%D0%B5%D0%B5_%D1%83%D0%B4%D0%B0%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_URL_%D1%81%D0%B0%D0%B9%D1%82%D0%B0_%D0%B2%D0%B8%D0%BA%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BE%D0%B2&amp;diff=17932"/>
				<updated>2012-02-02T13:13:17Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: Поправил очепятку&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Хочется избавиться от имени mediawiki, потому что это название вики-движка .&lt;br /&gt;
&lt;br /&gt;
Предлагайте варианты URL для вики-конспектов на этой странице.&lt;br /&gt;
Подписывайтесь, бонусы возможны.&lt;br /&gt;
&lt;br /&gt;
== Варианты ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
!Вариант!!Автор (&amp;lt;nowiki&amp;gt;~~~&amp;lt;/nowiki&amp;gt;)&lt;br /&gt;
|-&lt;br /&gt;
|knowledge||[[Участник:Kirelagin|Кирилл Елагин]]&lt;br /&gt;
|-&lt;br /&gt;
|wikiconsp||[[Участник:Igor buzhinsky|Игорь Бужинский]]&lt;br /&gt;
|-&lt;br /&gt;
|wk ''(что бы это ни значило)''||[[Участник:Kirelagin|Кирилл Елагин]]&lt;br /&gt;
|-&lt;br /&gt;
|lectures||[[Участник:Igor buzhinsky|Игорь Бужинский]]&lt;br /&gt;
|-&lt;br /&gt;
|theory||[[Участник:Shevchen|Дмитрий Шевченко]]&lt;br /&gt;
|-&lt;br /&gt;
|outlines||[[Участник:Shevchen|Дмитрий Шевченко]]&lt;br /&gt;
|-&lt;br /&gt;
|wikikt||[[Участник:Mamoshkin.Arseny|Арсений Мамошкин]]&lt;br /&gt;
|-&lt;br /&gt;
|lecturenotes||[[Участник:Dgerasimov|Дмитрий Герасимов]]&lt;br /&gt;
|-&lt;br /&gt;
|ktlectures||[[Участник:SkudarnovYaroslav|Ярослав Скударнов]]&lt;br /&gt;
|-&lt;br /&gt;
|wiki||[[Участник:Андрей Шулаев|Андрей Шулаев]]&lt;br /&gt;
|-&lt;br /&gt;
|pediwikia||[[Участник:Pashkal|Павел Кротков]]&lt;br /&gt;
|-&lt;br /&gt;
|wikisynopses||[[Участник:Rybak|Андрей Рыбак]]&lt;br /&gt;
|-&lt;br /&gt;
|ctpedia||[[Участник:Borisov|Сергей Борисов]]&lt;br /&gt;
|-&lt;br /&gt;
|ctd||[[Участник:Borisov|Сергей Борисов]]&lt;br /&gt;
|-&lt;br /&gt;
|wikimath||[[Участник:Yurik|Александров Юрий]]&lt;br /&gt;
|-&lt;br /&gt;
|itmopedia||Марат Валиахметов&lt;br /&gt;
|-&lt;br /&gt;
|w||[[Участник:Tsar|Иоанн Волков]]&lt;br /&gt;
|-&lt;br /&gt;
|notes||[[Участник:Grechko|Гречко Владислав]]&lt;br /&gt;
|-&lt;br /&gt;
|medialibrary||[[Участник:Андреев Кирилл|Андреев Кирилл]]&lt;br /&gt;
|-&lt;br /&gt;
|algowiki||[[Участник:ЗабылПароль|Иванов Денис]]&lt;br /&gt;
|-&lt;br /&gt;
|wiki.ifmo.ru||[[Участник:Proshev|Прошев Семен]]&lt;br /&gt;
|-&lt;br /&gt;
|db.algowiki.ru||[[Участник:GeraltFromRivia|Завадский Дмитрий]]&lt;br /&gt;
|-&lt;br /&gt;
|wikicat ||[[Участник:Русин Никита|Русин Никита]]&lt;br /&gt;
|-&lt;br /&gt;
|algostore ||[[Участник:Русин Никита|Русин Никита]]&lt;br /&gt;
|-&lt;br /&gt;
|store ||[[Участник:Русин Никита|Русин Никита]]&lt;br /&gt;
|}&lt;br /&gt;
+1 за педивикию :D&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BD%D0%BA%D1%83%D1%80%D1%81_%D0%B4%D0%BB%D1%8F_%D0%B1%D0%BE%D0%BB%D0%B5%D0%B5_%D1%83%D0%B4%D0%B0%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_URL_%D1%81%D0%B0%D0%B9%D1%82%D0%B0_%D0%B2%D0%B8%D0%BA%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BE%D0%B2&amp;diff=17722</id>
		<title>Конкурс для более удачного URL сайта вики-конспектов</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BD%D0%BA%D1%83%D1%80%D1%81_%D0%B4%D0%BB%D1%8F_%D0%B1%D0%BE%D0%BB%D0%B5%D0%B5_%D1%83%D0%B4%D0%B0%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_URL_%D1%81%D0%B0%D0%B9%D1%82%D0%B0_%D0%B2%D0%B8%D0%BA%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BE%D0%B2&amp;diff=17722"/>
				<updated>2012-01-24T00:27:04Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Варианты */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Хочется избавиться от имени mediawiki, потому что это название вики-движка .&lt;br /&gt;
&lt;br /&gt;
Предлагайте варианты URL для вики-конспектов на этой странице.&lt;br /&gt;
Подписывайтесь, бонусы возможны.&lt;br /&gt;
&lt;br /&gt;
== Варианты ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
!Вариант!!Автор (&amp;lt;nowiki&amp;gt;~~~&amp;lt;/nowiki&amp;gt;)&lt;br /&gt;
|-&lt;br /&gt;
|knowledge||[[Участник:Kirelagin|Кирилл Елагин]]&lt;br /&gt;
|-&lt;br /&gt;
|wikiconsp||[[Участник:Igor buzhinsky|Игорь Бужинский]]&lt;br /&gt;
|-&lt;br /&gt;
|wk ''(что бы это ни значило)''||[[Участник:Kirelagin|Кирилл Елагин]]&lt;br /&gt;
|-&lt;br /&gt;
|lectures||[[Участник:Igor buzhinsky|Игорь Бужинский]]&lt;br /&gt;
|-&lt;br /&gt;
|theory||[[Участник:Shevchen|Дмитрий Шевченко]]&lt;br /&gt;
|-&lt;br /&gt;
|outlines||[[Участник:Shevchen|Дмитрий Шевченко]]&lt;br /&gt;
|-&lt;br /&gt;
|wikikt||[[Участник:Mamoshkin.Arseny|Арсений Мамошкин]]&lt;br /&gt;
|-&lt;br /&gt;
|lecturenotes||[[Участник:Dgerasimov|Дмитрий Герасимов]]&lt;br /&gt;
|-&lt;br /&gt;
|ktlectures||[[Участник:SkudarnovYaroslav|Ярослав Скударнов]]&lt;br /&gt;
|-&lt;br /&gt;
|wiki||[[Участник:Андрей Шулаев|Андрей Шулаев]]&lt;br /&gt;
|-&lt;br /&gt;
|pediwikia||[[Участник:Pashkal|Павел Кротков]]&lt;br /&gt;
|-&lt;br /&gt;
|wikisynopses||[[Участник:Rybak|Андрей Рыбак]]&lt;br /&gt;
|-&lt;br /&gt;
|ctpedia||[[Участник:Borisov|Сергей Борисов]]&lt;br /&gt;
|-&lt;br /&gt;
|wikimath||[[Участник:Yurik|Александров Юрий]]&lt;br /&gt;
|-&lt;br /&gt;
|itmopedia||Марат Валиахметов&lt;br /&gt;
|-&lt;br /&gt;
|w||[[Участник:Tsar|Иоанн Волков]]&lt;br /&gt;
|-&lt;br /&gt;
|notes||[[Участник:Grechko|Гречко Владислав]]&lt;br /&gt;
|-&lt;br /&gt;
|medialibrary||[[Участник:Андреев Кирилл|Андреев Кирилл]]&lt;br /&gt;
|-&lt;br /&gt;
|algowki||[[Участник:ЗабылПароль|Иванов Денис]]&lt;br /&gt;
|}&lt;br /&gt;
+1 за педивикию :D&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15455</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15455"/>
				<updated>2011-12-31T07:13:47Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Описание==&lt;br /&gt;
В процессе работы алгоритма для вершин рассчитывается функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &lt;br /&gt;
*&amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; {{---}} наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &lt;br /&gt;
*&amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. &lt;br /&gt;
Чем меньше , тем раньше вершина будет открыта и исследована алгоритмом. Таким образом открытые алгоритмом вершины хранятся в очереди с приоритетом по значению &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt;. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
&lt;br /&gt;
Поведение алгоритма сильно зависит от того, какая эвристика используется. В свою очередь, выбор эвристики зависит[[Файл:Diagonal.png|thumb|right|Пример А* на сетке с возможностью ходить в восьми напрвлениях]] от постановки задачи. Часто А* используется для моделирования перемещения по поверхности, покрытой [http://deep-beta.co.uk/wp-content/uploads/2010/11/terrain.0.3+grid.png координатной сеткой].&lt;br /&gt;
&lt;br /&gt;
Если мы можем перемещаться в четырех направлениях, в качестве эвристики стоит выбрать [http://en.wikipedia.org/wiki/Manhattan_distance манхэттенское расстояние]&lt;br /&gt;
&amp;lt;tex&amp;gt;h(v) = |{v.x-goal.x}| + |{v.y-goal.y}|&amp;lt;/tex&amp;gt;. &lt;br /&gt;
&lt;br /&gt;
[http://ru.wikipedia.org/wiki/Расстояние_Чебышева Расстояние Чебышева] &amp;lt;tex&amp;gt;h(v) = \max{(|{v.x-goal.x}|, |{v.y-goal.y}|)}&amp;lt;/tex&amp;gt; применяется когда к четырем направлениям добавляются диагонали.&lt;br /&gt;
&lt;br /&gt;
Если передвижение не ограниченно сеткой, то можно использовать евклидово расстояние по прямой &amp;lt;tex&amp;gt;h(v) = \sqrt{(v.x-goal.x)^2 + (v.y-goal.y)^2}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Также стоит обратить внимание на то как соотносятся &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt;. Если они измеряются в разных величинах(Например, &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; это расстояние в километрах, а &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} оценка времени пути в часах) А* может выдать некорректный результат. &lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y через х&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y]) // можно улучшить расстояние до y                &lt;br /&gt;
                     tentative_is_better = true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better = false  &lt;br /&gt;
             if (tentative_is_better == true) // найден новый, более короткий путь до y&lt;br /&gt;
             {                              &lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
==Свойства==&lt;br /&gt;
===Корректность=== &lt;br /&gt;
Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше либо равна истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.&lt;br /&gt;
&lt;br /&gt;
===Оптимальность===&lt;br /&gt;
Любой другой алгоритм, использующий ту же эвристическую функцию &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt;, рассмотрит не меньше вершин, чем А*. &lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Википедия:Алгоритм_поиска_A*]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm Wikipedia:A*_search_algorithm]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Generalized best-first search strategies and the optimality of A*]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Manhattan.png&amp;diff=15452</id>
		<title>Файл:Manhattan.png</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Manhattan.png&amp;diff=15452"/>
				<updated>2011-12-31T06:28:53Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Diagonal.png&amp;diff=15451</id>
		<title>Файл:Diagonal.png</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Diagonal.png&amp;diff=15451"/>
				<updated>2011-12-31T06:28:25Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15417</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15417"/>
				<updated>2011-12-30T18:02:30Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Ссылки */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Описание==&lt;br /&gt;
В процессе работы алгоритма для вершин рассчитывается функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &lt;br /&gt;
*&amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; {{---}} наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &lt;br /&gt;
*&amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку. &lt;br /&gt;
Чем меньше &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt;, тем раньше вершина будет открыта и исследована алгоритмом. Таким образом множество альтернативных путей хранится в очереди с приоритетом. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y через х&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y]) // можно улучшить расстояние до y                &lt;br /&gt;
                     tentative_is_better = true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better = false  &lt;br /&gt;
             if (tentative_is_better == true) // найден новый, более короткий путь до y&lt;br /&gt;
             {                              &lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
==Свойства==&lt;br /&gt;
===Корректность=== &lt;br /&gt;
Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше либо равна истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.&lt;br /&gt;
&lt;br /&gt;
===Оптимальность===&lt;br /&gt;
Любой другой алгоритм, использующий ту же эвристическую функцию &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt;, рассмотрит не меньше вершин, чем А*. &lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Википедия:Алгоритм_поиска_A*]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm Wikipedia:A*_search_algorithm]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Generalized best-first search strategies and the optimality of A*]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15373</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15373"/>
				<updated>2011-12-30T02:09:48Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Ссылки */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Описание==&lt;br /&gt;
В процессе работы алгоритма для вершин рассчитывается функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &lt;br /&gt;
*&amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; {{---}} наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &lt;br /&gt;
*&amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку. &lt;br /&gt;
Чем меньше &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt;, тем раньше вершина будет открыта и исследована алгоритмом. Таким образом множество альтернативных путей хранится в очереди с приоритетом. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y через х&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y]) // можно улучшить расстояние до y                &lt;br /&gt;
                     tentative_is_better = true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better = false  &lt;br /&gt;
             if (tentative_is_better == true) // найден новый, более короткий путь до y&lt;br /&gt;
             {                              &lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
==Свойства==&lt;br /&gt;
===Корректность=== &lt;br /&gt;
Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше либо равна истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.&lt;br /&gt;
&lt;br /&gt;
===Оптимальность===&lt;br /&gt;
Любой другой алгоритм, использующий ту же эвристическую функцию &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt;, рассмотрит не меньше вершин, чем А*. &lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Википедия:Алгоритм_поиска_A*]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm Wikipedia:A*_search_algorithm]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM ]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15051</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15051"/>
				<updated>2011-12-22T07:49:11Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Описание==&lt;br /&gt;
В процессе работы алгоритма для вершин рассчитывается функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &lt;br /&gt;
*&amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; {{---}} наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &lt;br /&gt;
*&amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку. &lt;br /&gt;
Чем меньше &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt;, тем раньше вершина будет открыта и исследована алгоритмом. Таким образом множество альтернативных путей хранится в очереди с приоритетом. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y через х&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y]) // можно улучшить расстояние до y                &lt;br /&gt;
                     tentative_is_better = true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better = false  &lt;br /&gt;
             if (tentative_is_better == true) // найден новый, более короткий путь до y&lt;br /&gt;
             {                              &lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
==Свойства==&lt;br /&gt;
===Корректность=== &lt;br /&gt;
Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.&lt;br /&gt;
===Оптимальность===&lt;br /&gt;
Любой другой алгоритм, использующий ту же эвристическую функцию &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt;, рассмотрит не меньше вершин, чем А*. &lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library, в которой подробно написано обоснование корректности алгоритма]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15036</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=15036"/>
				<updated>2011-12-22T05:52:42Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Описание==&lt;br /&gt;
В процессе работы алгоритма для вершин рассчитывается функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &lt;br /&gt;
*&amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; {{---}} наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &lt;br /&gt;
*&amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.&lt;br /&gt;
Чем меньше &amp;lt;tex&amp;gt;f(v)&amp;lt;/tex&amp;gt;, тем раньше вершина будет открыта и исследована алгоритмом. Таким образом множество альтернативных путей хранится в очереди с приоритетом&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
==Свойства==&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library, в которой подробно написано обоснование корректности алгоритма]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=14974</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=14974"/>
				<updated>2011-12-21T00:40:31Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) {{---}} информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; {{---}} эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то алгоритм посетит вершины в том же порядке, что и [[алгоритм Дейкстры]]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library, в которой подробно написано обоснование корректности алгоритма]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13250</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13250"/>
				<updated>2011-11-19T17:14:17Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Полное доказательство расположено [http://www.cs.auckland.ac.nz/compsci709s2c/resources/Mike.d/astarNilsson.pdf здесь]. Здесь приведем основные факты.&lt;br /&gt;
Алгоритм является допустимым(корректным) если он гарантированно находит оптимальный путь из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; до целевой вершины. &lt;br /&gt;
Допустимые алгоритмы могут различаться числом рассмотренных вершин и порядком просмотра вершин.&lt;br /&gt;
&lt;br /&gt;
===Допустимость А*===&lt;br /&gt;
&lt;br /&gt;
Лемма 1. Для любой незакрытой вершины &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; и любого оптимального пути &amp;lt;tex&amp;gt;P&amp;lt;/tex&amp;gt; из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; в &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; существует открытая вершина &amp;lt;tex&amp;gt;n'&amp;lt;/tex&amp;gt;, лежащая на этом пути, для которой найденная стоимость пути из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; оптимальна.&lt;br /&gt;
&lt;br /&gt;
Теорема 1. Если для любой вершины эвристика не переоценивает настоящую стоимость минимального пути до целевой вершины, то А* допустим.&lt;br /&gt;
&lt;br /&gt;
===Оптимальность А*===&lt;br /&gt;
&lt;br /&gt;
Лемма 2. Предположим, что в процессе работы А* вершина &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; была закрыта и эвристика монотонна. Тогда вычисленный до нее путь из стартовой вершины оптимален.&lt;br /&gt;
&lt;br /&gt;
Теорема 2. Пусть А допустимый алгоритм информированный не больше чем А* и эвристика допустима и монотонна.Тогда если А* рассмотрела в процессе выполнения некоторую вершину &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt;, то А тоже рассмотрит эту вершину.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13249</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13249"/>
				<updated>2011-11-19T16:56:32Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в &amp;lt;tex&amp;gt;v&amp;lt;/tex&amp;gt; из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Полное доказательство расположено [http://www.cs.auckland.ac.nz/compsci709s2c/resources/Mike.d/astarNilsson.pdf здесь]. Здесь приведем основные факты.&lt;br /&gt;
Алгоритм является допустимым(корректным) если он гарантированно находит оптимальный путь из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; до целевой вершины. &lt;br /&gt;
Допустимые алгоритмы могут различаться числом рассмотренных вершин и порядком просмотра вершин.&lt;br /&gt;
&lt;br /&gt;
Допустимость А*&lt;br /&gt;
&lt;br /&gt;
Лемма 1. Для любой незакрытой вершины &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; и любого оптимального пути &amp;lt;tex&amp;gt;P&amp;lt;/tex&amp;gt; из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; в &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; существует открытая вершина &amp;lt;tex&amp;gt;n'&amp;lt;/tex&amp;gt;, лежащая на этом пути, для которой найденная стоимость пути из &amp;lt;tex&amp;gt;S&amp;lt;/tex&amp;gt; оптимальна.&lt;br /&gt;
&lt;br /&gt;
Теорема 1. Если для любой вершины эвристика не переоценивает настоящую стоимость минимального пути до целевой вершины, то А* допустим.&lt;br /&gt;
&lt;br /&gt;
Оптимальность А*&lt;br /&gt;
&lt;br /&gt;
Лемма 2. Предположим, что в процессе работы А* вершина &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt; была закрыта и эвристика монотонна. Тогда вычисленный до нее путь из стартовой вершины оптимален.&lt;br /&gt;
&lt;br /&gt;
Теорема 2. Пусть А допустимый алгоритм информированный не больше чем А* и эвристика допустима и монотонна.Тогда если А* рассмотрела в процессе выполнения некоторую вершину &amp;lt;tex&amp;gt;n&amp;lt;/tex&amp;gt;, то А тоже рассмотрит эту вершину.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13236</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13236"/>
				<updated>2011-11-19T00:14:35Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Доказательство оптимальности и корректности */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Полное доказательство расположено [http://www.cs.auckland.ac.nz/compsci709s2c/resources/Mike.d/astarNilsson.pdf здесь]. Здесь приведем основные факты.&lt;br /&gt;
Алгоритм является допустимым(корректным) если он гарантированно находит оптимальный путь из S до целевой вершины. &lt;br /&gt;
Допустимые алгоритмы могут различаться числом рассмотренных вершин и порядком просмотра вершин.&lt;br /&gt;
&lt;br /&gt;
Допустимость А*&lt;br /&gt;
&lt;br /&gt;
Лемма 1. Для любой незакрытой вершины n и любого оптимального пути P из S в n существует открытая вершина n', лежащая на этом пути, для которой найденная стоимость пути из S оптимальна.&lt;br /&gt;
&lt;br /&gt;
Теорема 1. Если для любой вершины эвристика не переоценивает настоящую стоимость минимального пути до целевой вершины, то А* допустим.&lt;br /&gt;
&lt;br /&gt;
Оптимальность А*&lt;br /&gt;
&lt;br /&gt;
Лемма 2. Предположим, что в процессе работы А* вершина n была закрыта и эвристика монотонна. Тогда вычисленный до нее путь из стартовой вершины оптимален.&lt;br /&gt;
&lt;br /&gt;
Теорема 2. Пусть А допустимый алгоритм информированный не больше чем А* и эвристика допустима и монотонна.Тогда если А* рассмотрела в процессе выполнения некоторую вершину n, то А тоже рассмотрит эту вершину.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13234</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13234"/>
				<updated>2011-11-19T00:13:32Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Доказательство оптимальности и корректности */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Полное доказательство расположено [http://www.cs.auckland.ac.nz/compsci709s2c/resources/Mike.d/astarNilsson.pdf здесь]. Здесь приведем основные факты.&lt;br /&gt;
Алгоритм является допустимым(корректным) если он гарантированно находит оптимальный путь из S до целевой вершины. &lt;br /&gt;
Допустимые алгоритмы могут различаться числом рассмотренных вершин и порядком просмотра вершин.&lt;br /&gt;
Допустимость А*&lt;br /&gt;
Лемма 1. Для любой незакрытой вершины n и любого оптимального пути P из S в n существует открытая вершина n', лежащая на этом пути, для которой найденная стоимость пути из S оптимальна.&lt;br /&gt;
Теорема 1. Если для любой вершины эвристика не переоценивает настоящую стоимость минимального пути до целевой вершины, то А* допустим.&lt;br /&gt;
&lt;br /&gt;
Оптимальность А*&lt;br /&gt;
Лемма 2. Предположим, что в процессе работы А* вершина n была закрыта и эвристика монотонна. Тогда вычисленный до нее путь из стартовой вершины оптимален.&lt;br /&gt;
&lt;br /&gt;
Теорема 2. Пусть А допустимый алгоритм информированный не больше чем А* и эвристика допустима и монотонна.Тогда если А* рассмотрела в процессе выполнения некоторую вершину n, то А тоже рассмотрит эту вершину.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13229</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13229"/>
				<updated>2011-11-18T23:22:55Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Доказательство оптимальности и корректности */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Полное доказательство расположено [http://www.cs.auckland.ac.nz/compsci709s2c/resources/Mike.d/astarNilsson.pdf здесь]. Здесь приведем основные факты.&lt;br /&gt;
Алгоритм является допустимым(корректным) если он гарантированно находит оптимальный путь из S до целевой вершины. &lt;br /&gt;
Допустимые алгоритмы могут различаться числом рассмотренных вершин и порядком просмотра вершин.&lt;br /&gt;
Допустимость А*&lt;br /&gt;
Лемма 1. Для любой незакрытой вершины n и любого оптимального пути P из S в n существует открытая вершина n', лежащая на этом пути, для которой найденная стоимость пути из S оптимальна.&lt;br /&gt;
Теорема 1. Если для любой вершины эвристика не переоценивает настоящую стоимость минимального пути до целевой вершины, то А* допустим.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13228</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13228"/>
				<updated>2011-11-18T22:14:06Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Псевдокод */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершины. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13227</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13227"/>
				<updated>2011-11-18T22:11:39Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Псевдокод */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершин. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13226</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13226"/>
				<updated>2011-11-18T22:06:48Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Псевдокод */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
А* просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент похожи на наилучший, причем алгоритм учитывает путь уже пройденный до текущей вершин. &lt;br /&gt;
[[Файл:Astar_progress_animation.gif|right]]&lt;br /&gt;
 void A*(start,goal) &lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Astar_progress_animation.gif&amp;diff=13225</id>
		<title>Файл:Astar progress animation.gif</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Astar_progress_animation.gif&amp;diff=13225"/>
				<updated>2011-11-18T22:02:37Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: Файл взят из википедии.&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Файл взят из википедии.&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13224</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13224"/>
				<updated>2011-11-18T20:41:37Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Эвристика */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
В процессе работы алгоритма для вершин используется функция &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторой картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
Краткое словесное описание будет здесь.&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13167</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13167"/>
				<updated>2011-11-17T18:35:43Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
Краткое словесное описание будет здесь.&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13166</id>
		<title>Обсуждение:Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=13166"/>
				<updated>2011-11-17T18:34:36Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: Новая страница: «Запилить формализованное доказательство оптимальности. А* оптимально среди одинаково ин...»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Запилить формализованное доказательство оптимальности. А* оптимально среди одинаково информированных алгоритмов поиска.&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12632</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12632"/>
				<updated>2011-11-02T23:55:12Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
*[http://dl.acm.org/citation.cfm?id=3830&amp;amp;coll=portal&amp;amp;dl=ACM Статья на ACM Digital Library]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12631</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12631"/>
				<updated>2011-11-02T23:52:30Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12630</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12630"/>
				<updated>2011-11-02T23:51:45Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Эвристика */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и &amp;lt;tex&amp;gt;f(v) = g(v) + h(v)&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;g(v)&amp;lt;/tex&amp;gt; - наименьшая стоимость пути в v из стартовой вершины, &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; - эвристическое приближение стоимости пути от v до конечной цели. &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
К примеру, если &amp;lt;tex&amp;gt;(h(v) == 0)&amp;lt;/tex&amp;gt;, то А* превращается в [http://chernykh.net/images/stories/Person/deiksteira.jpg Дейкстру ]. Если &amp;lt;tex&amp;gt;h(v)&amp;lt;/tex&amp;gt; всегда меньше истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм. Если выйдет так, что эвристика превысила истинную стоимость, то А* будет работать быстрее, но возможно найдет не лучший путь, хотя его можно считать &amp;quot;хорошим&amp;quot; и если производительность предпочтительнее точности можно использовать такую эвристику.&lt;br /&gt;
&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12626</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12626"/>
				<updated>2011-11-02T18:23:38Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) -- информированный  алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и f(v) = g(v) + h(v), где g(v) - наименьшая стоимость пути в v из стартовой вершины, h(v) - эвристическое приближение стоимости пути от v до конечной цели. h(v) должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12625</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12625"/>
				<updated>2011-11-02T17:04:55Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Псевдокод */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и f(v) = g(v) + h(v), где g(v) - наименьшая стоимость пути в v из стартовой вершины, h(v) - эвристическое приближение стоимости пути от v до конечной цели. h(v) должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12624</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12624"/>
				<updated>2011-11-02T17:04:34Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Псевдокод */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и f(v) = g(v) + h(v), где g(v) - наименьшая стоимость пути в v из стартовой вершины, h(v) - эвристическое приближение стоимости пути от v до конечной цели. h(v) должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
 void A*(start,goal)&lt;br /&gt;
 {&lt;br /&gt;
     closed := {}; // Множество вершин расстояние до которых мы уже оценили&lt;br /&gt;
     open.push(start);// Очередь с приоритетом &lt;br /&gt;
     f[start] = g[start] + h[start];&lt;br /&gt;
     parent[start] = start;&lt;br /&gt;
&lt;br /&gt;
     while (open.size() != 0) &lt;br /&gt;
     {&lt;br /&gt;
         x := open.pop(); &lt;br /&gt;
         if (x == goal) &lt;br /&gt;
             return succsess(x);// Кратчайший путь найден         &lt;br /&gt;
         closed.push(x);   &lt;br /&gt;
         for (y : xy in E) &lt;br /&gt;
         {&lt;br /&gt;
             if (y in closed)      &lt;br /&gt;
                 continue;&lt;br /&gt;
             tmp := g[x] + d[x,y]  // Стоимость пути до y&lt;br /&gt;
             if (y not in open) &lt;br /&gt;
             {&lt;br /&gt;
                 open.push(y);&lt;br /&gt;
                 tentative_is_better = true;&lt;br /&gt;
             }&lt;br /&gt;
             else            &lt;br /&gt;
                 if (tmp &amp;lt; g[y])                 &lt;br /&gt;
                     tentative_is_better := true   &lt;br /&gt;
                 else&lt;br /&gt;
                     tentative_is_better := false  &lt;br /&gt;
             if (tentative_is_better == true)// &lt;br /&gt;
             {&lt;br /&gt;
                 parent[y] = x;&lt;br /&gt;
                 g[y] = tmp;&lt;br /&gt;
                 f[y] = g[y] + h[y];&lt;br /&gt;
             }&lt;br /&gt;
         }&lt;br /&gt;
     }&lt;br /&gt;
     return failure; // Наша цель недостижима из start&lt;br /&gt;
 }&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12622</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12622"/>
				<updated>2011-11-02T16:15:24Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Доказательство оптимальности и корректности */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и f(v) = g(v) + h(v), где g(v) - наименьшая стоимость пути в v из стартовой вершины, h(v) - эвристическое приближение стоимости пути от v до конечной цели. h(v) должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
Алгоритм A* и допустим, и обходит при этом минимальное количество вершин, благодаря тому, что он работает с «оптимистичной» оценкой пути через вершину. Оптимистичной в том смысле, что, если он пойдёт через эту вершину, у алгоритма «есть шанс», что реальная стоимость результата будет равна этой оценке, но никак не меньше. Но, поскольку A* является информированным алгоритмом, такое равенство может быть вполне возможным.&lt;br /&gt;
&lt;br /&gt;
Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.&lt;br /&gt;
&lt;br /&gt;
Предположим теперь, что некий алгоритм B вернул в качестве результата путь, длина которого больше оценки стоимости пути через некоторую вершину. На основании эвристической информации, для алгоритма B нельзя исключить возможность, что этот путь имел и меньшую реальную длину, чем результат. Соответственно, пока алгоритм B просмотрел меньше вершин, чем A*, он не будет допустимым. Итак, A* проходит наименьшее количество вершин графа среди допустимых алгоритмов, использующих такую же точную (или менее точную) эвристику.&lt;br /&gt;
&lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12621</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=12621"/>
				<updated>2011-11-02T16:11:57Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Алгоритм '''А*'''(&amp;quot;A star&amp;quot;, &amp;quot;А звёздочка&amp;quot;) находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.&lt;br /&gt;
==Эвристика==&lt;br /&gt;
Все вершины графа перевзвешиваются и f(v) = g(v) + h(v), где g(v) - наименьшая стоимость пути в v из стартовой вершины, h(v) - эвристическое приближение стоимости пути от v до конечной цели. h(v) должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели. Например, если наш граф является некоторй картой, разбитой сеткой, то эвристику можно назначить минимальным числом перемещений из клетки в клетку.&lt;br /&gt;
==Псевдокод==&lt;br /&gt;
&lt;br /&gt;
==Доказательство оптимальности и корректности==&lt;br /&gt;
А* находит &lt;br /&gt;
==Оценка времени работы==&lt;br /&gt;
==Применение==&lt;br /&gt;
==Ссылки==&lt;br /&gt;
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Алгоритм_поиска_A* Википедия]&lt;br /&gt;
*[http://en.wikipedia.org/wiki/A*_search_algorithm A*_search_algorithm Wikipedia]&lt;br /&gt;
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей и различных оптимизациях А* в частности]&lt;br /&gt;
&lt;br /&gt;
[[Категория: Алгоритмы и структуры данных]]&lt;br /&gt;
[[Категория: Кратчайшие пути в графах ]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=11750</id>
		<title>Алгоритм A*</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A*&amp;diff=11750"/>
				<updated>2011-10-22T03:15:52Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: Новая страница: «Доказательство оптимальности и корректности Оценка времени работы Применение»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Доказательство оптимальности и корректности&lt;br /&gt;
Оценка времени работы&lt;br /&gt;
Применение&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10433</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10433"/>
				<updated>2011-06-29T15:32:17Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = \max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq \max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt; если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt; - вероятность того, что &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;. Поскольку предполагается, что все элементы в массиве различны, то при выборе &amp;lt;tex&amp;gt;x&amp;lt;/tex&amp;gt; в качестве опорного элемента впоследствии не будут сравниваться никакие &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; для которых &amp;lt;tex&amp;gt;z_i &amp;lt; x &amp;lt; z_j&amp;lt;/tex&amp;gt;. С другой стороны, если &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; выбран в качестве опорного, то он будет сравниваться с каждым элементом &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; кроме себя самого. Таким образом элементы &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; сравниваются тогда и только тогда когда первым в множестве &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; опорным элементом был выбран один из них.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Mатожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10133</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10133"/>
				<updated>2011-06-15T22:48:55Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = \max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq \max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt; если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt; - вероятность того, что &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;. Поскольку предполагается, что все элементы в массиве различны, то при выборе &amp;lt;tex&amp;gt;x&amp;lt;/tex&amp;gt; в качестве опорного элемента впоследствии не будут сравниваться никакие &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; для которых &amp;lt;tex&amp;gt;z_i &amp;lt; x &amp;lt; z_j&amp;lt;/tex&amp;gt;. С другой стороны, если &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; выбран в качестве опорного, то он будет сравниваться с каждым элементом &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; кроме себя самого. Таким образом элементы &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; сравниваются тогда и только тогда когда первым в множестве &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; опорным элементом был выбран один из них.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Mатожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10132</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10132"/>
				<updated>2011-06-15T22:48:09Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = \max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq \max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt; если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt; - вероятность того, что &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;. Поскольку предполагается, что все элементы в массиве различны, то при выборе &amp;lt;tex&amp;gt;x&amp;lt;/tex&amp;gt; в качестве опорного элемента впоследствии не будут сравниваться никакие &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; для которых &amp;lt;tex&amp;gt;z_i &amp;lt; x &amp;lt; z_j&amp;lt;/tex&amp;gt;. С другой стороны, если &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; выбран в качестве опорного, то он будет сравниваться с каждым элементом &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; кроме себя самого. Таким образом элементы &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; сравниваются тогда и только тогда когда первым в множестве &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; опорным элементом был выбран один из них.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}&lt;br /&gt;
Mатожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10131</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10131"/>
				<updated>2011-06-15T22:46:52Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = \max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq \max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt; если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt; - вероятность того, что &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;. Поскольку предполагается, что все элементы в массиве различны, то при выборе &amp;lt;tex&amp;gt;x&amp;lt;/tex&amp;gt; в качестве опорного элемента впоследствии не будут сравниваться никакие &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; для которых &amp;lt;tex&amp;gt;z_i &amp;lt; x &amp;lt; z_j&amp;lt;/tex&amp;gt;. С другой стороны, если &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; выбран в качестве опорного, то он будет сравниваться с каждым элементом &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; кроме себя самого. Таким образом элементы &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; сравниваются тогда и только тогда когда первым в множестве &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; опорным элементом был выбран один из них.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Таким образом матожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10130</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10130"/>
				<updated>2011-06-15T22:39:40Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt; если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt; - вероятность того, что &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;. Поскольку предполагается, что все элементы в массиве различны, то при выборе &amp;lt;tex&amp;gt;x&amp;lt;/tex&amp;gt; в качестве опорного элемента впоследствии не будут сравниваться никакие &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; для которых &amp;lt;tex&amp;gt;z_i &amp;lt; x &amp;lt; z_j&amp;lt;/tex&amp;gt;. С другой стороны, если &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; выбран в качестве опорного, то он будет сравниваться с каждым элементом &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; кроме себя самого. Таким образом элементы &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt; сравниваются тогда и только тогда когда первым в множестве &amp;lt;tex&amp;gt;Z_{ij}&amp;lt;/tex&amp;gt; опорным элементом был выбран один из них.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Таким образом матожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10129</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10129"/>
				<updated>2011-06-15T22:22:29Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;X_{ij} = 1&amp;lt;/tex&amp;gt;если произошло сравнение &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;z_j&amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;X_{ij} = 0&amp;lt;/tex&amp;gt;, если сравнения не произошло.&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Таким образом матожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10125</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10125"/>
				<updated>2011-06-15T21:53:21Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Заметим, что сравнеие каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Таким образом матожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10124</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10124"/>
				<updated>2011-06-15T21:48:04Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Среднее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
{{&lt;br /&gt;
Лемма&lt;br /&gt;
|statement=Пусть Х - полное количество сравнений элементов с опорным за время работы сортировки. Тогда время работы сортировки равно &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
|proof=Нам необходимо вычислить полное количество сравнений.&lt;br /&gt;
Переименуем элементы массива как &amp;lt;tex&amp;gt;z_1...z_n&amp;lt;/tex&amp;gt;, где &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; наименьший по порядку элемент.&lt;br /&gt;
Также введем множество &amp;lt;tex&amp;gt;Z_{ij} = \{z_i, z_{i+1}...z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Поскольку каждая пара элементов срановается не более одного раза, полное количество сравнений выражается как&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;X = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;E[X] = E\left[\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} X_{ij}\right] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} E[X_{ij}] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Осталось вычислить величину &amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\}&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Pr\{z_i&amp;lt;/tex&amp;gt; сравнивается с &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i&amp;lt;/tex&amp;gt; или &amp;lt;tex&amp;gt;z_j\} = &lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_i\} +&lt;br /&gt;
Pr\{&amp;lt;/tex&amp;gt; первым опорным элементом был &amp;lt;tex&amp;gt;z_j\} =&lt;br /&gt;
\frac {1}{j-i+1} + \frac {1}{j-i+1}  = \frac {2}{j-i+1} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt; E[X] = \sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n} \frac {2}{j-i+1} = \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k+1} &amp;lt; \sum\limits_{i=1}^{n-1}\sum\limits_{k=1}^{n-i} \frac 2{k} = \sum\limits_{i=1}^{n-1}O(\log n) = O(n \log n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
}}&lt;br /&gt;
Таким образом матожидание времени работы быстрой сортировки будет &amp;lt;tex&amp;gt;O(n \log n)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10114</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10114"/>
				<updated>2011-06-15T20:58:20Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Худшее время работы */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
&lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10112</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10112"/>
				<updated>2011-06-15T20:55:56Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;,где &amp;lt;tex&amp;gt;0 \leq q \leq n-1&amp;lt;/tex&amp;gt;, &lt;br /&gt;
так как мы разбиваемся на 2 подзадачи. &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq c(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Заметим, что &amp;lt;tex&amp;gt;q^2+(n-q-1)^2&amp;lt;/tex&amp;gt; принимает максимальное значение на концах интервала [0; n-1], что позволяет нам сделать оценку&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Подставим это в наше выражение для &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;.&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10105</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10105"/>
				<updated>2011-06-15T20:37:30Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10101</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10101"/>
				<updated>2011-06-15T20:18:00Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
 var&lt;br /&gt;
   a : array [ 1 . .N] of integer ;&lt;br /&gt;
 procedure QSort ( left , right : integer ) ;&lt;br /&gt;
   var&lt;br /&gt;
     i , j : integer ;&lt;br /&gt;
     key : integer ;&lt;br /&gt;
     buf : integer ;&lt;br /&gt;
 begin&lt;br /&gt;
   key := a [ random ( right - left + 1) + left ] ;&lt;br /&gt;
   i := left ;&lt;br /&gt;
   j := right ;&lt;br /&gt;
   repeat&lt;br /&gt;
     while a [ i ] &amp;lt; key do &lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
     while key &amp;lt; a [ j ] do &lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     if i &amp;lt;= j then begin&lt;br /&gt;
       buf := a [ i ] ;&lt;br /&gt;
       a [ i ] := a [ j ] ;&lt;br /&gt;
       a [ j ] := buf ;&lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     end ;&lt;br /&gt;
   unti l i &amp;gt; j ;&lt;br /&gt;
   if left &amp;lt; j then&lt;br /&gt;
     QSort ( left , j ) ;&lt;br /&gt;
   if i &amp;lt; right then&lt;br /&gt;
     QSort ( i , right ) ;&lt;br /&gt;
 end ;&lt;br /&gt;
 begin&lt;br /&gt;
   . . .&lt;br /&gt;
   QSort ( 1 , N) ;&lt;br /&gt;
 end .&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10058</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10058"/>
				<updated>2011-06-15T17:32:37Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
 var&lt;br /&gt;
   a : array [ 1 . .N] of integer ;&lt;br /&gt;
 procedure QSort ( left , right : integer ) ;&lt;br /&gt;
   var&lt;br /&gt;
     i , j : integer ;&lt;br /&gt;
     key : integer ;&lt;br /&gt;
     buf : integer ;&lt;br /&gt;
 begin&lt;br /&gt;
   key := a [ random ( right - left + 1) + left ] ;&lt;br /&gt;
   i := left ;&lt;br /&gt;
   j := right ;&lt;br /&gt;
   repeat&lt;br /&gt;
     while a [ i ] &amp;lt; key do &lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
     while key &amp;lt; a [ j ] do &lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     if i &amp;lt;= j then begin&lt;br /&gt;
       buf := a [ i ] ;&lt;br /&gt;
       a [ i ] := a [ j ] ;&lt;br /&gt;
       a [ j ] := buf ;&lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     end ;&lt;br /&gt;
   unti l i &amp;gt; j ;&lt;br /&gt;
   if left &amp;lt; j then&lt;br /&gt;
     QSort ( left , j ) ;&lt;br /&gt;
   if i &amp;lt; right then&lt;br /&gt;
     QSort ( i , right ) ;&lt;br /&gt;
 end ;&lt;br /&gt;
 begin&lt;br /&gt;
   . . .&lt;br /&gt;
   QSort ( 1 , N) ;&lt;br /&gt;
 end .&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q-1)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
 &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq cO(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
==Литература==&lt;br /&gt;
* Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10055</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10055"/>
				<updated>2011-06-15T17:25:06Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Ссылки */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. В худшем случае работает за &amp;lt;Tex&amp;gt;O(n^2)&amp;lt;/Tex&amp;gt;, среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
 var&lt;br /&gt;
   a : array [ 1 . .N] of integer ;&lt;br /&gt;
 procedure QSort ( left , right : integer ) ;&lt;br /&gt;
   var&lt;br /&gt;
     i , j : integer ;&lt;br /&gt;
     key : integer ;&lt;br /&gt;
     buf : integer ;&lt;br /&gt;
 begin&lt;br /&gt;
   key := a [ random ( right - left + 1) + left ] ;&lt;br /&gt;
   i := left ;&lt;br /&gt;
   j := right ;&lt;br /&gt;
   repeat&lt;br /&gt;
     while a [ i ] &amp;lt; key do &lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
     while key &amp;lt; a [ j ] do &lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     if i &amp;lt;= j then begin&lt;br /&gt;
       buf := a [ i ] ;&lt;br /&gt;
       a [ i ] := a [ j ] ;&lt;br /&gt;
       a [ j ] := buf ;&lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     end ;&lt;br /&gt;
   unti l i &amp;gt; j ;&lt;br /&gt;
   if left &amp;lt; j then&lt;br /&gt;
     QSort ( left , j ) ;&lt;br /&gt;
   if i &amp;lt; right then&lt;br /&gt;
     QSort ( i , right ) ;&lt;br /&gt;
 end ;&lt;br /&gt;
 begin&lt;br /&gt;
   . . .&lt;br /&gt;
   QSort ( 1 , N) ;&lt;br /&gt;
 end .&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
Oh, boy, here we go! &lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q-1)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
 &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq cO(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10035</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10035"/>
				<updated>2011-06-15T15:57:09Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Алгоритм */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. В худшем случае работает за &amp;lt;Tex&amp;gt;O(n^2)&amp;lt;/Tex&amp;gt;, среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
 var&lt;br /&gt;
   a : array [ 1 . .N] of integer ;&lt;br /&gt;
 procedure QSort ( left , right : integer ) ;&lt;br /&gt;
   var&lt;br /&gt;
     i , j : integer ;&lt;br /&gt;
     key : integer ;&lt;br /&gt;
     buf : integer ;&lt;br /&gt;
 begin&lt;br /&gt;
   key := a [ random ( right - left + 1) + left ] ;&lt;br /&gt;
   i := left ;&lt;br /&gt;
   j := right ;&lt;br /&gt;
   repeat&lt;br /&gt;
     while a [ i ] &amp;lt; key do &lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
     while key &amp;lt; a [ j ] do &lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     if i &amp;lt;= j then begin&lt;br /&gt;
       buf := a [ i ] ;&lt;br /&gt;
       a [ i ] := a [ j ] ;&lt;br /&gt;
       a [ j ] := buf ;&lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     end ;&lt;br /&gt;
   unti l i &amp;gt; j ;&lt;br /&gt;
   if left &amp;lt; j then&lt;br /&gt;
     QSort ( left , j ) ;&lt;br /&gt;
   if i &amp;lt; right then&lt;br /&gt;
     QSort ( i , right ) ;&lt;br /&gt;
 end ;&lt;br /&gt;
 begin&lt;br /&gt;
   . . .&lt;br /&gt;
   QSort ( 1 , N) ;&lt;br /&gt;
 end .&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
Oh, boy, here we go! &lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q-1)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
 &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq cO(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
Так как некий ленивый за***нец не собирается делать вики-конспект я его внаглую беру себе =^-^=.&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10034</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=10034"/>
				<updated>2011-06-15T15:55:45Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. В худшем случае работает за &amp;lt;Tex&amp;gt;O(n^2)&amp;lt;/Tex&amp;gt;, среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
 var&lt;br /&gt;
   a : array [ 1 . .N] of integer ;&lt;br /&gt;
 procedure QSort ( left , right : integer ) ;&lt;br /&gt;
   var&lt;br /&gt;
     i , j : integer ;&lt;br /&gt;
     key : integer ;&lt;br /&gt;
     buf : integer ;&lt;br /&gt;
 begin&lt;br /&gt;
   key := a [ random ( right - left + 1) + left ] ;&lt;br /&gt;
   i := left ;&lt;br /&gt;
   j := right ;&lt;br /&gt;
   repeat&lt;br /&gt;
     while a [ i ] &amp;lt; key do &lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
     while key &amp;lt; a [ j ] do &lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     if i &amp;lt;= j then begin&lt;br /&gt;
       buf := a [ i ] ;&lt;br /&gt;
       a [ i ] := a [ j ] ;&lt;br /&gt;
       a [ j ] := buf ;&lt;br /&gt;
       inc ( i ) ;&lt;br /&gt;
       dec ( j ) ;&lt;br /&gt;
     end ;&lt;br /&gt;
   unti l i &amp;gt; j ;&lt;br /&gt;
   if l e f t &amp;lt; j then&lt;br /&gt;
     QSort ( l e f t , j ) ;&lt;br /&gt;
   if i &amp;lt; r i g h t then&lt;br /&gt;
     QSort ( i , r i g h t ) ;&lt;br /&gt;
 end ;&lt;br /&gt;
 begin&lt;br /&gt;
   . . .&lt;br /&gt;
   QSort ( 1 , N) ;&lt;br /&gt;
 end .&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
Oh, boy, here we go! &lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q-1)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
 &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq cO(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
Так как некий ленивый за***нец не собирается делать вики-конспект я его внаглую беру себе =^-^=.&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0_%D0%B8_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B&amp;diff=10027</id>
		<title>Дискретная математика и алгоритмы</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0_%D0%B8_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B&amp;diff=10027"/>
				<updated>2011-06-15T15:36:59Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: /* Сортировка */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;[[Категория:Дискретная математика и алгоритмы]]&lt;br /&gt;
== Отношения ==&lt;br /&gt;
*[[Определение отношения]]&lt;br /&gt;
*[[Степень отношений]]&lt;br /&gt;
*[[Рефлексивное отношение|Рефлексивное отношение. Антирефлексивное отношение.]]&lt;br /&gt;
*[[Симметричное отношение]]&lt;br /&gt;
*[[Антисимметричное отношение]]&lt;br /&gt;
*[[Композиция отношений|Композиция отношений. Обратное отношение]]&lt;br /&gt;
*[[Транзитивное отношение]]&lt;br /&gt;
*[[Транзитивное замыкание|Транзитивное замыкание отношения]]&lt;br /&gt;
*[[Алгоритм Флойда — Уоршелла|Алгоритм Флойда-Уоршалла построения транзитивного замыкания отношения]]&lt;br /&gt;
&lt;br /&gt;
== Булевы функции ==&lt;br /&gt;
*[[Определение булевой функции]]&lt;br /&gt;
*[[Примеры булевых функций|Примеры булевых функций: все функции от нуля, одной и двух переменных]]&lt;br /&gt;
*[[Подстановка одной функции в другую, отождествление переменных]]&lt;br /&gt;
*[[Представление функции формулой, полные системы функций]]	&lt;br /&gt;
*[[СДНФ]]&lt;br /&gt;
*[[СКНФ]]&lt;br /&gt;
*[[Полином Жегалкина]]&lt;br /&gt;
*[[Теорема Поста о полной системе функций]]&lt;br /&gt;
*[[Сокращенная и минимальная ДНФ]]&lt;br /&gt;
*[[Минимизация ДНФ с помощью покрытий гиперкуба и карт Карно]]&lt;br /&gt;
*[[Специальные формы КНФ|Специальные формы КНФ: КНФ в форме Хорна и КНФ в форме Крома]]&lt;br /&gt;
*[[Преобразование Мёбиуса для получения коэффициентов полинома Жегалкина]]&lt;br /&gt;
*[[Представление функции класса DM с помощью медианы]]&lt;br /&gt;
*[[Пороговая функция]]&lt;br /&gt;
&lt;br /&gt;
== Схемы из функциональных элементов ==&lt;br /&gt;
*[[Реализация булевой функции схемой из функциональных элементов]]&lt;br /&gt;
*[[Изменение размера оптимальной схемы при переходе к другому базису]]&lt;br /&gt;
*[[Cумматор]]&lt;br /&gt;
*[[Каскадный сумматор]]&lt;br /&gt;
*[[Двоичный каскадный сумматор]]&lt;br /&gt;
*[[Матричный умножитель]]&lt;br /&gt;
*[[Дерево Уоллеса]]&lt;br /&gt;
&lt;br /&gt;
== Представление информации ==&lt;br /&gt;
*[[Кодирование информации]]&lt;br /&gt;
*[[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]&lt;br /&gt;
*[[Представление вещественных чисел]]&lt;br /&gt;
*[[Представление символов, таблицы кодировок]]&lt;br /&gt;
*[[Алгоритм Хаффмана]]&lt;br /&gt;
&lt;br /&gt;
== Алгоритмы сжатия ==&lt;br /&gt;
*[[Алгоритм LZW]]&lt;br /&gt;
*[[Алгоритмы LZ77 и LZ78]]&lt;br /&gt;
*[[Преобразование Барроуза-Уиллера]]&lt;br /&gt;
*[[Обратное преобразование Барроуза-Уиллера]]&lt;br /&gt;
*[[Преобразование MTF]]&lt;br /&gt;
*[[Расстояние Хэмминга]]&lt;br /&gt;
*[[Избыточное кодирование, код Хэмминга]]&lt;br /&gt;
&lt;br /&gt;
== Комбинаторика ==&lt;br /&gt;
*[[Комбинаторные объекты]]&lt;br /&gt;
*[[Лексикографический порядок]]&lt;br /&gt;
*[[Формула включения-исключения]]&lt;br /&gt;
*[[Генерация комбинаторных объектов в лексикографическом порядке]]&lt;br /&gt;
*[[Получение номера по объекту]]&lt;br /&gt;
*[[Получение объекта по номеру]]&lt;br /&gt;
*[[Получение следующего объекта]]&lt;br /&gt;
*[[Коды Грея]]&lt;br /&gt;
*[[Коды Грея для перестановок]]&lt;br /&gt;
*[[Цепные коды]]&lt;br /&gt;
*[[Действие перестановки на набор из элементов, представление в виде циклов]]&lt;br /&gt;
*[[Метод генерации случайной перестановки, алгоритм Фишера-Йетса]]&lt;br /&gt;
*[[Таблица инверсий]]&lt;br /&gt;
*[[Умножение перестановок, обратная перестановка, группа перестановок]]&lt;br /&gt;
*[[Теорема Кэли]]&lt;br /&gt;
*[[Матричное представление перестановок]]&lt;br /&gt;
*[[Задача о минимуме/максимуме скалярного произведения]]&lt;br /&gt;
*[[Задача о монотонных подпоследовательностях, теорема о связи длины НВП и НУП]]&lt;br /&gt;
*[[Поиск наибольшей возрастающей подпоследовательности и т. д.]]&lt;br /&gt;
*[[Нахождение количества разбиений числа на слагаемые | Нахождение количества разбиений числа на слагаемые. Пентагональная теорема Эйлера]]&lt;br /&gt;
&lt;br /&gt;
== Динамическое программирование ==&lt;br /&gt;
*[[Кратчайший путь в ациклическом графе]]&lt;br /&gt;
*[[Задача о расстановке знаков в выражении]]&lt;br /&gt;
*[[Задача о наибольшей общей подпоследовательности]]&lt;br /&gt;
*[[Задача о перемножении матриц]]&lt;br /&gt;
*[[Задача о наибольшей возрастающей подпоследовательности]]&lt;br /&gt;
*[[Задача о паросочетании максимального веса в дереве, амортизированные оценки для ДП на дереве]]&lt;br /&gt;
*[[Метод четырех русских для умножения матриц]]&lt;br /&gt;
*[[Применение метода четырех русских в задачах ДП на примере задачи о НОП]]&lt;br /&gt;
*[[Задача коммивояжера, ДП по подмножествам]]&lt;br /&gt;
*[[Задача о выводе в контекстно-свободной грамматике, алгоритм Кока-Янгера-Касами]]&lt;br /&gt;
*[[Задача о редакционном расстоянии, алгоритм Левенштейна]]&lt;br /&gt;
*[[Задача об оптимальном префиксном коде с сохранением порядка. Монотонность точки разреза]]&lt;br /&gt;
&lt;br /&gt;
== Теория вероятности ==&lt;br /&gt;
*[[Вероятностное пространство, элементарный исход, событие]]&lt;br /&gt;
*[[Независимые события]]&lt;br /&gt;
*[[Условная вероятность]]&lt;br /&gt;
*[[Формула Байеса]]&lt;br /&gt;
*[[Формула полной вероятности]]&lt;br /&gt;
*[[Дискретная случайная величина]]&lt;br /&gt;
*[[Независимые случайные величины]]&lt;br /&gt;
*[[Линейность математического ожидания]]&lt;br /&gt;
*[[Ковариация случайных величин]]&lt;br /&gt;
*[[Дисперсия случайной величины]]&lt;br /&gt;
*[[Энтропия случайного источника]]&lt;br /&gt;
*[[Симуляция одним распределением другого]]&lt;br /&gt;
*[[Арифметическое кодирование]]&lt;br /&gt;
&lt;br /&gt;
== [[Марковская цепь|Марковские цепи]] ==&lt;br /&gt;
&lt;br /&gt;
* [[Теорема о поглощении]]&lt;br /&gt;
* [[Фундаментальная матрица]]&lt;br /&gt;
* [[Математическое ожидание времени поглощения]]&lt;br /&gt;
* [[Расчет вероятности поглощения в состоянии]]&lt;br /&gt;
* [[Эргодическая марковская цепь]]&lt;br /&gt;
* [[Регулярная марковская цепь]]&lt;br /&gt;
&lt;br /&gt;
== Амортизационный анализ ==&lt;br /&gt;
* [[Амортизационный анализ. Метод предоплаты]]&lt;br /&gt;
* [[Саморасширяющийся массив]]&lt;br /&gt;
* [[Массив с увеличением/уменьшением размера]]&lt;br /&gt;
* [[Стек]]&lt;br /&gt;
* [[Очередь]]&lt;br /&gt;
* [[Список]]&lt;br /&gt;
&lt;br /&gt;
== Приоритетные очереди ==&lt;br /&gt;
* [[Двоичная куча|Двоичная куча]]&lt;br /&gt;
* [[Биномиальная куча|Биномиальная пирамида]]&lt;br /&gt;
* [[Фибоначчиевы кучи|Фибоначчиевы кучи]]&lt;br /&gt;
&lt;br /&gt;
== Система непересекающихся множеств ==&lt;br /&gt;
* [[СНМ(наивные реализации) | Наивные реализации]]&lt;br /&gt;
* [[СНМ(списки с весовой эвристикой) | Списки с весовой эвристикой]]&lt;br /&gt;
* [[СНМ(реализация с помощью леса корневых деревьев) | Реализация с помощью леса корневых деревьев]]&lt;br /&gt;
* [[Анализ реализации с ранговой эвристикой  | Анализ реализации с ранговой эвристикой]]&lt;br /&gt;
&lt;br /&gt;
== Деревья поиска ==&lt;br /&gt;
* [[Упорядоченное множество]]&lt;br /&gt;
* [[Дерево поиска, наивная реализация]]&lt;br /&gt;
* [[АВЛ-дерево]]&lt;br /&gt;
* [[2-3 дерево]]&lt;br /&gt;
* [[B-дерево]]&lt;br /&gt;
* [[Красно-черное дерево]]&lt;br /&gt;
* [[Декартово дерево]]&lt;br /&gt;
* [[Splay-дерево]]&lt;br /&gt;
* [[Декартово дерево по неявному ключу]]&lt;br /&gt;
* [[Дерево ван Эмде Боаса]]&lt;br /&gt;
&lt;br /&gt;
== Дерево отрезков ==&lt;br /&gt;
* [[Статистики на отрезках. Корневая эвристика]]&lt;br /&gt;
* [[Дерево отрезков. Построение]]&lt;br /&gt;
* [[Реализация запроса в дереве отрезков сверху]]&lt;br /&gt;
* [[Реализация запроса в дереве отрезков снизу]]&lt;br /&gt;
* [[Несогласованные поддеревья. Реализация массового обновления]]&lt;br /&gt;
* [[Многомерное дерево отрезков]]&lt;br /&gt;
* [[Сжатое многомерное дерево отрезков]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Дерево Фенвика ==&lt;br /&gt;
* [[Дерево Фенвика]]&lt;br /&gt;
* [[Встречное дерево Фенвика]]&lt;br /&gt;
* [[Дерево Фенвика, запрос изменения элемента]]&lt;br /&gt;
* [[Многомерное дерево Фенвика]]&lt;br /&gt;
&lt;br /&gt;
== Хеширование ==&lt;br /&gt;
* [[Хеширование]]&lt;br /&gt;
* [[Различные алгоритмы хеширования]]&lt;br /&gt;
* [[Открытое и закрытое хеширование]]&lt;br /&gt;
* [[Поиск свободного места при закрытом хешировании]]&lt;br /&gt;
* [[Хеширование кукушки]]&lt;br /&gt;
* [[Двойное хеширование]]&lt;br /&gt;
* [[Перехеширование. Амортизационный анализ]]&lt;br /&gt;
* [[Фильтр Блума]]&lt;br /&gt;
* [[Универсальное семейство хеш-функций]]&lt;br /&gt;
&lt;br /&gt;
== Сортировка ==&lt;br /&gt;
* [[Сортировка пузырьком]]&lt;br /&gt;
* [[Сортировка слиянием]]&lt;br /&gt;
* [[Cортировка слиянием с использованием O(1) дополнительной памяти]]&lt;br /&gt;
* [[Сортировка вставками]]&lt;br /&gt;
* [[Сортировка подсчетом]]&lt;br /&gt;
* [[Сортировка подсчетом сложных объектов]]&lt;br /&gt;
* [[Цифровая сортировка]]&lt;br /&gt;
* [[Поиск k-ой порядковой статистики]]&lt;br /&gt;
* [[Поиск k-й порядковой статистики за линейное время]]&lt;br /&gt;
* [[Теорема о нижней оценке для сортировки сравнениями]]&lt;br /&gt;
* [[Быстрая сортировка]]&lt;br /&gt;
&lt;br /&gt;
== [[Сортирующие сети]] ==&lt;br /&gt;
* [[0-1 принцип | Проверка сети компараторов на то, что она сортирующая. 0-1 принцип]]&lt;br /&gt;
* [[Сортирующие сети для квадратичных сортировок]]&lt;br /&gt;
* [[Сеть Бетчера]]&lt;br /&gt;
&lt;br /&gt;
== Алгоритмы поиска ==&lt;br /&gt;
* [[Троичный поиск]]&lt;br /&gt;
* [[Поиск с помощью золотого сечения]]&lt;br /&gt;
* [[Интерполяционный поиск]]&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D1%83%D0%BC_%D0%BF%D0%BE_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%BC%D1%83_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D1%83_%D0%B7%D0%B0_2_%D1%81%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D1%80&amp;diff=9730</id>
		<title>Обсуждение:Теоретический минимум по математическому анализу за 2 семестр</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D1%83%D0%BC_%D0%BF%D0%BE_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%BC%D1%83_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D1%83_%D0%B7%D0%B0_2_%D1%81%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D1%80&amp;diff=9730"/>
				<updated>2011-06-12T16:02:00Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Вопрос №7. Признак типа Абеля-Дирихле&lt;br /&gt;
&lt;br /&gt;
казалось бы, недостаточно, чтобы &amp;lt;tex&amp;gt;a_n(x)&amp;lt;/tex&amp;gt; стремилась к нулю, нужно еще чтобы она это делала монотонно&lt;br /&gt;
:fixed&lt;br /&gt;
&lt;br /&gt;
14, 15 вопрос, конечно, очень хотелось бы, что-бы запилили [[Участник:System29a|System29a]] 02:48, 12 июня 2011 (UTC)&lt;br /&gt;
&lt;br /&gt;
Могу ошибаться но в 49 вопросе написан критерий существования первообразной, а нужно что-то вроде &lt;br /&gt;
ранг тау -&amp;gt; 0 предел разности верхних и нижних сумм дарбу -&amp;gt;0?&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=9248</id>
		<title>Быстрая сортировка</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0&amp;diff=9248"/>
				<updated>2011-06-07T18:09:51Z</updated>
		
		<summary type="html">&lt;p&gt;ЗабылПароль: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{В разработке}}&lt;br /&gt;
'''Быстрая сортировка'''(qsort, сортировка Хоара) - один из самых известных и широко используемых алгоритмов сортировки. В худшем случае работает за &amp;lt;Tex&amp;gt;O(n^2)&amp;lt;/Tex&amp;gt;, среднее время работы &amp;lt;Tex&amp;gt;O(nlogn)&amp;lt;/Tex&amp;gt;, что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении.&lt;br /&gt;
&lt;br /&gt;
==Алгоритм==&lt;br /&gt;
* Выбираем опорный элемент.&lt;br /&gt;
* Разбиваем массив таким образом, что все элементы меньшие или равные опорному будут лежать левее опроного элемента, а большие или равные правее.&lt;br /&gt;
* Рекурсивно сотрируем &amp;quot;маленькие&amp;quot; и &amp;quot;большие&amp;quot; элементы.&lt;br /&gt;
&lt;br /&gt;
===Оптимизация глубины рекурсии до O(logn) в худшем случае===&lt;br /&gt;
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь &amp;lt;Tex&amp;gt;O(n)&amp;lt;/Tex&amp;gt;. Этого можно избежать, если в цикле разбивать массив, но рекурсивно вызываться только от части, содержащей меньшее число элементов, а большую часть продолжать разбивать в цикле.&lt;br /&gt;
==Асимптотика==&lt;br /&gt;
Oh, boy, here we go! &lt;br /&gt;
===Худшее время работы===&lt;br /&gt;
Обозначим худшее время работы за &amp;lt;tex&amp;gt;T(n)&amp;lt;/tex&amp;gt;. Получим рекуррентное соотношение &lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) = Max(T(q-1)+T(n-q-1))+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
 &lt;br /&gt;
Предположим, что &amp;lt;tex&amp;gt;T(n) \leq cO(n^2)&amp;lt;/tex&amp;gt;. Тогда получим&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq Max(cq^2+c(n-q-1)^2)+\Theta(n) = &lt;br /&gt;
cMax(q^2+(n-q-1)^2)+\Theta(n)&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;Max(q^2+(n-q-1)^2) \leq (n-1)^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;T(n) \leq cn^2 - c(2n-1) + \Theta(n) \leq cn^2&amp;lt;/tex&amp;gt;&lt;br /&gt;
Таким образом &amp;lt;tex&amp;gt;T(n) = O(n^2)&amp;lt;/tex&amp;gt;&lt;br /&gt;
===Среднее время работы===&lt;br /&gt;
&lt;br /&gt;
==Ссылки==&lt;br /&gt;
http://ru.wikipedia.org/wiki/Быстрая_сортировка &lt;br /&gt;
 &lt;br /&gt;
http://en.wikipedia.org/wiki/Quicksort&lt;br /&gt;
&lt;br /&gt;
Так как некий ленивый за***нец не собирается делать вики-конспект я его внаглую беру себе =^-^=.&lt;/div&gt;</summary>
		<author><name>ЗабылПароль</name></author>	</entry>

	</feed>