C_13 / Metoda Greedy. 3. Metoda Back Tracking 4. Metoda Programării Dinamice. 6. Metode. Euristice 1/35/35

Transcription

1 C_13 / Metode de elaborare a algoritmilor 1. Metoda Greedy 2. Metoda Divide et Impera 3. Metoda Back Tracking 4. Metoda Programării Dinamice 5. Metoda Branch and Bound - doar teoretic! 6. Metode Euristice 7. Algoritmi Genetici - nu se cer! 1

2 11.5. Metoda Branch_and_Bound (nu se cere la proba practica) Metoda Branch_and_Bound (ramifică şimărgineşte) se aseamănă cu metoda Back_Tracking, însă diferă în primul rând prin ordinea de parcurgere a spaţiului soluţiilor posibile (a spaţiului stărilor). Am văzut că la metoda Back_Tracking mulţimile ce compun spaţiul stărilor posibile trebuie să fie finite şi de asemenea componentele vectorului X căutat iau valori fără nici o prioritate (preferinţă). La metoda Branch_and_Bound, spaţiul stărilor este parcurs într-un mod mai inteligent, algoritmul fiind capabil să simtă soluţia, să se îndrepte spre aceasta, şi în plus metoda Branch_and_Bound nu poate conduce la un ciclu infinit, dacă problema are soluţie, chiar dacă spaţiul stărilor este infinit. În continuare vom încerca să descriem această metodă, apoi algoritmul general de rezolvare a unei probleme prin aceasta. 2

3 Metoda Branch_and_Bound Fie S={s 1,s 2,...,s n } o mulţime de stări posibile, care conţine o stare iniţială s p cunoscută (precizată) şi o stare finală s f cunoscută (dată) sau care poate fi recunoscută (admisă ca stare finală) după anumite cerinţe (condiţii sau caracteristici precizate în problemă). Pot exista mai multe stări finale F S. Dintr-o stare si se poate trece (ramifica) în mai multe stări s i1,s i2,...s ij, printr-o transformare (dată de problema concretă pe care o avem de rezolvat) de forma : T : S P(S), T(s i )={s i1,s i2,...s ij }, pentru i=1,2,,n. Se cere să determinăm o succesiune de stări începând cu starea iniţială s p până la starea finală s f aplicând succesiv transformarea T. Aceasta înseamnă că va trebui să determinăm şirul stărilor de forma s k1,s k2,...s km, pentru care: s k1 =s p, s k2 =T(s k1 ),, s ki =T(s ki-1 ),, s km =T(s km-1 )=s f F. Pentru că în general putem avea mai multe soluţii (chiar o infinitate), se poate cere să determinăm cea mai scurtă secvenţă rezultat, adică cea pentru care m este minim. 3

4 Metoda Branch_and_Bound Pentru a ajunge la starea finală vom utiliza o mulţime de stări active (posibile pentru continuare spre starea finală) din care vom alege acea stare care este cât mai aproape de starea iniţială şi de starea finală (distanţa de la starea iniţială + distanţa până la starea finală este minimă). Distanţa faţă de starea iniţială se poate uşor măsura (determina) fiind numărul de transformări aplicate stării iniţiale pentru a obţine acea stare: d 1 : S N, d 1 (s) = k dacă s T k (s p ). Distanţa de la o stare s i la starea finală s f, în general este greu de calculat, de cele mai multe ori nu se poate determina doar după ce am rezolvat problema în sine. Din această cauză va trebui să căutăm o aproximantă a acesteia, care poate fi uşor calculată pentru problema concretă dată. Această distanţă va fi de forma : d 2 : S R +, iar d 2 (s f )=0. Criteriul de alegere din mulţimea stărilor active constă în determinarea acelei stări care realizează minimul sumei distanţelor d 1 şid 2. Aceasta înseamnă că dacă la un moment dat, mulţimea stărilor active este S a ={s a1,...,s al }, atunci se alege starea s aj, pentru care : d 1 (s aj )+d 2 (s aj ) = min { d 1 (s ai )+d 2 (s ai ) / s ai Sa }. 4

