Embed Size (px)
Citation preview
u~enik:Nikola Doj~inovi} II8
Tehnika programirawaTehnika programirawaBACKTRACKBACKTRACK
Profesor Predrag Stanimirovi}
NikolaDoj~inovi} II8
Tema: Tehnika programirawaTehnika programirawaBACKTRACKBACKTRACK
UVOD
Programirawe se kroz istoriju, kao nauka razvila do granica savr{enstva i postala je neophodni ~inilac za obavqawe svakodnevnih aktivnosti, jer probleme re{ava uz mnogo mawe zalagawa i za vrlo kra}e vreme. Razvijaju}i se, informatika je dostigla granicu transcedentnosti, te je ~ak po~ela i da li~i na umetnost. Kao i u drugim umetnostima, i u programirawu postoje pravci i na~ini savla|ivawa problema i emocijalne ekspresije. Kao plod svih ovih okolnosti i jo{ mnogih drugih pogodnosti koje pru`a, pojavila se tehnika programirawa koja se zove BEKTREK ( BACKTRACK ).
Kroz vreme, svojom prakti~no{}u i primenqivo{}u bektrek je doprineo da izraste u jednu od standardnih programerskih tehnika za re{avawe ogromnog broja problema. Za bektrek se tako|e mo`e re}i da je izuzetno zanimqiv za izu~avawe, kako sa prkti~ne, isto tako i sa logi~ke ta~ke gledi{ta.
KARAKTERISTIKE
2
Su{tina bektreka, kao na~ina programirawa, je veoma zanimqiva i wene tajne se mogu nazresti iz samog naziva bektrek (back-pozadi; track-staza). No ipak, naziv bektrek ne mo`emo prevesti bukvalno, te se on kod nas naj~e{}e prevodi kao pretraga sa vra}awem. Sam postupak programirawa se vr{i dosta postupno, korak po korak. Za odre|ivawe slede}eg koraka u ciqu dolazka do delimi~no krajweg i krajweg re{ewa na raspolagawu za taj korak imamo vi{e mogu}nosti, za koje mi unapred ne mo`emo znati koja vode do re{ewa, a koja su samo utopijski pravci koji ne vode do krajweg re{ewa. Za slede}i korak u odre|ivawu re{ewa uzima se jedna od preostalih mogu}nosti i u odnosu na wu se re{ewe odre|uje od kraja. Ukoliko ne postoji slede}i korak koji zadovoqava zadate uslove, vra}a se korak unazad (back) i kao slede}i korak uzimaju neka druga solucija. Kraj programa je situacija kada su sve mogu}e putawe isprobane i ne postoji vi{e ni jedno re{ewe koje mo`e zadovoqiti uslove zadatka. Samo re{ewe problema bektrekom predstavqa, na neki ka~in, jednu putawu (track) koja se sastoji od niza adresa poqa koja pokazuju jadna na drugu.
S obzirom na to da se re{ewe mo`e formulisati kao putawa, tehnika bektreka mo`e na}i prakti~nu primenu pri re{avawu problema kretawa i polo`aja, te se kao takva ova tehnika mo`e koristiti za re{avawe prostijih {ahovskih problema. Nave{}u jedan {ahovski problem koji predstavqa tipi~an i jedan od prostijih primera za re{avawe problema uz pomo} bektreka.
PRIMER 1: Na {ahovsku tablu dimenzija n*n rasporediti n kraqica, tako da se me|usobno ne napadaju.
RE[EWE 1: program kraljice_primer1;uses crt;var i,q,r,brojac,n:integer; a:array[1..100] of integer; moza:bollean;procedure pisi(var n:integer); { komentar 1.1 }begin
3
clrscr; for q:=1 to n do begin for r:=1 to n do
if a[q]=r then write(‘ K‘); else write(‘ O’);writeln;
end; inc(brojac);writeln(‘Resenje broj’, brojac); readln;end; procedure (d,n:integer); { komentar 1.2 }var j,w:intger;begin if i>n then pisi(n)
else for j:=1 to n do
begin moze:=true;
for w:=1 to i-1 do if(j=a[w]) or (w+j=i+a[w]) or (w+a[w]=i+j) then
moze:=false; if moze then begin
a[i]:=j; d(i+1,n);
end; end;end;begin { za program } write(‘Unesite dimenzije sahovske table n*n , n= ‘);readln(n); brojac:=0;d(1,n);end.
komentar 1.1 : Procedura pisi je procedure za ispis. U odnosu na klasi~ne procedure za ispis nizova koje se primewuju u praksi, ova procedura za ispis je veoma neobi~na, ali se wena slo`enost i neobi~nost mo`e shvatiti i opravdati komentarom 2 koji opisuje proceduru d koja je
4
ustvari operativna procedura i uslovqava neobi~nu proceduru za ispis.
komentar 1.2 : Procedura d je zapravo telo programa. Iako je logi~no da se za re{ewe ovog problema koriste matrice, jer one verno oslikavaju oblik {ahovske table, za re{avawe ovog problema se koriste jednodimenzionalni nizovi du`ine n. Funkcija d je rekurzivna i kao argumente ima n, {to predstavqa dimenzije matrice, i i {to predstavqa redni broj dame koju treba rasporediti. Ukoliko broj i tj. broj dama, prevazi|e dimenziju matrice onda imamo sve dame raspore|ene, pa se prikazuje kona~no re{ewe i wegov redni broj. U suprotnom slu~aju dama se stavqa na i-tu kolonu na svako od mesta, a mesto mo`e biti bilo koje izme|u 1 i n jer a[i] uzima sve vrednosti od 1 do n. Pri tome se mora voditi ra~una da se ostalih i-1 dama me|usobno ne napada i da ne napadaju postavqenu damu.
Konkretno }emo uzeti u razmatrawe slu~aj kada je dimenzija {ahovske table 8*8, tj. posmatra}emo jednu klasi~nu tablu za {ah. Na toj tabli je potrebno postaviti 8 kraqica koje se pri tome ne smeju ma|usobno napadati. Na prvi pogled, tj. prakti~nim ra{avawem na}i}emo nekoliko re{ewa i u glavi mo`emo okvirno nazreti algoritam za wihovo postavqawe. Kompjuter }e, me|utim izbaciti 92 re{ewa. Prikaza}emo jedno od wih i to ba{ prvo ( sl.1 ): K
KK
KK
5
KK
Kslika 1
Re{ewe broj 92 bi bila slika prvog re{ewa u ogledalu, te ako tablu posmatramo kao telo sa dve ose simetrije onda mo`emo re}i da ima ukupno 92/4=23 re{ewa.
Ovo je samo jedna od mnogobrojnih primena bektreka, ali jedna od naj~e{}ih. Bektrek se mo`e upotrebiti i kao metoda za re{avawe problema sa stringovima. Jedan od takvih problema koji se re{ava bektrekom je i problem zagrada.
PRIMER 2 : Za dat prirodan broj n odrediti stringove du`ine n koji sadr`e samo korektne parove zagrada.
RE[EWE 2 : program zagrade_primer2;var s:string; n:integer;procedure postavi(k:integer); { komentar 2.1 }var l,i:integer;begin l:=length(s); if k>n then begin write(s); for i:=l+1 to 2*n do write(')'); writeln;
6
end else begin for i:=l+1 to 2*k-1 do begin s:=s+'('; postavi(k+1); s[i]:=')'; end; s[0]:=chr(l) { komentar 2.2 } end;end;begin write('Unesite n,n= '); readln(n); n:=n div 2; s:='('; postavi(2); readln;end.
komentar 2.1 : String koji treba formimati mo`e se opisatiN-torkom pozicija otvorenih zagrada{ ((((….(((( } . Neka je X(k) pozicija k-te zagrade. Pri korektnom rasporedu bi trebalo da bude da je X(k)=1. Za vrednosti k ve}e od 1, X(k) mo`e uzeti vrednost od X(k-1) do 2k-1. Broj n nije poznat unapred, te ne mo`emo unapred napraviti n ciklusa umetnutih jedan u drugi. Problem n ciklusa se mo`e re{iti rekurzijom koriste}i proceduru postavi(k), koja postavqa k-tu otvorenu zagradu.
komentar 2.2 : Umesto naredbe s[0]:=chr(L); mo`e se napisati i druga naredba koja izvr{ava istu funkciju, a to je naredba s:=copy(s,1,L).
Kao test primer ovog programa uze}emo neki broj koji nije tako veliki ( zbog prakti~nosti ). Za n=6 na unosu, dobija se slede}i raspored :1. ( ( ( ) ) )2. ( ( ) ( ) )3. ( ( ) ) ( )4. ( ) ( ( ) )5. ( ) ( ) ( )
7
Me|utim, i za broj 7 dobija se isti raspored :1. ( ( ( ) ) )2. ( ( ) ( ) )3. ( ( ) ) ( )4. ( ) ( ( ) )5. ( ) ( ) ( )
Program }e ista re{ewa dati i za 2k i za 2k+1. To je zbog toga {to program ne uzima neparne brojeve u obzir, jer bilo koji broj neparnih zagrada se ne mo`e napisati korektno, ve} program razmatra broj n div 2.
Iz ovog primera se vidi da je bektrek dosta primenqiv u kombinatorici. Vidi se, tako|e da se bektrek veoma lako obra~unava sa generisawem svih elemenata i objekata nekog datog zadatog skupa.
Tako|e sam napomenuo da re{ewe bektrek programa mo`emo smatrati kao niz povezanih adresa koje pokazuju jedna na drugu, te se celo re{ewe problema mo`e smatrati kao jedna putawa. Zbog ove karakteristike bektreka mo`emo primeniti ovu tehniku programirawa pri re{avawu problema kada se kao re{ewe zahteva putawa (track). Jedan od takvih problema je i problem Minotaurovog lavirinta.
PRIMER 3 : U datoteci se nalaze podaci o lavirintu: u prvom redu je 6 brojeva i to su broj vrsta i kolona pravougaonog lavirinta M i N, zatim koordinate ( redni broj vrste i kolone ) polaznog i koordinate ciqnog poqa u lavirintu. U narednih M redova se nalazi po N znakova koji predstavqaju lavirint. Znak ‘ ‘(blanko) predstavqa prolaz, a ‘*’ predstavqa prepreku.
Napisati program koji demonstrira tra`ewe puta u lavirintu.
ANALIZA 3 : Svaki put kada do|emo do raskrsnice, krenemo jednim od slobodnih puteva. Ukoliko dospemo u }orsokak, vra}amo se do predhodne raskrsnice i nalazimo drugi put koji je slobodan. Da bi prepoznali put kojim smo i{li da ne bi vi{e puta i{li istim putem, pri prolazku ga obele`avamo sa ‘*’ i u budu}e ga smatramo neprohodnim. Kada do|emo do ciqa, put do wega pamtimo kroz neku globalnu promenqivu. Ovaj problem predstavqa jo{ jedan od lak{ih i jednostavnijih primera za bektrek.
8
RE[EWE 3 : program lavirint_primer3;{$B-} uses crt;const maxn=79; maxm=24; del=40;var f:text; ls:array[1..24] of string[79]; m,n,sn,sm,kn,km,i,j:integer; { komentar 3.1 } ch:char; found:boolean;procedure trazi(tm,tn:integer);begin delay(del); gotoxy(tn,tm); write('o');ls[tm,tn]:='o'; found:=(tn=kn) and (tm=km); if not found and (tm<m) and (ls[tm+1,tn]=' ') then trazi(tm+1,tn); if not found and (tn<n) and (ls[tm,tn+1]=' ') then trazi(tm,tn+1); if not found and (tm>1) and (ls[tm-1,tn]=' ') then trazi(tm-1,tn); if not found and (tn>1) and (ls[tm,tn-1]=' ') then trazi(tm,tn-1); gotoxy(tn,tm); if found then begin write('O');ls[tm,tn]:='O';end else begin write('.');ls[tm,tn]:='.';end; delay(del);end;begin clrscr; assign(f,'primer3.dat'); reset(f); readln(f,m,n,sm,sn,km,kn); for i:=1 to m do begin
9
for j:=1 to n do begin read(ls[i][j]); { komentar 3.2 } if ls[i][j]='*' then begin gotoxy(j,i);write(' ');end; end; readln(f) end; close(f); trazi(sn,sm); readln;end.
komentar 3.1 : Promenqive definisane u delu za definiciju promenqivih imaju slede}e zna~ewe
M, N su dimenzije matrice (vi{e o matrici u 3.2) ne ve}e od 79*24, pre svega zbog prakti~nosti prikaza re{ewa
Sm, Sn su koordinate po~etne pozicije sa koje se polazi u kretawe matricom
Km, Kn su koordinate krajwe, ciqne pozicije do koje treba do}i kretawem po matrici
komentar 3.2 : Podaci o lavirintu se u~itavaju iz datoteke. Uz pomo} tih podataka formira se matrica dimenzija M*N ~ija se poqa defini{u kao prolaz za ‘ ‘(blanco), i prepreka za ‘*’. Sa svakog poqa poku{avamo da nastavimo kretawe u sva 4 pravca.
ITERATIVNI POSTUPAK
Postoji jedno nepisano pravilo po kome se bektrek najlak{e realizuje uz pomo} rekurzije. Upravo zbog toga se ~esto bektrek poistove}uje sa rekurzijom. Ova misao nema podloge u realnosti jer postoji ogroman broj primera koji se re{avaju rekurzijom a da pri tome nema nikakve veze sa bektrekom. Najpoznatiji primeri za ovakve probleme su izra~unavawe vrednosti izraza sa zagradama, obilazak hiperkocke, problem Hanojske kule itd...Nezavisnost bektreka od rekurzije je imanentna i mo`e se pokazati kroz
10
primere u kojima se rekurzivni postupak zamewuje iterativnim postupkom. Za realizaciju ovog na~ina potrebno je zabele`iti na svakom koraku podatke o tome koja je mogu}nost ostvarqiva, a koja ne. U prethodnom postupku bi bilo prakti~no stavqati odre|ene oznake za kretawe unapred i unazad.
HEURISTI^KE METODE
Bektrek se mo`e shvatiti kao univerzalna tehnika programirawa jer se wome uvek mo`e do}i do svih postoje}ih re{ewa. Ova prednost bektreka je ujedno i wegova najve}a mana, jer se ispitivawem svih potencijalnih re{ewa dobija na ta~nosti, ali se gubi na vremenu. U primeru pretrage kroz lavirint tra`ewe je toliko razgranato te se svako poqe matrice mo`e posetiti po dva puta ( pri tra`ewu puta i pri povratku ), te brzina programa zavisi od veli~ine matrice.
Bektrek je stvorio pomalo la`nu sliku o sebi i svojoj efikasnosti. ^esto se prostor pretrage zadaje implicitno, te se prostor pretrage znatno uve}ava. Tu se vidi da bektrek mo`e ~esto biti ma~ sa dve o{trice. Zato nije naodmet bektrek zameniti nekom drugom tehnikom programirawa kada god je to mogu}e. No, ipak postoje metode kojima se pove}ava brzina bektreka, a samim tim i smawuje vreme pretrage. Po nekad je mogu}e iskoristiti dodatne informacije o predmetu pretrage. Pomo}u toga bi se objekat pretra`ivao drugim redosledom, pa bi se time do{lo znatno br`e do re{ewa. Time bi se izbegla pretraga nekih delova objekta koji nisu va`ni za pretragu.
U informatici se postupci koji vode usmervawe pretrage prema re{ewu, nazivaju se heuristika. Heuristika, u op{tem zna~ewu te re~i, ozna~ava nauku o metodama i pronala`ewu novih, naro~ito u smislu pronala`ewa nau~nih ~iwenica. Od programa koji se zasniva na heuristikama o~ekujemo da radi, u bilo kom smislu, boqe od programa koji re{ava isti problem, ali je bez izrazitih heuristi~kih metoda. U nekim slu~ajevima problem je, bez heuristika, prakti~no nere{iv. Ne smemo se previ{e osloniti ni na heuristike,
11
heuristike u informati~kom smislu te re~i, jer one nisu ni{ta drugo do plod intuicije i “pomoz bog” metoda i nema neku opipqivu nau~no-teorijsku podlogu. Samim tim, ponekad, mogu dovesti i do neta~nih re{ewa. Ipak, ne mo`emo re}i da se pri kori{}ewu bektreka ne treba koristiti izvesnim prednostima koje nam daje na{ zdrav razum, te se slobodno mo`emo koristiti pojedinim dosetkama sve dotle dok one ne po~nu da uti~u negativno na rezultate na{eg programa. Prikaza}emo jedan primer koji se upravo slu`i tim metodama zdravog razuma koje doprinose kvalitetu programirawa.
PRIMER 4 : Dat je niz A od N realnih brojeva. Potrebno je podeliti ove brojeve u dve grupe, tako da su sume u grupama, {to je vi{e mogu}e, pribli`ne.
ANALIZA 4 : Ovaj problem mo`emo re{iti na vi{e na~ina. Kako bektrekom, ovaj problem se mo`e savladati dinami~kim programirawem, ta~nije modifikacijom problema ranca sa elementima od kojih se svaki mo`e uzeti samo jednom. Bektrekom se ovaj problem mo`e re{iti na dva na~ina: klasi~nim bektrekom i poboq{anim, heuristi~kim bektrekom. Verzije re{ewa }emo prikazati po efikasnosti, po~ev{i od najneefikasnije, tj. od klasi~nog bektreka.
RE[EWE 4.1 :program tegovi_ProstiBektrek_primer4;uses utime;var a:array[1..40] of real; group,bestgroup:array[1..40] of boolean; bestsum,sumall:real; i,k,n:integer; t:longint;procedure trazi(sum:real;dep:integer);begin if dep=n then begin if (sum>bestsum) and (sum<=sumall/2.0) then begin bestsum:=sum; for k:=1 to n do bestgroup[k]:=group[k];
12
end; end else if sum<=sumall/2.0 then begin group[dep+1]:=false; trazi(sum,dep+1); group[dep+1]:=true; trazi(sum+a[dep+1],dep+1); end;end;begin bestsum:=0; sumall:=0; write(' n= ');readln(n); for i:=1 to n do begin write(' a[',i,']= '); readln(a[i]); sumall:=sumall+a[i]; end; t:=getltime; trazi(0,0); writeln(getltime-t); for i:=1 to n do if bestgroup[i] then write(a[i]:5:1); writeln(' ',bestsum:5:1); readln;end.
komentar 4.1 : Ovo re{ewe je primena tipi~nog bektreka. Ako uporedime brzine sa heuristi~kim bektrekom, {to }emo uraditi ne{to kasnije ( sl.2 ), vide}emo da }e ovaj na~im vremenski neefikasniji. Ideja u ovoj verziji bektreka je da se za svaki ~lan niza isprobaju po dve mogu}nosti, tj. za svaki element ispitujemo da li je boqe da ga stavimo u pomo}ni podniz ili ne. U svakoj od ovih varijanti potragu bi trebalo nastaviti. Ovim bi, zapravo, formirali sve podnizove postoje}eg niza, a samim tim, ukoliko je n broj elemenata niza, ciklus bi pro{ao 2n puta. Pove}awem broja elemenata
13
niza za samo jedan element, du`ina izvr{avawa programa }e se duplo uve}ati. Prvi korak koji je u~iwen u ciqu ubrzavawa programa je odbacivawe re{ewa sa sumom ve}om od polovine ukupne sume. Ovo poboq{awe nam je skoro prepolovilo vreme, ali ipak je i daqe ovaj program radio sporo. Program se mo`e dodatano ubrzati prekidawem pretrage uvek kada ni uvr{tavawe svih preostalih ~lanova niza ne dovodi do dobijawa ve}e sume od optimalne. Ovaj radikalni pomak mo`e biti heuristika koja vodi u neta~no re{ewe, jer se u drugom delu niza, koji u prethodnom koraku odbacili, mogu nalaziti najve}i ~lanovi niza, pa se odsekao mali deo niza. Zbog toga ne bi bilo lo{e da ne niz, pre bilo kojih drugih operacija, sortira u nerastu}i poredak. Time bi se odsecali ve}i delovi drveta.
Uz jo{ neko poboq{awa mo`e se dobiti modifikovana heuristi~ka verzija bektrek re{ewsa ovog istog zadatka
RE[EWE 4.2 :program tegovi_HeuristickiBektrek_primer4;uses utime;var a:array[1..40] of real; group,bestgroup:array[1..40]ofboolean; bestsum,sumall:real; i,k,n:intger; t:longint;procedure trazi(sum:real;dep:integer;sumleft:real);begin if dep=n then begin if (sum>bestsum) and (sum<=sumall/2.0) then begin bestsum:=sum; for k:=1 to n do bestgroup[k]:=group[k]; end; end else if (sum<=sumall/2.0) and (sum+sumleft>bestsum) then begin group[dep+1]:=false;
14
trazi(sum,dep+1,sumleft-a[dep+1]); group[dep+1]:=true; trazi(sum+a[dep+1],dep+1,sumleft-a[dep+1]); end;end;begin bestsum:=0; sumall:=0; write(' n= ');readln(n); for i:=1 to n do begin write('a[',i,']= ');readln(a[i]); sumall:=sumall+a[i]; end; t:=getltime; trazi(0,0,sumall); writeln(getltime-t); for i :=1 to n do if bestgroup[i] then write(a[i]:5:1); writeln(' : ',bestsum:5:1);end.
komentar 4.2 : Kao heuristika u ovom primeru ra~una se odstupawe sume pomo}nog podniza od polovine sume svih ~laniva niza. U zadatku se tra`i minimum obe funkcije, tj. tra`i se slu~aj kada je razlika izme|u polovine sume svih elemenata i sume elemenata pomo}nog podniza najmawa. Koji god slu~aj da posmatramo, razlika izme|u suma niza i pomo}nog podniza, mo`e se maksimalno smawiti za sumu preostalih elemenata niza. Zbog toga nema potrebe za pretra`ivawem onog dela u kome napomenuta razlika, ni u ekstremnim uslovima kada se uvrste svi ostali ~lanovi, ne mo`e dosti}i minimum. Ovaj heuristi~ki metod smawivawa prostora pretrage naziva se tehnika razgranavawa i ograni~avawa pretrage ili na engleskom branch and bound ili skra}eno B&B. B&B predstavqa jednu od najpoznatijih i naj primenqivijih tehnika koja, veoma efikasno, smawuje prostor pretrage.
BRZINA KAO MANA
15
O razlici u efikasnosti ova dva programa koji re{avaju jedan te isti problem, i to oboje bektrekom, najboqe govori ova tabela ( sl.2 ). I jedan i drugi program su ispitivani rastu}im redosledom i sa opadaju}im redosledom elemenata niza. Nizovi nad kojima su ova dva prorama radila bila su razli~ita: jedan niz ~iji su elementi brojevi opsega 10-100, a drugi niz je sadr`ao pojedine elemente ve}e od ove granice. S obzirom na to kakvi su bili nizovi i wihov raspon, mo`emo razlikovati 4 slu~aja: veliki raspon i rastu}i niz, mali raspon i rastu}i niz, mali raspon i opadaju}i niz i veliki raspon i opadaju}i niz.U zavisnosti od niza programi su pokazali slede}e rezultate prikazane na slici 2.
tip podatka obi~an bektrek
branch and bound
veliki raspon, rastu}i niz 5’25.66” 6’43.26”
mali raspon, rastu}i niz 5’15.33” 6’11.35”
mali raspon, opadaju}i niz 3’28.82” 33.64”
veliki raspon, opadaju}i niz 3’17.95” 1.59”
slika 2.Evidentno je da se brzina smawuje, ako je niz ure|en u
rastu}em poretku, dok se u opadaju}en poretku brzina pove}ava, {to je dodu{e bilo o~ekivano. U ovom slu~aju B&B daje kontra efekat, jer se bezpotrebno tro{i vreme na proveru uslova za odsecawe drugog dela niza. Sve ovo se mo`e izbe}i prethodnim sortirawem niza u opadaju}i poredak. Ukoliko uporedimo rad sa nizovima koji su ure|eni opadaju}im poretkom, vide}emo da je B&B neuporedivo br`i i efikasniji. Ako uporedimo vrednosti iz tre}eg reda, vide}emo da B&B zadatak obavqa oko {est puta br`e, a za vrednosti kao u ~etvrtom redu oko 120 puta br`e, te s toga mo`emo zakqu~iti da se sa pove}awem raspona niza pove}ava efikasnost B&B, a raste jaz u vremenu izme|u wega i obi~nog bektreka.
16
Kada smo govorili o manama bektreka, rekli smo da se bektrek treba zameniti nekom drugom metodom kada je god to mogu}e. Konkretno ovaj zadatak, se mnogo efikasnije radi uz pomo} dinami~kog programirawa koje sve ~e{}e zamewuje pomalo zastareli bektrek. Prednost dinami~kog programirawa u odnosu na bektrek se mo`e prikazati na primeru ovog zadatka.
RE[EWE 4.3 :program tegovi_DinamickoProgramiranje_primer4;uses crt;var teg:array [1..20] of real; grupa,grupa1:array [1..20] of 0..1; i,j,n:integer; raz,min,suma,suma1,minsuma1:real;begin clrscr; write('Unesite koliko ima tegova: '); readln(n); for i:=1 to n do begin write('TEG[',i,']='); readln(teg[i]) end; suma:=0; for i:=1 to n do begin grupa[i]:=0; suma:=suma+teg[i] end; min:=suma; repeat suma1:=0; for i:=1 to n do if grupa[i]=1 then suma1:=suma1+teg[i]; raz:=abs(suma-2*suma1); if raz<min then begin min:=raz;
17
minsuma1:=suma1; for i:=1 to n do grupa1[i]:=grupa[i] end; j:=n; while (j>=0)and(grupa[j]=1) do begin grupa[j]:=0; j:=j-1 end; if j>0 then grupa[j]:=1 until j=0; clrscr; writeln('Minimalna razlika izmedju tegova je ',min:8:3,'.'); writeln; writeln('Tegovi prve grupe su:'); for i:=1 to n do if grupa1[i]=1 then write(teg[i]:8:3,' '); writeln; writeln('Ukupna masa tegova prve grupe je ',minsuma1:8:3,'.'); writeln; writeln('Tegovi druge grupe su:'); for i:=1 to n do if grupa1[i]=0 then write(teg[i]:8:3,' '); writeln; writeln('Ukupna masa tegova druge grupe je ',(suma-minsuma1):8:3); readlnend.BRZINA KAO VRLINA
Vreme izvr{avawa ovog programa, {to se ti~e prve dve kolone tabele ( sl.2 ), znatno mawe ( oko dve sekunde ), {to svedo~i o tome da niz u koji su sme{tene vrednosti te`ina tegova ne mora biti ure|en u opadaju}i poredak, da bi program radio efikasnije. [to se ti~e druge dve kolone tabele, ne mo`emo iza}i sa ~iwenicama u korist dinami~kog programirawa, jer su izmerene vrednosti u tim slu~ajevima
18
neznatno mawe nego li u prva dva slu~aja ( oko 1,8 sekundi ). U tim slu~ajevima se heuristi~ka metoda bektreka pokazuje kao najefikasnija. S obzirom na to da heuristi~ka metoda daje najboqe rezultate sa opadaju}im nizom, uz malu modifikaciju, koja se sastoji u dodavawe procedure za ure|ewe niza u opadaju}i poredak, ona bi mogla da poka`e, ipak, najboqe rezultate. Da ne bi ceo program pisao jo{ jednom, da}u samo proceduru za sortirawe niza u opadaju}i poredak sort(a,n) koja bi trebala da bude izvr{ena pre svih ostalih naredbi u operativnom delu programa.
DODATAK 4.2 : procedure sort(var a:array[1..40] of real;n:integer);var i,j:integer; d:real; begin for i:=1 to n-1 do for j:=i+1 to n do
if a[i]<a[j] then begin d:=a[i]; a[i]:=a[j]; a[j]:=d; end;
end; Program sa ovim heuristikama je efikasniji i od
dinami~kog programirawa i od obi~nog bektreka. No, ovo su prostiji primeri bektrek programirawa. Da bi se videla prava dra` bektreka, da}u primer koji je znatno slo`eniji i, za na{ nivo poznavawa Pascal-a, vrhunac programirawa. Ovaj zadatak je, pored toga {to je klasi~an primer za slo`eniji bektrek, specifi~an i po tome {to daje boqe re{ewe od bilo koje druge metode primewene na ovaj problem.
PRIMER 5 : Za dati niz od N cifara, na}i sve prirodne brojeve A sa najvi{e N cifara, ~iji se kvadrat zavr{ava datim nizom cifara. Na primer, za N=2 i niz a[1]=2, a[2]=1, tra`eni brojevi A su 11 (11*11 =121), 39 (39*39=1521), 61 (61*61=3721) i 89 (89*89=7921).
ANALIZA 5 : Da bi pre{li na programsko re{ewe zadatka, prvo ga trebamo re{iti matemati~ki, tj.
19
pojednostaviti rad kompjuteru sopstvenim matemati~kim pojednostavqewem problema.
Prvo re{ewe koje se ukazuje kao trivijalno je izra`eno preko kretawa kroz ciklus od 0 do broja 10n -1, pri ~emu bi se tra`ilo zadwih N cifara i odmah bi se upore|ivale sa zadatim vrednostima i ukoliko bi ispuwavali uslove, brojevi bi trebali biti {tampani. Ovaj program bi pao za sve vrednosti N ve}e od 12, jer je 10n opseg najve}e celobrojne deklaracije LongInt.
Jedna od ideja je da se posmatra samo zadwih K cifara, te s toga mo`emo zakqu~iti da na zadwih K cifara broja A uti~e, zapravo zadwih K cifara broja N. Ukoliko broj A shvatimo kao X*10k+B, gde je 10< Bk, pa imamo: A2=(X2*102k+ 2*B*X*10k+B2) = (X2*10k+2*B*X)*10k+B2. Iz ovoga se lako mo`e zakqu~iti da zavr{etak od K cifara zavisi samo od V, a zadwe dve cifre kvadrata broja V mo`emo zapisati na slede}i na~in B2 mod 10=10k(c*10k-2) +2cP*10k-1+P2, gde je c k-ta cifra sdesna na levo. c uti~e na K-tu cifru broja A2, {to nam daje mogu}nost da zadatak re{imo postupno, za svako K od 1 do N.
Ukoliko smo odredili broj V<10k za koji se posledwih K cifara poklapa sa posledwih K cifara broja V2, odredili smo potencijalni K--cifreni zavr{etak broja A. Da bi prona{li K+1-vu cifru broja A2 mo`emo jednostavnije prona}i K+1-vu cifru broja 2*B*c*10k+B2.
Iako na prvi pogled mnogo slo`eniji, ovaj postupak je mnogo br`i od testirawa svih K cifara. Kori{}ewem tablice ( sl.3 ) mo`emo izbe}i poga|awe prve cifre broja A, ve} je mo`emo odrediti kao tabli~nu vrednost, pomo}u niza stringova First ~iji element First[i] sadr`i sve cifre ~iji se kvadrati zavr{avaju tom cifrom i.
0 1 2 3 4 5 6 7 8 9
20
cifre ~iji se kvadrati
zavr{avaju na i0 0
9 / / 28 5 4
6 / / 37
slika 3.
RE[EWE 5 : program cifre_primer5;{$R+} const tenpow:array[0..9] of longint=(1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000);var quotient:array[0..9,0..9]of string; first:array[0..9]of string; aa:string; b:longint; aa1,i,j,c,n,err:integer;procedure trazi(b,carry:longint;nd:integer);var p,q,k:integer;begin if nd=0 then writeln(b) else begin writeln(b:10,nd:10); p:=(ord(aa[nd]-38-carry) mod 10; if p<0 then p:=p+10; q:=2*b mod 10; for k:=1 to length(quotient[p,q]) do begin c:=ord(quotient[p,q,k])-48; trazi(c*tenpow[n-nd]+b,(carry+2*b*c+c*c*tenpow[n-nd]) div 10,nd-1); end;
21
end;end;begin for i:=0 to 9 do first[i]:=''; for i:=0 to 9 do first[(i*i)mod 10]:=first[(i*i)mod 10]+ chr(i+48); for i:=0 to 9 do for j:=0 to 9 do quotient[i,j]:=''; for i:=0 to 9do for j:=0 to 9 do quotient[(i*j) mod 10,i]:=quotient[(i*j) mod 10,i] + chr(j+48); write('Kako se zavrsava A*A? ');readln(aa); n:=length(aa); writeln('A mora da se zavrsava na jedan od ovih nacina: '); aa1:=ord(aa[n])-48; for i:=1 to length(first[aa1]) do begin j:=ord(first[aa1][i])-48; trazi(j,(j*j) div 10, n-1); end; writeln(' kraj '); redln;end.
22
Ovaj primer je po sve slo`en, te zahteva detaqno obja{wewe koje nije ba{ realno i ne bi doprinelo lak{em razumevawu zadatka, ve} sam mi{qewa da je boqe zadatak ilustrovati kroz test primer. Uze}emo primer kada je N=4, a niz izgleda ovako: a[1]=1;a[2]=0;a[3]=2;a[4]=4. Me|u ovim ciframa postoje dve ~iji se kvadrati zavr{avaju brojem 4, pa }e program dva puta pozvati proceduru trazi, za parametre trazi(2,0,3) i trazi(8,6,3). U nekim slu~ajevima }e se program spustiti do dna drveta pretrage, kao na primer za broj 82. Zbog toga je program znatno sporiji, pa, kao {to je ranije napomenuto, nije lo{e ukoliko mo`emo da izbegnemo ovu tehniku programirawa. No ipak, ovaj problem daje znatno boqe rezultate kada radi bektrek verzijom, nego nekim drugim na~inom programirawa i ima znatno kra}e vreme izvr{avawa u odnosu na alternativna re{ewe.
Jo{ jedan problem, koji se veoma efikasno re{ava bektrekom, je i problem kowi}evog skoka.
PROBLEM 6 : Kvadratnu {ahovsku tablu dimenzija n*n treba obi}i potezima skaka~a, polaze}i iz gorweg levog ugla i staju}i na svako poqe ta~no po jednom.
ANALIZA 6.1 : Ovaj zadatak se mo`e uradeti na dva na~ina i to oba bektrekom, s tim {to je se re{ewa razlikuju po efikasnosti. Jedna ~iwenica koja je va`na za oba re{ewa problema je ta da skaka~ s jednog na drugo poqe, iz jednog poteza mo`e da pre|e ako i samo ako su apsolutne vrednosti razlike koordinata polaznog i poqa na koje skaka~ sti`e, 1 i 2 istovremeno. Re{ewe 6.1 ispituje sintaksnim redom sve mogu}e i nemogu}e putawe, tj. za svaku poziciju ispituje sve mogu}e poteze koji mogu da slede iz te pozicije.
RE[EWE 6.1 : program KlasicanBektrek_primer6;uses crt,utime;const dx:array[1..8] of integer=(2,2,1,1,-2,-2,-1,-1); dy:array[1..8] of integer=(1,-1,2,-2,1,-1,2,-2);var a:array[-1..23,-1..23] of integer; i,j,n:integer;
23
found:boolean; t:longint;procedure trazi(x,y,k:integer);var mov:integer;begin if not found then if a[x,y]=0 then begin a[x,y]:=k; if k=n*n then found:=true else for mov:=1 to 8 do trazi(x+dx[mov],y+dy[mov],k+1); if not found then begin a[x,y]:=0; end; end;begin write('Unesite dimenzije matrice n*n, n= '); readln(n); clrscr; t:=getltime; for i:=-1 to n+2 do for j:=-1 to n+2 do a[i,j]:=100; for i:=1 to n do for j:=1 to n do a[i,j]:=0; found:=false; trazi(1,1,1); clrscr; for i:=1 to n do begin for j:=1 to n do write(a[i,j]); writeln; end; writeln((getltime-t)/1000:6:2);
24
readln;end.
komentar 6.1 : Problem ovog programa je wegova brzina, jer ovaj program na~ini N2-1 potez. Pove}awem dimenzija {ahovske table za jedan broj poteza se drasti~no pove}ava, pa program za primere ve}e od 8 radi isuvi{e dugo.
ANALIZA 6.2 : Poqa koja nisu pose}ena povezana su u celinu, zbog malog dometa skaka~a, pa ukoliko imamo razdvojene grupe poqa, verivatno}a da }e se putawa dovr{iti postaje veoma mala. Zbog toga ne bi bilo lo{e da se kretawe vr{i du` ivica. Skaka~ koji se nalazi na sredini mo`e da se pomeri na 8 poqa. [to je skaka~ bli`e ivici, broj mogu}nosti za slede}i potez se znatno smawuje. Zbog toga ne bi bilo lo{e da isprobamo prvo mogu}nosti iz kojih je broj nastavaka najmawi. Program 6.2 izva~unava broj mogu}ih nastavaka.
RE[EWE 6.2 : program HeuristickiBektrek_primer6;uses crt,utime;const dx:array[1..8] of integer=(2,2,1,1,-2,-2,-1,-1); dy:array[1..8] of integer=(1,-1,2,-2,1,-1,2,-2); maxn=20;var a:array[-1..maxn+2,-1..maxn+2] of integer; i,j,n,p,x1,y1:integer; found:boolean; t:longint;procedure trazi(x,y,k:integer);var order,psbl:array[1..8] of integer; mov1,mov2:integer;begin if not found then if a[x,y]=0 then begin a[x,y]:=k;
25
gotoxy(3*x,y);write(k:4); if k=n*n then found:=true else begin for i:=1 to 8 do order[i]:=i; for mov1:=1 to 8 do begin psbl[mov1]:=0; x1:=x+dx[mov1]; y1:=y+dy[mov1]; if a[x1,y1]=0 then begin for mov2:=1 to 8 do if a[x1+dx[mov2],y1+dy[mov2]]=0 then psbl[mov1]:=psbl[mov1]+1; end; end; for i:=1 to 7 do for j:=1 to 7 do if psbl[order[i]]>psbl[order[j]] then begin p:=order[i]; order[i]:=order[j]; order[j]:=p; end; for mov1:=1 to 8 do trazi(x+dx[order[mov1]],y+dy[order[mov1]],k+1); end; if not found then begin a[x,y]:=0; gotoxy(3*x,y); write(0:4); end; end;begin write('Unesite dimenzije sahovske table n*n, n= '); readln(n);
26
clrscr; t:=getltime; for i:=-1 to n+2 do for j:=-1 to n+2 do a[i,j]:=100; for i:=1 to n do for j:=1 to n do a[i,j];=0; found:=false; trazi(1,1,1); clrscr; for i:=1 to n do begin for j:=1 to n do write(a[i,j]:4); writeln; end; writeln((getltime-t)/1000:6:2); readln;end.
komentar 6.2 : Mogla bi se dodati jo{ jedna heuristi~ka metoda koja podrazumeva da kada u nekoj poziciji ima vi{e mogu}ih poteza, a nakon jednog od wih nema nastavaka, da se presko~e sva isprobavawa, jer ta putawa ne mo`e da se nastavi. Iako perfektan program ne postoji, ovom zadatku nisu potrebna nikakva poboq{awa, jer on i zavelike vrednosti dimenzija matrice, npr. n=19, radi veoma brzo, ~ak i ispod jedne stotinke. Jedini problem za test primere ve}e od 19 je taj {to je ispis za tako velike test primere nepregledan zbog velikih dimenzija matrice.
Iz dosada{wih primera smo videli da se, u problemima u kojima se tra`i bilo koje re{ewe, a ne odre|eno, re{ewe dobija znatno br`e uz pomo} heuristi~kih metoda, jer one seku slepo crevo, tj. prekidaju pretragu kada ona ne mo`e dovesti do re{ewa.
Nave{}u jo{ jedan primer bektreka za kraj. Ovaj primer nije jedan od slo`enijih, ali je zanimqiv zbog toga {to
27
pokazuje mogu}nost da se bektekom mogu re{avati zadaci u kojima je potrebno na}i permutacije datog skupa.
PRIMER 7 : Na}i sve brojeve koji su permutacije broja 123456789i pri mno`ewu nekim jednocifrenim brojem razli~itim od jedinice, daju neku drugu permutaciju broja 123456789. Za svaki od jednocifrenih faktora ispitati broj na|enih permutacija.
ANALIZA 7 : Ru~no mo`emo do}i do zakqu~ka da su tra`ene cifre za primer 123456789, 2(123456789*2=246913578), 4( 123456789*4 =493827156 ), 5( 123456789*5=617283945 ), 7( 123456789*7=864197523 ), 8( 123456789*8= 987654312 ). Cifre koje ne odgovaraju ovom uslovu su 3, 6, 9.
Ideja zadatka je da se prvo generi{u permutacije svih cifara osim 0, s tim {to bi se proces prekinuo onda kada bi se mno`ewem prvog dela datim faktorom ponovila neka cifra ili ako bi se pojavila nula. Ova heuristika je veoma bitna jer se wome izbegava generisawe svih permutacija skupa S={ 1,2,3,4,5,6,7,8,9 }, a samim tim se vreme znatno skra}uje i program je znatno br`i.
RE[EWE 7 : program PermutovaniBrojevi_primer7;uses crt;var r:array[0..9]of integer; x:array[0..9]of longint; a,p:array[1..9]of integer; jeua,jeup:array[1..9]of boolean; i,j,f:longint;procedure perm(i:integer);var k:integer;begin if(i>9) and (r[9]=0) then x[f]:=x[f]+1 else begin for k:=1 to 9 do if not jeua[k] then
28
begin jeua[k]:=true; a[i]:=k; p[i]:=(a[i]*f+r[i-1])mod 10; r[i]:=(a[i]*f+r[i-1])div 10; if (p[i]>0) and (not jeup[p[i]]) then begin jeup[p[i]]:=true; perm(i+1); jeup[p[i]]:=false; end; jeua[k]:=false; end; end;end;begin clrscr; r[0]:=0; for i:=1 to 9 do begin jeua[i]:=false; jeup[i]:=false; x[i]:=0; end; for f:=2 to 9 do begin perm(1); writeln(f,' ',x[f]:6); end;readlnend.
Ovaj program se mo`e jo{ i daqe poboq{ati efikasnijim generisawem permutacija. Poboq{awe se sastoji u tome {to se ne bi pri svakom dodavawu cifre prolazilo kroz sve cifre i tra`ila bi se neka cifra koja nije ve} uvr{tena, ve} bi se direktno pristupalo ciframa koje nisu uvr{tene.
ZAKQU^AK
29
Na kraju se mo`e re}i da se bektrek danas sve mawe i mawe upotrebqava, najvi{e zbog sporosti, a i zbog slo`enosti. Iako postoje mnogi bektrek programi koji su znatno efikasniji od programa pisanih drugim tehnikama, bektrek se sve vi{e i vi{e zamewuje dinami~kim programirawem. Moramo pratiti i upotrebqavati i druge efikasnije metode, ali na bektrek se ne sme zaboraviti. Barem za sada...
Nikola Doj~inovi}
Sadr`aj
Uvod________________________________________________________02
30
Karakteristike______________________________________________02
Primer 1___________________________________________________
_03Re{ewe
1____________________________________________________03
Primer 2___________________________________________________
_06Re{ewe
2____________________________________________________06
Primer 3___________________________________________________
_08Analiza
3____________________________________________________08
Re{ewe 3___________________________________________________
_08Iteraktivni
postupak________________________________________10Heuristi~ke
metode__________________________________________10
31
Primer 4___________________________________________________
_11Analiza
4____________________________________________________11
Re{ewe 4.1_________________________________________________
__11Re{ewe
4.2___________________________________________________12
Brzina kao mana_____________________________________________1
5Re{ewe
4.3___________________________________________________16
Brzina kao vrlina___________________________________________17
Dodatak 4.2_________________________________________________
_18Primer
5____________________________________________________18
Analiza 5___________________________________________________
_18
32
Re{ewe 5___________________________________________________
_20Primer
6____________________________________________________21
Analiza 6.1_________________________________________________
_21Re{ewe
6.1___________________________________________________22
Analiza 6.2_________________________________________________
_23Re{ewe
6.2___________________________________________________23
Primer 7___________________________________________________
_26Analiza
7____________________________________________________26
Re{ewe 7___________________________________________________
_26Zakqu~ak__________________________________________
__________28
33
