Implementati probemele de la curs:

1. Problema labirintului

2. Problema mutarii blocurilor

3. Problema misionarilor si canibalilor.

Se cere ca la implementari sa se organizeze codul pe module.

Se cere existenta a cel putin un modul separat pentru algoritmii de cautare informata.

Solutie completa 2.

Se considera M blocuri si N spatii de depozitare. Intr-un spatiu de depozitare se pot pune blocuri
suprapuse. Se cere asezarea blocurilor in spatiile de depozitare. Pentru aceasta. se pot muta doar
blocurile aflate in varfurile stivelor de depozitare (modelul stivei).

Exp. Pentru M=4 si N=3, consideram configuratia initiala: [ [d], [a, b], [c] ].

• Configuratia finala va fi: [ [ ], [a, b, c, d], [ ] ].

• Pentru aceasta, scopul va fi reprezentat prin scop( [ [ ], [a, b, c, d], [ ] ] )
• Analog pentru configuratia initiala

Program Prolog:

initial( [ [d], [a, b], [c] ] ).

scop( [ [ ], [a, b, c, d], [ ] ] ).

s(L,Lr):- membru(X,L),

% X reprezinta, pe rand, cate o lista a configuratiei

% initiale L

X=[Varf|_],
 % X trebuie sa aiba cel putin un element

det_poz_el(L,N,X),

% determina pozitia N a lui X in lista L

stergn(L,Li,N),

% din L se sterge primul element (Varf) aflat in pozitia N

membru(Y,L),

% caut o alta pozitie N1 a listei L unde se va gasi lista Y

% sa il pot muta pe Varf. Evident N diferit de N1:

det_poz_el(L,N1,Y),

N\==N1,

adaugn(Varf,Li,Lr,N1),

% adaug Varf in lista Li la pozitia N1 si obtin Lr

not(permutare(L,Lr)).

% evit ciclicitatea in cautarea solutiei

%---------------------------------------------------------------------

% Definesc det_poz_el(L,N,X) ce determina pozitia N a lui X in lista L

det_poz_el([H|_],1,H).

det_poz_el([_|T],N,X):- det_poz_el(T,N1,X), N is N1+1.

%---------------------------------------------------------------------

% stergn(L,Li,N) sterge din L, de la pozitia N, primul element (Varf)

% De exemplu: pentru L=[[SubLista1],[SubLista2],..[SubListaN]..]

% unde [SubListaN] aflata pe pozitia N in L este de forma [Varf|T],

% in urma stergerii se obtine Li=[[SubLista1],[SubLista2],..[T]..].

stergn([[_|T]|L],[T|L],1).
% Sterg head-ul listei de pe pozitia 1 din L (prima lista)

stergn([H|T],[H|T1],N):- N>1,N1 is N-1,stergn(T,T1,N1).

%---------------------------------------------------------------------

% adaugn(Varf,Li,Lr,N1) adauga pe Varf in lista Li de la pozitia N1 in

% Se va obtine lista Lr.

% In consecinta: se sterge primul element din lista de pe pozitia N

% (primul element reprezinta deci primul bloc, iar listele reprezinta

% spatiile de depozitare) si ramane Li, dupa care elementul respectiv

% se muta in lista de pe pozitia N1 (pe alt spatiu de depozitare)

% rezultand noua configuratie Lr.

adaugn(Varf,[H|T],[[Varf|H]|T],1).

adaugn(Varf,[H|T],[H|T1],N):-N>1,N1 is N-1,adaugn(Varf,T,T1,N1).

%------------------------------------------------------------------

%Cautare BF

breadthfirst(NodInitial,Solutie):- bf([[NodInitial]],Solutie).

bf([[Nod|Drum]|_],[Nod|Drum]):- scop(Nod).

bf([Drum|Drumuri],Solutie):- extind(Drum,DrumNoi),

conc(Drumuri,DrumNoi,Drumuri1),

bf(Drumuri1,Solutie).

extind([Nod|Drum],DrumNoi):- bagof([NodNou,Nod|Drum],

(s(Nod,NodNou),not(membru(NodNou,[Nod|Drum]))),DrumNoi),!.

extind(_,[]).
%---------------------------------------------------------------------

% Appel generare solutie si afisaj

problema:- tell('D:\\blocuri.txt'),

initial(S),

breadthfirst(S,Solutie),

afisare(Solutie),

told.

%---------------------------------------------------------------------

% Lucram la afisarea in fisier

% N este lungimea lui L=[_|T]

lung([],0).

lung([_|T],N):- lung(T,N1),N is N1+1.

max(A,B,B):- B >= A,!.

max(A,_,A).

% Determinam cea mai mare lungime a unei liste (stiva) din L

max_lung([],0).

max_lung([H|T],N):- max_lung(T,N1),lung(H,N2),max(N1,N2,N).

% Afisam configuratiile

arata(L):- nl,max_lung(L,N),afis(L,N,N).

% Det cea mai mare lungime a unei stive din L si afisam nivel cu nivel
% incepand de la ultimul, blocurile din listele (locurile de
depozitare) din L

afis(L1,_,0):- af(L1).

afis(L1,N,K):- K>0,afis2(L1,N,K),nl,K1 is K-1,afis(L1,N,K1).

af([]):- write(==).

af([_|T]):- write(===),af(T).

afis2([],_,_).

afis2([H|T],N,K):- lung(H,L),

(L>=K,L1 is L-K+1,det_el_n(H,L1,R),write(R);

L<K,tab(1)),

tab(2),afis2(T,N,K).

det_el_n([H|_],1,H).

det_el_n([_|T],K,H):- K>1,K1 is K-1,det_el_n(T,K1,H).

sterg_el(X,[X|L],L).

sterg_el(X,[Y|L],[Y|L1]):- sterg_el(X,L,L1).

permutare([],[]).

permutare([H|T],L):- permutare(T,T1),sterg_el(H,L,T1).

membru(X,[X|_]).

membru(X,[_|L]):- membru(X,L).

conc([H|T],L,[H|T1]):- conc(T,L,T1).
conc([],L,L).

afisare([]).

afisare([H|T]):- afisare(T),arata(H),nl.