5 Metoda Branch_and_Bound Strategia Branch_and_Bound este următoarea : iniţial S a ={s p }, iar pentru o mulţime de stări active obţinută la un moment dat se alege o stare curentă sc (o stare de continuare, aşa cum am arătat mai sus) iar în locul ei se depune în mulţimea stărilor active acele stări care se ramifică din ea ( S a :=S a \ {s c } T(s c ) ). Dacă printr-o astfel de transformare (ramificare) am ajuns la o stare finală s f F problema este rezolvată. Pentru ca într-o problemă să putem aplica metoda Branch_and_Bound, va trebui să ne asigurăm că problema are soluţie, altfel strategia prezentată poate conduce la un ciclu infinit. Cele două distanţe (d 1 şid 2 ) nu ne vor permite să ne îndepărtăm preamultde starea iniţială (d 1 ) şi de asemenea dacă d 2 este mărginită ( k N : d 2 (s) k, s S), atunci metoda nu admite o abatere de la calea corectă (spre soluţie) decât cu cel mult k paşi(mărginirea posibilităţilor). Pentru a putea reconstitui drumul parcurs de la starea iniţială la starea finală vom reţine pentru fiecare stare care rezultată dintr-o ramificaţie starea care se transformă. Dacă T(s)={s 1,s 2,...,s t }, atunci Pred(s i ):=s, pentru fiecare i=1,2,,t sau mai simplu, ceeea ce este suficient pentru a reconstitui calea inversă. 5

6 Metoda Branch_and_Bound Algoritmul general de tip Branch_and_Bound este următorul: Algoritmul Branch_and_Bound Este : Date sp,f; { Citeşte starea iniţială ială şi starile finale } Sa:={sp}; { starea iniţială ială sp este prima stare activă } Repetă sc:=aleg(sa Aleg(Sa); { starea curentă realizează min d1+dd +d2 } Dacă sc F Atunci { starea curentă este stare finală?} Sa:=Sa\{sc}; { starea eleasă devie pasivă } St:=T(sc T(sc); { ramifică starea curentă (caută noi stări) ) } Pentru s St Execută s.pred:=sc ; { reţine calea de întoarcere } Sa:=Sa St Până_Când Sa= sau sc F; Dacă sc F Atunci sk:=sc; Tipăreşte sk; { parcurge calea inversă } Repetă sk:= :=Pred(sk); Tipăreşte sk {de la starea fianlă la starea iniţială ială} Până_Când sk=sp Altfel Tipăreşte "Problema nu are soluţie ie" Sf_Algoritm. { Nu există soluţie sau am găsit o stare finală } 6

7 Metoda Branch_and_Bound Pentru rezolvarea unei probleme de tip Branch_and_Bound, vom utiliza o listă înlănţuită ordonată crescător după suma distanţelor d 1 şid 2 care va conţine toate toate stările generate (plecând de la starea iniţială), atât cele active (care urmează să fie alese) cât şi cele pasive (care au fost deja alese, păstrate pentru a da rezultatul), diferenţierea acestora fâcându-se prin câmpul numit Tip {Activă, Pasivă}. În acest mod, alegerea se va efectua simplu, deoarece starea aleasă va fi prima stare activă din listă. Adăugarea în listă se va efectua în aşa fel încât lista să rămână ordonată. Elementele listei vor conţine pe lângă câmpul ce caracterizează o stare s S (configuraţia) şi cheia de ordonare egală cu d 1 (s)+d 2 (s). De asemenea, pentru a determina cât mai rapid distanţa d1 a unei stări faţă de starea iniţială, se va reţine şi această distanţă pentru fiecare stare (element al listei), deci d 1 (s):=d 1 (Sc)+1. Pentru a putea reconstitui calea parcursă de la starea iniţială până la starea finală, vom reţine şi adresa stării din care s-a produs transformarea stării curente (Pred). Elementele listei înlânţuite (prin Leg) vor avea structura următoare: Cheie d1+d2 Configuraţia ia Informaţiile stării d1 Pred Dacă o stare activă este aleasă ca stare curentă, ea devine pasivă pentru a nu va mai fi aleasă. Mai precizăm că este de preferat ca o stare nouă să nu o adăugăm în listă dacă ea are acceaşi configuraţie cu o altă stare deja existentă (activă sau pasivă). Tip Adr. urm.. Element Leg. 7

8 Exemple: Metoda Branch_and_Bound a) Problema Canibalilor Pe malul unui râu se află 2n băştinaşi dintrecare n sunt canibali. Aceştia doresc să traverseze un râu utilizând o barcă, care poate transporta cel mult k oameni şi nu poate circula singură. Dacă peun mal sauînbarcă vor fi mai mulţi canibali, atunci aceştia îi vor mânca pe ceilalţi. Cum reuşesc să treacă toţi pe malul opus? Configuraţia ia unei stări este (c,b,p), unde c şi b reprezintă numărul canibalilor respectiv al băştinaşilor necanibali (de pe primul mal), iar p este poziţia bărcii (malul pe care se află). Configuraţia iniţială este (n,n,1) iar cea finală este (0,0,2). La p se poate renunţa deoarece p = d 1 Mod 2 + 1! Distanţa d 1 (a unei stări faţă de starea iniţială) reprezintă numărul de traversări cu barca. Distanţa d 2 (a unei stări faţă de soluţie) este: d 2 (c,b)=c+b, reprezentând numărul de persoane care mai trebuie transportate (care nu sunt la locul lor!). Se observă că d 2 (sf)=0. Transformarea T (a unei stări sc=(c,b,d 1 )) este corectă prin transportul (i,j) {0,,n} 2 pentru care ((i+j) {1,,k}) şi ((i j) sau (j=0)), dacă (c'=c i,b'=b j) {0,,n} 2 şi((c' b') sau (b'=0)) şi ((c' b') sau (b'= n)). 8

