Программирование на языке пролог
ModernLib.Net / Программирование / Клоксин У. / Программирование на языке пролог - Чтение
(стр. 14)
Автор:
|
Клоксин У. |
Жанр:
|
Программирование |
-
Читать книгу полностью
(715 Кб)
- Скачать в формате fb2
(716 Кб)
- Скачать в формате doc
(1 Кб)
- Скачать в формате txt
(1 Кб)
- Скачать в формате html
(503 Кб)
- Страницы:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
|
|
7.8. Использование базы данных: random, генатом, найтивсе
Во всех программах, которые рассматривались до сих пор, база данных использовалась лишь для хранения фактов и правил, с помощью которых определяются предикаты. Можно использовать базу данных и для хранения обычных структур, т. е. таких, которые порождаются при выполнении программы. До сих пор для передачи таких структур от одного предиката к другому мы применяли механизм аргументов. Однако существуют доводы в пользу хранения этой информации в базе данных. Иногда некоторый элемент информации может потребоваться во многих частях программы. Передача его через механизм аргументов может привести к появлению одного – двух дополнительных аргументов у большинства предикатов. Другим доводом является возможность сохранения информации при возвратном ходе. В этом разделе мы рассмотрим три предиката, которые позволяют хранить в базе данных структуры, время жизни которых превышает то, что может быть обеспечено с помощью переменных. Вот эти три предиката:
random,вырабатывающий при каждом вызове псевдослучайное целое,
найтивсе,порождающий список всех структур, обеспечивающих истинность данного предиката, и
генатом,порождающий атомы с различающимися именами.
Генератор случайных чисел (random)
Цель
random(R, N)конкретизирует
Nцелым числом, случайно выбранным в диапазоне от
1до
R. Метод выбора случайного числа основан на конгруэнтном методе с использованием начального числа («затравки») инициализируемого произвольным целым числом. Каждый раз, когда требуется случайное число, ответ вычисляется на основе существующего начального значения, и при этом порождается новое начальное число, которое сохраняется до тех пор, пока вновь не потребуется вычислить случайное число. Для хранения начального числа между вызовами
randomмы используем базу данных. После того как начальное число использовано, мы убираем (с помощью
retract)из базы данных старую информацию о начальном числе, вычисляем его новое значение, и засылаем в базу данных новую информацию (с помощью
asserta).Исходное начальное значение – это просто факт в базе данных, с функтором
seedимеющим одну компоненту – целое значение начального числа.
seed(13).
random (R,N):-seed(S),N is (S mod R) + 1,retract(seed(S)),NewSeed is (125 * S + 1) mod 4096,asserta(seed(NewSeed)),!.
Используя семантику
retractможно упростить определение
randomследующим образом:
random(R,N):-retract(seed(S)),N is (S mod R)+1,NewSeed is (125 * S +1) mod 4096,asserta(seed(NewSeed)),!.
Для того, чтобы напечатать последовательность случайных чисел, расположенных в диапазоне между 1 и 10, которая обры-вается после того, как будет порождено значение 5, нужно задать следующий вопрос:
?- repeat, random(10,X), write(X), nl, X=5.
Генератор имен (генатом)
Предикат
генатомпозволяет порождать новые атомы Пролога. Если у нас есть программа, которая воспринимает информацию об окружающем мире (например, путем анализа описывающих его предложений на английском языке), то в случае появления в этом мире нового объекта возникают трудности с его обозначением. Естественно представлять объект атомом Пролога. Если объект ранее не встречался, мы должны убедиться в том, что тот атом, который мы ему сопоставляем, случайно не совпал с другим атомом, уже представляющим какой-то другой объект. Иными словами, нам необходимо иметь возможность формировать новые атомы. Мы можем также потребовать, чтобы созданный атом имел также некоторое мнемоническое значение: это облегчит понимание информации выводимой нашей программой. Если бы атомы представляли, скажем, студентов, то целесообразно было
быназвать первого студента –
студент1,второго –
студент2, третьего –
студентЗи т. д. Если к тому же нам нужно было бы работать с объектами представляющими еще и преподавателей, то можно было бы выбрать для их представления атомы
преподаватель1,
преподаватель2, преподавательЗи т. д.
Функция программы
генатомсостоит в том, чтобы порождать новые атомы от заданных корней (таких как
студенти
преподаватель).Для каждого корня программа запоминает, какой номер был использован в последний раз. Поэтому, когда в следующий раз от нее требуется породить атом с данным корнем можно гарантировать, что он будет отличаться от тех, что были порождены ранее. Так, когда вопрос
?- генатом(студент,X).
задан впервые, ответом будет
X = студент1
В следующий же раз ответом будет
X = студент2
и т. д.
Заметим, что эти различающиеся решения при возвратном ходе не порождаются (
генатом(Х, Y)нельзя согласовать вновь), они порождаются последующими целями, включающими этот предикат.
В определении
генатомиспользуется вспомогательный предикат
тек_номер. Контроль за тем, какой номер использовать следующим для данного корня, осуществляется программой
генатомпутем записи в базу данных фактов вида
тек_номери удаления фактов, которые стали ненужными. Факт
тек_номер (Корень, Номер)означает, что последний номер, использованный с корнем
Корень,был
Номер.Иными словами, последний атом, порожденный для этого корня, состоял из литер, взятых из
Корень,за которыми был приформирован номер, взятый из
Номер.Когда Пролог пытается доказать согласованность цели
генатом, обычно делается следующее: последний факт
тек_номердля заданного корня удаляется из базы данных, к его номеру прибавляется 1, и новый факт
тек_номерзапоминается в базе данных, заменяя исключенный факт. С этого момента новый номер может быть использован как основа для порождения нового атома. Хранить информацию о текущем номере в базе данных очень удобно. В противном случае каждый предикат, прямо или косвенно участвующий в выполнении
генатом, должен был бы пересылать информацию о текущих номерах через дополнительные аргументы.
Последние несколько утверждений этой программы определяют предикат
целое_имя,который используется для преобразования целого числа в последовательность литер-цифр. Атомы, порождаемые
генатом,формируются с помощью встроенного предиката
name,который формирует атом из литер корня, за которыми следуют цифры номера. В некоторых реализациях Пролога используется версия предиката
name,которая выполняет также функции предиката
целое_имя,однако весьма поучительно посмотреть, как его можно определить на Прологе. В этом определении неявно используется тот факт, что коды ASCII для цифр 0, 1, 2 и т. д. равны соответственно 48, 49, 50 и т. д. Поэтому, чтобы преобразовать число меньшее 10 в код ASCII соответствующей цифры, достаточно прибавить к этому числу 48. Перевести в последовательность литер число, большее 9, сложнее. Последнюю цифру такого числа получить легко, поскольку это просто остаток от деления на
10 (число mod 10).Таким образом, цифры числа легче формировать в обратном порядке. Мы просто циклически повторяем следующие операции: получение последней цифры, вычисление остальной части числа (результат его целого деления на 10). Определение этого на Прологе выглядит следующим образом:
цифры_наоборот(N,[С]):- N‹10,!, С is N+48.
цифры_наоборот(М,[С|Сs]):-С is (N mod 10) + 48,N1 is N/10,цифры_нaoбopот(N1,Cs).
Чтобы получить цифры в правильном порядке, применим трюк: в этот предикат добавим дополнительный аргумент – список «уже сформированных» цифр, С помощью этого аргумента мы можем получать цифры по одной в обратном порядке, но в итоговый список вставлять их в прямом порядке. Это делается следующим образом. Пусть у нас есть число 123. В начале список «уже сформированных» цифр есть []. Первым получаем число 3, которое преобразуется в литеру с кодом 51. Затем мы рекурсивно вызываем
целое_имя,чтобы найти цифры числа 12. Список «уже сформированных» цифр, который передается в это целевое утверждение, содержит литеру, вставленную в исходный список «уже сформированных» цифр – это список [51]. Вторая цель
целое_имявыдает код 50 (для цифры 2) и снова вызывает
целое_имя,на этот раз с числом 1 и со списком «уже сформированных» цифр [50, 51]. Эта последняя цель успешно выполняется и, поскольку число было меньше 10, дает ответ [49,50,51]. Этот ответ передается через аргументы разных целей
целое_имяи дает ответ на исходный вопрос – какие цифры соответствуют числу 123?
Приведем теперь всю программу полностью.
/* Породить новый атом, начинающийся с заданного корня, и оканчивающийся уникальным числом. */
генатом (Корень,Атом),выдать_номер(Корень,Номер), name(Корень,Имя1), целое_имя(Номер,Имя2), присоединить(Имя1,Имя2,Имя), name(Атом,Имя).
выдать_номер(Корень, Номер):-retract(тeк_номер(Корень, Номер1)),!,Номер is Номер 1 + 1, asserta(тек_номер(Корень, Номер)).
выдать_номер(Корень,1):- asserta(тек_номep(Kopeнь,l)).
/* Преобразовать целое в список цифр */
целое_имя(Цел,Итогспи):- целое_имя (Цел, [], Итогспи).
целое_имя(I,Текспи,[С|Текспи]:- I ‹10,!, С is I+48.
целое_имя(I,Текспи,Итогспи):-Частное is I/10, Остаток is I mod 10,С is Остаток+48.
целое_имя(Частное,[С|Текспи],Итогспи).
Генератор списков структур (найтивсе)
В некоторых прикладных задачах полезно уметь определять все термы, которые делают истинным заданный предикат. Например, мы могли бы захотеть построить список всех детей Адама и Евы с помощью предиката
родителииз гл.
1(и располагая базой данных с фактами
родителио родительских отношениях). Для этого мы могли бы использовать предикат по имени
найтивсе, который мы определим ниже. Цель
найтивсе(Х,G, L)строит список
L, состоящий из всех объектов
Xтаких, что они позволяют доказать согласованность цели
G. При этом предполагается, что переменная
Gконкретизирована произвольным термом, однако таким, что
найтивсерассматривает его как целевое утверждение Пролога. Кроме того переменная
Xдолжна появиться где-то внутри
G. Таким образом
Gможет быть конкретизирована целевым утверждением Пролога произвольной сложности. Для того, чтобы найти всех детей Адама и Евы, необходимо было бы задать следующий вопрос:
?- найтивсе(Х, родители(Х,ева,адам), L).
Переменная
Lбыла бы конкретизирована списком всех
X, для которых предикату
родители(Х,ева,адам)можно найти сопоставление в базе данных. Задача
найтивсезаключается в том, чтобы повторять попытки согласовать его второй аргумент, и каждый раз, когда это удается, программа должна брать значение X и помещать его в базу данных. Когда попытка согласовать второй аргумент завершится неудачно, собираются все значения
X, занесенные в базу данных. Получившийся при этом список возвращается как третий аргумент. Если попытка доказать согласованность второго аргумента
ни разуне удастся, то третий аргумент будет конкретизирован пустым списком. При помещении элементов данных в базу данных используется встроенный предикат
asserta,который вставляет термы перед теми, которые имеют тот же самый функтор. Чтобы поместить элемент
Xв базу данных, мы задаем его в качестве компоненты структуры по имени
найдено.Программа для
найтивсевыглядит следующим образом:
найтивce(X,G,_):-asserta(найденo(мapкep)), call(G), asserta(найденo(X)),fail.
найтивсе(_,_,L):- собрать_найденное([],М),!, L=M.
собрать_найденное(S,L):- взятьеще(Х),!,собрать_найденное([Х |S],L).
собрать_найденное(L,L).
взятьеще(Х):- retract(найдено(Х)),!, Х\==маркер.
Предикат
найтивсе,начинает свою работу с занесения специального маркера, который представляет из себя структуру с функтором
найденои с компонентой
маркер.Этот специальный маркер отмечает место в базе данных, перед которым будут занесены (с помощью
asserta)все
X,согласующие
Gс базой данных при данном запуске
найтивсе.Затем делается попытка согласовать
Gи каждый раз, когда это удается,
Xзаносится в базу данных в качестве компоненты функтора
найдено.Предикат
failинициирует процесс возврата и попытку повторно согласовать
G (assertaсогласуется не более одного раза). Когда попытка согласовать
Gзавершается неудачей, процесс возврата приводит к неудаче первого утверждения из определения
найтивсе,и делается попытка согласовать в качестве цели второе утверждение. Второе утверждение вызывает
собрать_найденноедля выборки из базы данных всех структур найдено и включения их компонент в список. Предикат
собрать_найденноевставляет каждый элемент в переменную, где хранится список «уже собранных» элементов. Этот прием мы рассматривали выше при разборе программы ге-натом. Как только встречается компонента
маркер, взятьещезавершается неудачей, после чего выбирается второе утверждение для
собрать_найденное.При сопоставлении
егос текущей целью второй аргумент (результат) сцепляется с первым аргументом (с набранным списком)
Заметим, что присутствие в базе данных структуры
найдено (маркер)указывает на некоторое конкретное употребление
найтивсе. Это означает, что
найтивсеможет вызываться рекурсивно – любое использование
найтивсево втором аргументе другого
найтивсебудет обработано правильно.
В разд. 7.9 мы разработаем программу, которая использует предикат
найтивседля построения списка всех потомков узла в графе. Этот список необходим для реализации программы поиска по графу вширь.
Упражнение 7.7.Напишите Пролог-программу
случайный_выбортакую, что цель
случайный_выбор(L, Е)конкретизирует Е случайно выбранным элементом списка
L. Подсказка: используйте генератор случайных чисел и определите предикат, который возвращает N-й элемент списка.
Упражнение 7.8.Задана цель
найтивсе(Х,G, L). Что произойдет, если в
Gимеются неконкретизированные переменные не сцепленные с
X?
7.9. Поиск по графу
Граф – это сеть, состоящая из узлов, соединенных дугами. Например, географическую карту можно рассматривать как граф, где узлами являются населенные пункты, а дугами, соединяющие их дороги. Если вы хотите найти кратчайший маршрут между двумя населенными пунктами, вам предстоит решить задачу нахождения кратчайшего пути между двумя узлами графа.
Проще всего описать граф в базе данных с помощью фактов, представляющих дуги между узлами графа. На рис, 7.3 приведен пример графа и его представления с помощью фактов. Чтобы пройти от узла
gк узлу
а, мы можем пойти по пути
g,
d,
e,
аили по одному из многих других возможных путей. Если мы представляем ориентированный граф, то предикат а следует понимать так, что
а(Х, Y)означает, что существует дуга из
Xв
Y, но из этого не следует существование дуги из
Yв
X. В данном разделе мы будем иметь дело только с неориентированными графами, у которых все дуги двунаправленные. Это допущение совпадает с тем, которое мы делаем в разд. 7.2 при поиске в лабиринте.
Простейшая программа поиска по графу, представленному так, как указано выше, выглядит следующим образом:
переход(Х,X).
переход(Х,Y):- (a(X,Z);a(Z,X)), переход(Z,Y).
К сожалению, эта программа может зацикливаться. Поэтому, как и раньше, мы используем список Т для хранения перечня тех узлов, в которых мы уже побывали в какой-либо рекурсии предиката.
переход(Х,Х,Т).
переход(Х,Y,T):- (a(X,Z);a(Z,X)), not (принадлежит(Z, Т)),переход(Z, Y,[Z|T]).
Эта программа, разработанная в разд. 7.2, осуществляет так называемый поиск «вглубь», поскольку вначале рассматривается только один из соседей узла по графу, Другие же соседи игнорируются до тех пор, пока неудачные попытки согласовать цели в рекурсивных вызовах не возвратят Пролог к рассмотрению данного узла.
Теперь давайте рассмотрим такой поиск по графу, который мог бы быть полезен на практике. Как быть, если мы должны спланировать маршрут поездки из одного города Северной Англии в другой? Для этого потребуется база данных с информацией о дорогах между городами в Северной Англии и их протяженности:
а(ньюкасл,карлайл,58).
а(карлайл,пенрит,23).
а(дарлингтон,ньюкасл,40).
а(пенрит, дарлингтон,52).
а(уэркингтон,карлайл,33).
а(уэркингтон,пенрит,39).
На некоторое время мы можем забыть о расстояниях и определить новый предикат:
a(X,Y):- a(X,Y,Z).
С помощью этого определения предиката а уже имеющаяся программа поиска по графу (
переход) будет находить пути, по которым можно переезжать из одного места на графе в любое другое. Однако программа
переходимеет недостаток: когда она успешно завершается, мы не знаем, какой путь она нашла. По меньшей мере мы вправе ожидать от программы переход
выдачинам в нужном порядке списка мест, которые придется посетить. Тем более, что в программе имеется перечень этих мест, правда, в порядке, обратном тому, какой нам нужен. Чтобы получить правильный список, мы можем воспользоваться программой
обр, определенной в разд. 7.5. Тогда мы получим новое определение программы
переход, которая возвращает найденный маршрут через свой третий аргумент:
переход(Старт,Цель,Путь):- переход0(Старт,Цель,[],R),обр(R, Путь).
переход0(Х,Х,Т,[Х|Т]).
переход0(Место,Y,Т,R):-следузел(Место,Т,Сосед),переход0(Сосед,Y,[Место|T],R).
следузел(Х,Бывали,Y):- (a(X,Y); a(Y,X)),not (принадлежит(Y,Бывали)).
Заметим, что предикат
следузелпозволяет получать для узла
X«правильный» узел
Y, т. е. такой, к которому можно непосредственно перейти от узла
X. Ниже приводится пример работы этой программы при поиске маршрута из Дарлингтона в Уэркингтон:
?- переход(дарлингтон,уэркингтон,Х)
Х=[дарлингтон,ньюкасл,карлайл,пенрит,уэркингтон]
Это не самый лучший маршрут, однако, программа найдет другие маршруты если мы инициируем процесс возврата.
У этой программы много недостатков. Она совершенно не управляет выбором следующего участка пути, поскольку у нее нет доступа к полному набору возможных вариантов, а те выборы, которые у программы имеются, не представлены явно в виде структуры, которая может анализироваться программой, а неявно предопределены схемой работы механизма возврата.
Ниже приведен переработанный вариант программы, который отличается большей универсальностью. В дальнейшем мы увидим, как с помощью простых изменений в этой программе можно получить разнообразные методы поиска.
переход(Старт,Цель,Путь):- переход1([[Старт]],Цель,R),обр(R, Путь).
переход1([Первый|Ост],Цель,Первый):- Первый =[Цель|_].
переход1([[Послед|Бывали]|Прочие],Цель,Путь):-найтивсе([Z, Послед|Бывали], следузел(Послед, Бывали,Z), Список), присоединить(Список, Прочие, НовПути), переход1(НовПути,Цель,Путь).
Предикат
следузелостается прежним. Предикату
переход1передается список рассматриваемых путей вместе с конечным пунктом, и в последнем аргументе он возвращает удачный путь. Список рассматриваемых путей – это просто все дороги, начинающиеся в начальной точке, которые мы уже рассмотрели. Мы надеемся, что одна из них при продлении даст путь, который приведет нас в конечный пункт. Все пути представлены в виде обратных списков населенных пунктов, так что они могут также выполнять функции перечня мест, где мы уже бывали.
В самом начале имеется только один возможный путь, который можно пытаться продлить. Это просто путь, который начинается в исходном пункте и никуда не ведет. Если мы стартуем из Дарлингтона, то это будет
[дарлингтон].Если теперь исследовать пути ведущие из Дарлингтона в соседние города, то можно обнаружить, что имеются два возможных пути
[ньюкасл, дарлингтон]и
[пенрит, дарлингтон].Поскольку Уэркингтон не встречается ни на одном из этих путей, необходимо решить, какой из этих путей следует продолжить. Если принято решение продлить первый путь, то мы обнаружим, что существует всего один доступный узел – последний город на этом пути. Итак, кроме пути Дарлингтон – Пенрит у нас есть новый путь:
[карлайл, ньюкасл, дарлингтон].
Наш «изыскатель»,
переход1ведет полный список путей, по которым, может быть, стоит двигаться. Как же он решает какой из путей следует рассмотреть первым? Он просто выбирает
первый попавшийся.Затем он ищет все возможные способы продления этого пути до следующего населенного пункта (используя
найтивседля построения списка всех таких продленных путей) и помещает получившиеся пути в
началосписка для рассмотрения их на следующем уровне рекурсии.
В результате,
переход1ведет себя таким образом, что он попробует все возможные способы продления первого пути прежде чем будет рассматривать альтернативные пути. Такая стратегия поиска является одним из вариантов
поиска вглубь.Между прочим,
переход1рассматривает пути совершенно в том же порядке, что и
переход0.Быть может вам будет интересно выяснить, почему это так.
Если нас интересует кратчайший путь от Дарлингтона до Уэркингтона, то имеющаяся программа для этого не подходит. Первое найденное ею решение – это не кратчайший путь, а наоборот, самый длинный (в данном случае). Нам нужно изменить программу таким образом, чтобы она строила пути в порядке возрастания их длины. Если мы изменим ее так, чтобы она всегда продлевала более короткие пути, прежде чем рассматривать более длинные, то она будет вынуждена находить вначале кратчайшие пути (если измерять длину пути числом городов на нем). Полученная программа будет осуществлять
поиск вширь.Единственное, что нужно сделать для этого – это вставлять новые альтернативы в конец всего списка возможностей, а не в начало, как в последнем примере. Мы просто исправим второе утверждение в определении
переход1, чтобы он выглядел следующим образом:
переход1([[Послед|Бывали]|Прочие],Цель,Путь):-найтивсе([Z,Послед|Бывали], следузел(Послед, Бывали,Z),Список), присоединить(Прочие,Список,НовПути), переход1(НовПути,Цель, Путь).
Теперь исправленная программа находит возможные пути из Дарлингтона в Уэркингтон в следующем порядке:
[дарлингтон,пенрит,уэркингтон]
[дарлингтон,ньюкасл, карлайл,уэркингтон]
[дарлингтон,пенрит,карлайл,уэркингтон]
[дарлингтон,ньюкасл,карлайл,пенрит,уэркингтон]
Мы можем значительно упростить эту программу, если уверены, что ответ на вопрос всегда существует и если нам нужно только первое решение. В этом случае отпадает необходимость в проверке на зацикливание. Попробуйте самостоятельно выяснить, почему это так.
К сожалению, путь через наименьшее число городов не обязательно будет самым кратчайшим по километражу. До сих пор мы не принимали во внимание информацию о расстояниях, имеющуюся в нашем графе. Если же мы добавим к нашему графу несколько фиктивных городов, чтобы получить:
а(ньюкасл,карлайл,58).
а(карлайл,пенрит,23).
а(городБ,городаА,15).
а(пенрит, дарлингтон,52).
а(городБ,городВ,10).
а(уэркингтон, карлайл, 33).
а(уэркингтон,городВ,5).
а(уэркингтон,пенрит,39).
а(дарлингтон,городА,25).
то путь, кратчайший по километражу, фактически будет построен последним, поскольку он проходит через большое число городов. С каждым путем, который может быть продолжен, нам нужно связать и поддерживать в процессе работы программы указатель текущей длины этого пути. Тогда программа будет всегда продлевать путь с наименьшим километражем. Такая стратегия называется поиском по критерию
первый-лучший.Будем теперь представлять путь в списке альтернативных путей в виде структуры
г(М, П), где
М– общая длина пути в километрах, а
П– список мест, где мы уже побывали. Модифицированный предикат
переходЗнаходит кратчайший путь в списке альтернатив. Предикат кратчайший выделяет кратчайший путь в отдельный список, а остальные пути – в другой список. Предикат
продлитьнаходит все допустимые продолжения текущего кратчайшего пути и добавляет их к списку. Это в свою очередь требует новой версии предиката
следузел, которая прибавляет расстояние до следующего города к уже вычисленному расстоянию. В целом программа выглядит так:
переходЗ (Пути,Цель,Путь):-кратчайший (Пути,Кратчайший,ОстПути), продлить(Кратчайший,Цель,ОстПути,Путь).
продлить(г(Расст,Путь),Цель,_,Путь):- Путь = [Цель|_].
продлить(г(Расст,[Послед| Бывали]),Цель,Пути,Путь):-найтивсе(г(D1,[Z,Послед|Бывали]),следузел(Послед,Бывали,Z,Расст,D1),Список), присоединить(Список,Пути,НовПути), переходЗ(НовПути,Цель,Пути).
кратчайший([Путь[Пути],Кратчайший,[ПутьЮст]):-кратчайший(Пути,Кратчайший,Ост), короче(Кратчайший,Путь),!.
кратчайший(Путь|Ост],Путь,Ост). короче(г(М1,_),г(М2, _):- M1 ‹ М2.
следузел(Х,Бывали,Y,Расст,НовРасст):-(a(X,Y,Z); a(Y,X,Z)),not(принадлежит(Y,Бывали)),НовРасст is Расст+Z.
Чтобы использовать эту программу, необходимо задать вопрос, содержащий предикат переход, определенный следующим образом:
переход (Старт,Цель,Путь):-переход3([г(0,[Старт])],Цель,R), обр(R,Путь).
Эта новая программа успешно строит возможные пути в по-рядке возрастания их фактической протяженности. Может быть, вам захочется изменить ее так, чтобы вместе с ответами она печатала длины различных путей.
Мы лишь затронули вопрос о возможных способах организации поиска по графу. Сведения о том, как осуществлять поиск по графу с использованием более эффективных критериев, чем «первый лучший», можно найти в литературе по искусственному интеллекту. Например: Nilsson N.
Principles of Artificial Intelligence,Springer-Verlag,
1982
[10]и Winstone
P. Artificial Intelligence,(second edition), Addison-Wesley, 1984.
[11]
7.10. Просеивай Двойки, Просеивай Тройки
Просеивай Двойки,
Просеивай Тройки,
Эратосфена Решето,
Пусть все кратные им отсеем,
Простые числа получим зато.
Аноним
Простое число – это целое положительное число, которое делится нацело только на 1 и на само себя. Например, число 5 – простое, а число 15 – нет, поскольку оно делится на 3. Один из методов построения простых чисел называется «решетом Эратосфена». Этот метод, «отсеивающий» простые числа, не превышающие N, работает следующим образом:
1. Поместить все числа от 2 до N в решето.
2. Выбрать и удалить из решета наименьшее число.
3. Включить это число в список простых.
4. Просеять через решето (удалить) все числа, кратные этому числу.
5. Если решето не пусто, то повторить шаги 2-5.
Чтобы перевести эти правила на Пролог, мы определим предикат
целыедля получения списка целых чисел, предикат
отсеятьдля проверки каждого элемента решета и предикат
удалитьдля создания нового содержимого решета путем удаления из старого всех чисел, кратных выбранному числу. Это новое содержимое опять передается предикату
отсеять.Предикат
простые- это предикат самого верхнего уровня, такой что
простые(N, L)конкретизирует
Lсписком простых чисел, заключенных в диапазоне от
1до
Nвключительно.
Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
|
|