9 Metoda Branch_and_Bound Programul Pascal este următorul: Program Brach_and_Bound; Type TipSt =(Activa,Pasiva Activa,Pasiva); Adr=^Elem; Config = Record c,b :Byte Stare = Record d1_2:byte; Conf:Config; ; d1:byte; Pred:Adr; Tip:TipSt Elem = Record Inf : Stare; Leg:Adr Procedure Inits(var s:stare; ; d1_plus_d2,can,bas,d_1:byte; Adr_Pred:Adr; t:tipst); Begin With s,conf Do Begin d1_2:=d1_plus_d2; c:=can; b:=bas; d1:=d_1; Pred:= :=Adr_pred;; Tip:=t End Procedure Ado(Var Sa:Adr; s:stare); Var Nou:Adr; Begin With Sa^,Inf Do If (Sa<>Nil) And (d1_2<s.d1_2) Then Ado(Leg,s) ) Else Begin New(Nou); With Nou^ ^ Do Begin Nou^.Inf:=s; Nou^.Leg:=Sa; Sa:=Nou End End Function Aleg(Sa:Adr):Pointer; Begin If Sa^.Inf.Tip=Activa Then Aleg:=Sa Else Aleg:= :=Aleg(Sa^.Leg)) Function Finala(s:Adr):Boolean; ; Begin With s^.inf.conf Do Finala:= :=c+b=0 Function Vida (S:Adr):Boolean( S:Adr):Boolean; ; Begin With s^,inf Do Vida:=(S=Nil) Or ((Tip=Pasiva Pasiva) ) And Vida(Leg)) 9

10 Metoda Branch_and_Bound Procedure Transf(sc:Adr; k,n:byte; Var Sa:Adr); Function Corect(c,b,n:Integer):Boolean; Begin Corect:=(c In [0..n]) And (b In [0..n]) And ((c<=b) Or (b=0)) And ((c>=b) Or (b=n)) Function Exista(x,y,d_1:Integer; Sa:Adr):Boolean; Begin With Sa^,Inf,Conf Do Exista:=(Sa<> :=(Sa<>Nil)And(((x=c)And(y=b)And(Odd(d1)=Odd(d_1))) Or Exista(x,y,d_1,Leg)) Var i,j,x,y:integer; s:stare; Begin For i:=0 To n Do For j:=0 To n Do If ((i+j i+j) ) In [1..k]) And ((i<=j)or(j j)or(j=0)) Then With sc^,inf,conf Do Begin If Odd(d1) Then Begin x:=c+i c+i; ; y:=b+j End Else Begin x:=c-i; ; y:=b-j If Corect(x,y,n) ) And (Not Exista(x,y,d1+1,Sa)) Then Begin Inits(s,d1+1+x+y,x,y,d1+1,sc,Activa); Ado(Sa,s) ) End End 10

11 Metoda Branch_and_Bound Procedure Tipar(sc:Adr;n:Byte); Begin If sc<>nil Then With sc^, Inf,, Conf Do Begin Writeln( ( c:3, b:3,chr(32-((d1+1) ((d1+1) Mod 2)*14):3); Writeln(' ('~~~~~~~~~~~');'); Writeln(n-c:3,n c:3,n-b:3,chr(32-(d1 (d1 Mod 2)*14):3,#10); Readln; Tipar(Pred,n) Var Sa,sc:Adr; n,k:byte; sp:stare; Begin Write(' Canibali/necanibali, nr.locuri in barca : '); Readln(n,k); Inits(sp,, n+n,n,n,0,nil,activa); Sa:=Nil; Ado(Sa,sp); Repeat sc:=aleg(sa Aleg(Sa); sc^.inf.tip:= :=Pasiva; If Not Finala(sc) ) Then Begin With sc^, Inf,, Conf Do Tip:=Pasiva Pasiva; Transf(sc,k,n,Sa) ) End Until Vida(Sa) ) Or Finala(sc); If Finala(sc) ) Then Tipar(sc,n) Else Writeln(' Problema nu are soluţie ie'); Readln End. 11

12 Metoda Branch_and_Bound b) Problema Ţăranului Pemalulaltuirâuse află un ţăran cu un lup, o capră, o varză şio barcă. Cum reuşeşte ţăranul să transporte cu barca cele trei cadouri ştiind că nu poate pune în barcă decât unul sigur iar capra nesupravegheată poate fi atacată de lup sau poate să mănânce varza? Configuraţia unei stări este (l,c,v,ţ), unde l,c şi v malul pe care se află, iar ţ este (malul pe care se află ţăranul şi barca). Configuraţia iniţială este (1,1,1,1) iar cea finală este (2,2,2,2). La ţ se poate renunţa deoarece ţ = d 1 Mod 2 + 1! Distanţa d 1 reprezintă numărul de traversări cu barca. Distanţa d 2 este: d 2 (l,c,v) = 6-l-c-v, reprezentând numărul de cadouri care mai trebuie transportate (sunt pe primul mal). Observăm că d 2 (s f )=0. Transformarea unei stări s c =(l,c,v,d 1 ) este corectă prin transportul unui cadou dacă acela se află pe malul curent iar capra este supravegheată sau rămâne singură. 12

13 Metoda Branch_and_Bound c) Perspico Fiind dată o configuraţie a tablei de perspico, se cere să se aşeze piesele într-o poziţie indicată! Configuraţia unei stări este matricea de 4x4 cu numere de la 0 la 15 (0=spaţiu). Distanţa d 1 reprezintă numărul de mutări efectuate. Distanţa d 2 = numărul de piese care nu sunt la locul lor. Transformarea unei stări în alte 4 stări (cel mult) se poate face prin ocuparea spaţiului liber (0) de către o piesă vecină (având 2, 3 sau 4 posibilităţi) ?

14 Teme: 1. Să se rezolve problema corespunzătoare jocului alăturat (configuraţia iniţială fiind cea din partea stângă iar cea finală cea din dreapta), prin mutări similare jocului anterior (perspico). Piesa mare trebuie adusă jos prin translaţiile pieselor. 2. Fiind date două cercuri cu câte n bile (din care cele două din intersecţie sunt comune), se cere să se aducă bilele albastre pe cercul albastru, prin operaţii de rotire (vezi figura de mai jos pentru n=10) a celor două cercuri. 3. Cum trec două şiruri de câte n capre un pod fără să se ocolească, dacă vin din direcţii opuse şi nu se poate sări decât peste o capră adversă? _ 14

15 11.6. Metode Euristice În situaţiile în care pentru anumite probleme complexe, pentru a căror rezolvare nu se cunosc algoritmi, sau aceştia sunt ineficienţi (timp, memorie, cost), se preferă utilizarea unor algoritmi care rezolvă problema dată mult mai rapid, cu efort mic, însă nu ne va furniza întotdeauna cea mai bună soluţie, ci doar soluţii acceptabile, adică soluţii corecte care pot fi eventual îmbunătăţite. Prin algoritm euristic vom înţelege un algoritm care furnizează soluţii bune, nu neapărat optime, care poate fi implementat rapid şi furnizează rezultate în timp util. O idee frecvent utilizată constă în descompunerea procesului de determinare a soluţiei în mai multe etape succesive pentru care se poate determina optimul local. 15

16 Metode Euristice Optimul global nu poate fi obţinut întotdeauna prin determinări succesive de optimului local, deci nu se poate aplica metoda Greedy, doar o startegie de acest tip. În practică se găsesc de multe ori soluţii aproximative, mai ales dacă algoritmul se foloseşte de puţine ori şi efortul de determinare al soluţiei optime este mai mare decât beneficiul obţinut. O metodă euristică poate să împartă rezolvarea în mai multe etape, se determină optimul din fiecare etapă (până în acel moment) urmărind prin aceasta ca rezultatul final să fie cât mai bun. Dacă este posibil să determinăm rapid mai multe astfel de soluţii, atunci rezultatul dat va fi cel mai bun dintre acestea. La scrierea unui algoritm euristic vom aplica doar condiţiile simple dar necesare pentru o soluţie corectă, care eventual va mai fi îmbunătăţită. 16

17 Exemple: Metode Euristice a) Problema Comis-Voiajorului Fiind date n localităţi şi distanţele dintre ele se cere să se determine traseul de lungime minimă pe care îl parcurge comis-voiajorul pentru a vizita o singură dată fiecare localitate, iar apoi să se reîntoarcă în localitatea de unde a plecat. Strategia: se alege întotdeauna cea mai apropiată localitate (dintre cele nevizitate). Imbunătăţire: deoarece un traseu este un circuit închis, putem considera ca punct de plecare oricare dintre localităţi (traseul optim nu depinde de localitatea de start). Pentru fiecare localitate considerată ca localitate de plecare, se determină traseul preferat, apoi dintre aceste k trasee corecte se determină traseul cel mai bun (de lungime minimă) dat ca rezultat final (care nu este neapărat traseul optim). Evident că traseul final va fi refăcut astfel încât să aibă ca localitate de start localitatea de domiciliu a comis voiajorului (în exemplul dat am considerat toate cele n variante, deci k=n). 17

18 Metode Euristice Programul Pascal este următorul: Program Metode_Euristice_Comis_Voiajor; Const Dm = 10; Type Dist = Array[1..Dm,1..Dm] Of Word; Drum = Array[1..Dm] Of Byte; Mult = Set Of Byte; Procedure Date(Var n,s:byte; Var d:dist); var i,j:byte; Pas:Text; Rand:String; Begin Assign(Pas,'Me_Com-V.Pas V.Pas'); Reset(Pas); Repeat Readln(Pas,Rand) ) Until Rand='End.'; Read(Pas,n,s); For i:=1 To n Do Begin For j:=1 To i-1 i 1 Do Begin Read(Pas,d[i,j]); d[j,i]:= ]:=d[i,j]] Readln(Pas,Rand) Writeln('d:'); For i:=1 To n Do Begin For j:=1 To n Do Write(d[i,j]:3); Writeln; ; Close(Pas); Writeln(#10) 18

19 Metode Euristice Procedure Ad_T(s:Byte; Var T:Drum; Var i:byte); Begin Inc(i); T[i]:=s Function Aleg(Var NeviZ:Mult; d:dist; n:byte; Var k:byte):byte; Var s,o:byte; Begin s:=k; k:=0; Repeat Inc(k) ) Until k In NeViz; For o:=k+1 To n Do If (o In NeViz) ) And (d[s,o( d[s,o]< ]<d[s,k]) Then k:=o; Aleg:=k; NeViz:= :=NeViz-[k] Procedure Traseu(n,s:Byte; d:dist; Var T:Drum); Var i,k,j:byte; Neviz:Mult; Begin i:=0; k:=s; Ad_T(k,T,i); NeViz:=[1..n] :=[1..n]-[k];[k]; For j:=2 To n Do Ad_T(Aleg(NeViz,d,n,k),T,i); ); Ad_T(s,T,i) 19

20 Metode Euristice Function Dr_Min(T:Drum; d:dist; n:byte):word; Var i:byte; Lung_Dr:Word; Begin Lung_Dr:=0; For i:=1 To n Do Inc(Lung_Dr,d[T[i],T[i+1]]); Dr_Min:= :=Lung_Dr Procedure Tip_Tr(T:Drum; d:dist; n,s:byte); Var i,k:byte; M:Drum; Begin i:=0; Repeat Inc(i) ) Until T[i]=s; M[n+1]:=s; k:=0; Repeat Inc(k); M[k]:= ]:=T[i]; Inc(i); If i>n Then i:=1 Until k=n; For i:=1 To n Do Writeln(M[i]:3,' ',d[m[i],m[i+1]],'-->',m[i+1]); Var n,s,i:byte; d:dist; Tm,T:Drum; Lm,Ld:Word; Begin Date (n,s,d( n,s,d); Traseu(n,1,d,Tm); Lm:=Dr_Min(Tm,d,n Dr_Min(Tm,d,n); For i:=2 To n Do Begin Traseu(n,i,d,T ); Ld:=Dr_Min(T,d,n); If Ld<Lm Then Begin Tm:=T; Lm:=Ld End Writeln('Dr.. Min. '); Tip_Tr(Tm,d,n,s); Writeln('Lg.:',Lm:3); Readln End. 20

21 Metode Euristice N S D Date Rezultate Dr. Min > > > > > >3 Lg.: 24 21

22 Metode Euristice a) Problema Execuţiei Lucrărilor de către mai multe Procesoare Cum sunt repartizate m lucrări la n procesoare astfel încât execuţia lor să se termine cât mai repede. Mai precizăm că procesoarele pot lucra simultan şi orice procesor poate executa orice lucrare, iar o lucrare nu va fi executată de către mai multe procesoare. Timpul de execuţie al lucrării i este ti ( i = 1,2,,m). Strategia: se alege lucrarea neexecutată de durată maximă (se ordonează lucrările descrescător după timpul de execuţie) care va fi repartizată primului procesor liber. Practic se va determina o ordine O de execuţie a celor m lucrări (oi reprezintă a câta lucrare se execută a i-a, adică este pe locul i în coada de aşteptare). Imbunătăţire: deoarece strategia nu garantează optimul (de exemplu pentru timpii 3,3,2,2,2 rezultatul dat va fi 7 ore la o prelucrare cu două procesoare, însă optimul este 6) vom încerca diverse perturbării ale acestei ordini propuse, iar dintre variantele obţinute o vom reţine pe cea mai convenabilă (în speranţa că va fi chiar cea optimă). 22

23 Metode Euristice Programul Pascal este următorul: Program Metode_Euristice_Procesoare; Const Dm = 100; Type Timpi = Array[1..Dm] Of Word; Coada = Array[1..Dm] Of Byte; Procedure Date(Var n,m:byte; Var T:Timpi); Var i,j:byte; Pas:Text; Rand:String; Begin Assign(Pas,'Me_Rep_L.Pas'); '); Reset(Pas); Repeat Readln(Pas,Rand) Until Rand='End.'; Readln(Pas,n); Read(Pas,m); For i:=1 To m Do Read(Pas,t[i]); Close(Pas) 23

24 Metode Euristice Procedure Ordine(T:Timpi; Var O:Coada; m:byte); var i,k:byte; Ordonat:Boolean; Aj:Word; Begin k:=1; For i:=1 To m Do o[i]:=i; Repeat Ordonat:=True; For i:=1 To m-k Do If t[o[i]]<t[o[i+1]] Then Begin Inc(k); Aj:= :=o[i]; o[i]:=o[i+1]; o[i+1]:=aj Aj; Ordonat:=False Until Ordonat Function Liber(P:Timpi; n:byte):byte; Var Begin k:=1; For j:=2 To n Do If p[j]< ]<p[k]] Then k:=j; Liber:=k k,j:byte; { Minim } 24

25 Var Begin n,m,i,j:byte; T,P:Timpi; O:Coada; TMax:Word; Date (n,m,t( n,m,t); For i:=1 To m Do Write(t[o[i]]:3); Writeln; Ordine(T,O,m); For i:=1 To m Do Write(t[o[i]]:3); Writeln; For j:=1 To n Do p[i]:=0; For i:=1 To m Do Begin j:=liber(p,n Liber(P,n); Inc(p[j],t[o[i]]); ]]); For j:=1 To n Do Write(p[j]:3); Writeln TMax:=p[1]; For j:=2 To n Do If p[j]> ]>TMax Then TMax:= :=p[j]; Writeln(' Timpul nesar este ',TMax TMax); Readln End. Date 3 n Procesoare Rezultate m Lucrari:t1,t2...tm Metode Euristice Timpul nesar este 9 25

26 Teme: Ca temă poate fi orice problemă de tip Greedy la care nu am demonstrat obţinerea optimului global! 26

27 11.7. Algoritmi Genetici (nu se cer la ex.) Aceşti algoritmi rezolvă probleme de optimizare după modelul selecţiei naturale, conform căreia populaţia evoluează prin supravieţuirea celui mai performant. Algorimii genetici nu garantează optimul, dar furnizează soluţii bune. O populaţie este formată din indivizi (fiecare reprezentând o soluţie potenţială) care evoluează (prin selecţie, (re)combinare şi mutaţie) spre optim. Un individ este caracterizat prin unul sau mai mulţi cromozomi (formând genotipul) Un cromozom conţine caracteristicile individului (poartă informaţia genetică) într-un numărfix de gene. Un algoritm genetic este caracterizat prin codificarea spaţiului de căutare, funcţia de evaluare (pentru selecţie ie) în vederea reproducerii (recombinare) şi hazard în evoluţie (mutaţie). 27

28 Algoritmi Genetici Calitatea unui individ se măsoară cu funcţia de performanţă (de adecvare sau de evaluare): f : X R, unde X este spaţiul de căutare. Operatorii utilizaţi sunt următorii: Recombinare r : X p X q, Mutaţie m : X p X q, Supravieţiure s : X p B. Algoritmul Ag_Simplu este: Date Nr_Gen, Dim_Pop; { Nr. Max. de generaţii, Dim. Populaţiei } Init(P,Dim_Pop); t:=0; { Populaţia iniţială, la momentul t=0 } Repetă t:=t+1; Selectează(P, Pi,Pj); { Selectez doi indivizi : i,j pt. reproducere} Combin (Pi,Pj,Desc); { Prin recombinare un descendent } Mutatie(Desc); { care suferă o mutaţie } Pk:=CelMaiSlab(P); { Determină cel mai slab individ } P:=P\{Pk} {Desc}; { care se înlocuieşte cu noul individ } Pe:=CelMaiBun(P); { Determină cel mai bun individ } Până_Când (f(pe)=max) sau (t>nr_gen); { S-a găsit optimul sau o aproxim. } Rezultate Pe { Soluţia sau o aproximantă a acesteia } Sf_Ag. 28

29 Exemplu: Algoritmi Genetici a) Problema determinării unei submulţimi de sumă dată. Fiind dată o mulţime de numere reale pozitive şi un număr T, se cere să se determine o submulţime de sumă T. Cromozomul este codificat printr-un şir de n gene {0,1} (1=se însumează, 0=nu). Combinarea este realizată luând aleator câte o genă din cei doi cromozomi părinte. Mutaţia este realizată schimbând eventual (aleator) câte o genă. Performanţa se măsoară în funcţie de distanţa sumeipână la totalul dorit T (Fit). 29

30 Algoritmi Genetici Programul Pascal este următorul: Program Submulţime_de_suma_Da ime_de_suma_dată; Uses Crt,Graph; Const n=15; T:Integer=250; Nr_Gen=500; A:Array[1..n] Of Word = (1,2,3,5,10,15,20,25,50,75,80,100,125,150,200); 0,125,150,200); Type Gena=0..1; Cromozom=Array[1..n] Of Gena; Var m,i,j,k,e:byte; P:Array[Byte] ] Of Cromozom; Desc:Cromozom; Pas:Integer; Procedure Combin(x,y:Cromozom; Var z:cromozom); Var j:byte; Begin For j:=1 To n Do If Random(2)=0 Then z[j]:= ]:=x[j] Else z[j]:= ]:=y[j] Procedure Mutatie(Var x:cromozom); Var j:byte; Begin For j:=1 To n Do If Random(100)<2 Then x[j]:=1 ]:=1-x[j] 30

31 Algoritmi Genetici Function Fit(i:Byte):Word; Var j:byte; s:word; Begin s:=0; For j:=1 To n Do s:=s+p[i][j s+p[i][j]* ]*a[j]; Fit:=Abs(s Abs(s-T) Function CelMaiSlab:Byte; Var i,k:byte; Begin k:=1; For i:=2 To m Do If Fit(i)> )>Fit(k)) Then k:=i; CelMaiSlab:=k Function CelMaiBun:Byte; Var i,k:byte; Begin k:=1; For i:=2 To m Do If Fit(i)< )<Fit(k)) Then k:=i; CelMaiBun:=k 31

32 Algoritmi Genetici Var Gd,Gm:Integer; ss:string; Function Des_Cromo(i:Integer):Word; Var j:byte; s:integer; Begin s:=0; For j:=1 To n Do s:=s+p[i][j s+p[i][j]* ]*a[j]; MoveTo(6*i,(T i,(t-s) ) Div 1 + GetMaxY Div 2-5); LineRel(-3,+5); LineRel(+3,+5); LineRel(+3,-5); LineRel(-3, 3,-5); Procedure Populatie; Var i:byte; Begin Line(1,GetMaxY Div 2,GetMaxX-1,GetMaxY Div 2); For i:=1 To m Do Des_Cromo(i); 32

33 Algoritmi Genetici Begin Write(' Dati m < 256 : '); Readln(m); Randomize; InitGraph(Gd,Gm,'c:\Bp\Bgi'); SetWriteMode(1); SetBkColor(Blue); For i:=1 To m Do For j:=1 To n Do P[i][j]:=Random(2); ]:=Random(2); Pas:=0; SetColor(White); Populatie; OutTextxy(400,GetMaxY-60,'Initial... Press a Key...'); ReadKey; OutTextxy(400,GetMaxY-40,'To Stop... press Esc key '); Repeat Pas:=Pas+1; i:=random(m)+1; j:=random(m)+1; While (i=j) Do j:=random(m)+1; Combin (P[i],P[j],Desc); Mutatie(Desc); k:=celmaislab CelMaiSlab; Des_Cromo(k); SetColor(Green); Line(1,GetMaxY Div 2,Pas,GetMaxY Div 2); Delay(50); Line(1,GetMaxY Div 2,Pas,GetMaxY Div 2); SetColor(White); P[k]:= ]:=Desc; Des_Cromo(k); Delay(25); e:=celmaibun CelMaiBun; Until (Fit(e( Fit(e)=0) Or (Pas>Nr_Gen Nr_Gen) Or (KeyPressed And (ReadKey=#$1B)); { Nr. ind.. } { Init(P); } {Populatie;} 33

34 Algoritmi Genetici SetWriteMode(0); SetColor(Yellow); Des_Cromo(e); Str(Fit(e),ss); OutTextxy(30,GetMaxY-60,'Err.:'+ss+' '); Str(Pas,ss); OutTextxy(230,GetMaxY-60,'Gen. :'+ss+'!'); MoveTo (30,GetMaxY-40); Str(T,ss); OutText(ss+' = '); For j:=1 To n Do If P[e][j]=1 ]=1 Then Begin Str(a[j],ss); OutText('+'+ss) OutTextxy(400,GetMaxY-20,'To Exit... Press a Key...'); ReadKey; CloseGraph End. 34

35 Teme: Ca temă poate fi orice problemă de tip Euristic!... C_13 /