SI Wiki - Кориснички доприноси [sr]

ОС1/Јун 2018

2024-09-13T00:09:21Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2018/jun/Jun%202018.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Objasniti razliku između pojmova ''proces'' i ''nit'' (engl. ''thread'').

=== Rešenje ===
Proces je jedno izvršavanje programa sa jednim adresnim prostorom. Nit (''thread'') ili laki proces je tok kontrole koji teče uporedo sa drugim tokovima kontrole, ali koji deli virtuelni adresni prostor sa nekim drugim tokom ili tokovima kontrole.

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih operacija <code>setjmp</code> i <code>longjmp</code>, implementirati operaciju ''wait'' na binarnom semaforu koji je realizovan klasom <code>Event</code> poput one u školskom jezgru.

=== Rešenje ===
<syntaxhighlight lang="cpp">
void Event::wait() {
if (val == 1) {
val = 0;
} else {
if (setjmp(Thread::running->context) == 0) {
blocked.put(running);
Thread::running = Scheduler::get();
longjmp(Thread::running->context, 1);
}
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Korišćenjem sistemskih poziva <code>fork</code> i <code>exec</code>, napisati funkciju <code>run</code> koja kreira proces nad programom u fajlu sa zadatom putanjom i vraća negativnu vrednost u slučaju greške, a <code>pid</code> kreiranog procesa u slučaju uspeha pri <code>fork</code>. Ukoliko ne uspe <code>exec</code>, kreirani proces-dete treba ugasiti.

=== Rešenje ===
<syntaxhighlight lang="cpp">
int run(char* path) {
pid_t pid = fork();
if (pid < 0) {
return -1;
}
if (pid == 0) {
int t = exec(path);
if (t < 0) {
exit(-2);
}
}
return pid;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Dva procesa pristupaju kritičnoj sekciji. Dat je presudokod jednog od njih, koji bi trebalo da obezbedi međusobno isključenje uposlenim čekanjem (kod drugog procesa izgleda analogno). Da li ovo rešenje obezbeđuje međusobno isključenje? Da li ima neki problem (ako ima, koji)?
{{Милокод|<nowiki>
process P1
begin
loop
flag1 := true;
while flag2 = true do null end;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</nowiki>}}

=== Rešenje ===
Ovo rešenje ne valja jer se dešava ''livelock'' odnosno oba procesa se međusobno zaključaju i ni jedan ni drugi se neće dalje izvršavati. To se desi kada proces P1 postavi <code>flag1</code> na <code>true</code> a zatim se desi promena konteksta i P2 postavi <code>flag2</code> na <code>true</code>.

== 5. zadatak ==
=== Postavka ===
Za koju od ove dve tehnike, dinamičko učitavanje (''dynamic loading'') ili preklopi (''overlays''), se može očekivati duže izvršavanje istog programa u najgorem slučaju? Precizno obrazložiti.

=== Rešenje ===
Duže vreme izvršavanja u najgorem slučaju se može očekivati kod preklopa jer će program stalno učitavati iz memorije iznova i iznova, dok će dinamičko učitavanje zauzeti više memorije, svaki potreban modul će učitati po jednom.

== 6. zadatak ==
=== Postavka ===
U nekom sistemu primenjuje se ''worst-fit'' algoritam kontinualne alokacije memorije. Inicijalno je prostor veličine 256KB potpuno slobodan za alokaciju korisničkih procesa. Potom su različiti procesi zadavali sledeće zahteve (slovna oznaka označava proces koji je postavio zahtev, brojna oznaka označava veličinu alociranog prostora u KB, a minus označava gašenje procesa i oslobađanje njegove memorije): A64, B16, C128, D32, A-, E8, F32, B-

Odgovoriti na sledeća pitanja koja se odnose na stanje memorije nakon ove sekvence zahteva:
# Koliko je ukupno slobodnih fragmenata?
# Kolika je veličina najmanjeg slobodnog fragmenta?
# Kolika je veličina najvećeg slobodnog fragmenta?

=== Rešenje ===
Jedno slovo označava 8KB prostora.
AAAAAAAA------------------------
AAAAAAAABB----------------------
AAAAAAAABBCCCCCCCCCCCCCCCC------
AAAAAAAABBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDD--
E-------BBCCCCCCCCCCCCCCCCDDDD--
EFFFF---BBCCCCCCCCCCCCCCCCDDDD--
EFFFF-----CCCCCCCCCCCCCCCCDDDD--
* Slobodnih fragmenata: 2
* Najmanji slobodan fragment: 16KB
* Najveći slobodan fragment: 40KB

== 7. zadatak ==
=== Postavka ===
Prilikom preslikavanja virtuelne adrese, procesor je generisao izuzetak zbog pokušaja upisa na tu adresu koji je u deskriptoru stranice označen kao zabranjen. Operativni sistem ipak neće ugasiti taj proces. Precizno objasniti zašto.

=== Rešenje ===
Neće ugasiti program jer se zapravo radi o tehnici ''copy-on-write'' odnosno kopiranja na upis. U ovoj tehnici, MMU vidi tu memoriju kao zabranjenu za upis. Prilikom generisanja greške, OS proverava da li je zabranjena, i kako vidi da zapravo nije nije, to znači da se radi o tehnici kopiranja na upis pa će operativni sistem kopirati stranicu i reći MMU da je dozvoljena za upis.

== 8. zadatak ==
=== Postavka ===
Navesti tri usluge vezane za realno vreme koje operativni sistem može da nudi i predložiti i kratko objasniti funkcije – sistemske pozive za te usluge.

=== Rešenje ===
# Informacija o tekućem realnom vremenu:
#: <syntaxhighlight lang="c" inline>time_t time (time_t* tloc);</syntaxhighlight>
#: Vraća broj sekundi koje su protekle od 1. 1. 1970. u 0 časova. Postoje i bibliotečke funkcije u <code>time.h</code> koje vraćaju “kalendarsko” vreme, rastavljeno na datum i sat itd, a oslanjaju se na ovaj sistemski poziv: <code>asctime</code>, <code>ctime</code>, <code>gmtime</code>, <code>localtime</code>.
# Suspenzija pozivajućeg procesa (“uspavljivanje”) za zadato vreme
#: <syntaxhighlight lang="c" inline>unsigned int sleep (unsigned int seconds);</syntaxhighlight>
# Čekanje na događaje, uslove ili na sinhronizacione primitive, ali vremenski ograničeno (tzv. ''timeout'' kontrole); ako se proces ne deblokira u zadatom vremenu, biće deblokiran zbog isteka vremenske kontrole; npr. za semafore:
#: <syntaxhighlight lang="c" inline>int sem_timedwait (sem_t *sem, const struct timespec *abs_timeout);</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako je tekući direktorijum nekog procesa <code>/a/b/c</code>, koja je apsolutna putanja do fajla koji taj proces otvara davanjem putanje <code>d/../../e/f.txt</code>?

=== Rešenje ===
Raščlanimo relativnu putanju na delove:
* <code>d</code>: idemo u direktorijum <code>d</code>, sada je putanja <code>/a/b/c/d</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b/c</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b</code>
* <code>e</code> idemo u direktorijum <code>e</code>, sada je putanja <code>/a/b/e</code>
* <code>f.txt</code> posećujemo fajl <code>f.txt</code>, krajnja putanja je <code>/a/b/e/f.txt</code>

== 10. zadatak ==
=== Postavka ===
Fajl sistem primenjuje ulančanu alokaciju, s tim da se i slobodni blokovi ulančavaju u listu. U strukturi FCB polje <code>head</code> sadrži broj prvog bloka sa sadržajem fajla, a polje <code>size</code> veličinu sadržaja. Funkcija jezgra <code>free</code> prima kao argument broj prvog bloka u lancu blokova koje treba proglasiti slobodnim. Napisati funkciju jezgra <code>truncate</code> koja briše sadržaj fajla na čiji <code>FCB</code> ukazuje argument.

=== Rešenje ===
Pretpostavimo da <code>free_head</code> i <code>free_tail</code> predstavljaju pokazivače na početak i kraj ulančane liste slobodnih blokova.
<syntaxhighlight lang="c">
void truncate(FCB *f) {
if (f->head == NULL) {
return;
}
int numOfBlocks = f->size / BLOCK_SIZE, i = 0, cur = f->head, tmp_head = f->head, prev;
while (i < numOfBlocks) {
free(cur);
prev = cur;
cur = cur->next;
i++;
}
if (free_head == NULL) {
free_head = tmp_head;
} else {
free_tail->next = tmp_head;
}
free_tail = prev;
}
</syntaxhighlight>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

АСП2/К3 2020

2024-09-13T00:09:18Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K3_1920.pdf Postavka na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Upotrebom tehnike objedinjenog ulančavanja implementirati funkciju DELETE_ENTRY koja treba da iz heš tabele (''table'') fizički ukloni prosledjeni<sup>[sic]</sup> ključ (''key'') ukoliko on postoji. Tabela ima ''n'' ulaza, a funkcija treba da ažurira i index ''free'' tako da ne postoji slobodna lokacija sa većim indeksom.

=== Rešenje ===
Prvo tražimo lokaciju ključa za uklanjanje a zatim, ako je ključ pronađen, prevezujemo prethodnu posećenu zauzetu lokaciju, brišemo ključ iz tabele i ažuriramo pokazivač ''free''.
{{Милокод|<nowiki>
DELETE ENTRY(table, n, key, free)
prev_adr = -1
adr = h(key)
while (adr ≠ -1) and (key(table[adr]) ≠ key) do
prev_adr = adr
adr = next(table[adr])
end_while
if adr ≠ -1 then
if prev_adr ≠ -1 then
next(table[prev_adr]) = next(table[adr])
end_if
key(table[adr]) = empty
next(table[adr]) = -1
if adr > free then
free = adr
end_if
end_if
</nowiki>}}
Po novijoj verziji knjige profesora Mila V. Tomaševića pri objedinjenom ulančavanju bi trebalo da se na oslobođeno mesto prebacuje ključ sa kraja liste u kojoj se nalazio, i takav pristup se nalazi ispod:
{{Милокод|<nowiki>
DELETE ENTRY(table, n, key, free)
prev_adr = -1
adr = h(key)
while (adr ≠ -1) and (key(table[adr]) ≠ key) do
prev_adr = adr
adr = next(table[adr])
end_while
if adr ≠ -1 then
if next(table[adr]) = -1 then
if prev_adr ≠ -1 then
next(table[prev_adr]) = -1
end_if
key(table[adr]) = empty
next(table[adr]) = -1
if adr > free then
free = adr
end_if
else
prev_adr = -1
last_adr = adr
while next(table[last_adr]) ≠ -1 do
prev_adr = last_adr
last_adr = next(table[last_adr])
end_while
next(table[prev_adr]) = -1
key(table[adr]) = key(table[last_adr])
key(table[last_adr]) = empty
if last_adr > free then
free = last_adr
end_if
end_if
end_if
</nowiki>}}

== 2. zadatak ==
=== Postavka ===
Radix exchange algoritam.
<div class="abc-list">
# Prikazati prve tri iteracije algoritma radix exchange nad sledećom sekvencom 5-bitnih neoznačenih celobrojnih ključeva:
# Da li je algoritam stabilan? Obrazložiti ukratko.
</div>

=== Rešenje ===
Prvo odvajamo ključeve na bitove:
* 4 — 00100
* 7 — 00111
* 9 — 01001
* 10 — 01010
* 15 — 01111
* 16 — 10000
* 18 — 10010
* 23 — 10111
{| class="wikitable"
|+ Prve tri iteracije ''radix exchange'' algoritma nad sekvencom
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7
|-
| 7 || 18 || 23 || 4 || 10 || 16 || 9 || 15
|-
| 7 || 15 || 9 || 4 || 10 || 16 || 23 || 18
|-
| 7 || 4 || 9 || 15 || 10 || 16 || 23 || 18
|-
| 7 || 4 || 9 || 10 || 15 || 16 || 18 || 23
|}
Ovaj algoritam nije stabilan jer funkcioniše po sličnom principu kao ''quicksort'' zamena. Stabilnost algoritma podrazumeva da se jednaki elementi sortiraju po indeksu u originalnom poretku, a ovde se može desiti da se prilikom zamene element koji je bio prvi među jednakima prebaci na kraj.

== 3. zadatak ==
=== Postavka ===
Posmatra se rastuće uređeni '''binarni hip''', koji je dat u vidu niza ključeva ''heap''. Napisati u pseudokodu efikasnu iterativnu funkciju koja menja vrednost zadatog ključa ''key'', na zadatu vrednost ''new_key''. Poznato je da hip ima ''n'' elemenata.

=== Rešenje ===
Algoritam prvo pronalazi ključ u hipu iterativnim obilaskom niza (ne postoji efikasnija tehnika od te jer hip ne daje nikakve garancije da će se dati element naći u levom ili desnom podstablu).
{{Милокод|<nowiki>
HEAP CHANGE(heap, n, key, new_key)
pos = -1
for i = 1 to n do
if heap[i] = key then
pos = i
break
end_if
end_for
if pos = -1 then
ERROR(Ključ nije u hipu)
end_if
heap[pos] = new_key
parent_pos = pos / 2
child_pos_1 = pos * 2
child_pos_2 = pos * 2 + 1
if (parent_pos > 0) and (heap[parent_pos] > heap[pos]) then
while (parent_pos > 0) and (heap[parent_pos] > heap[pos]) do
heap[pos] = heap[parent_pos]
heap[parent_pos] = new_key
pos = parent_pos
parent_pos = pos / 2
end_while
else if ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) then
while ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) do
if (child_pos_1 ≤ n) and (heap[child_pos_2] < heap[child_pos_1] < heap[pos]) then
heap[pos] = heap[child_pos_1]
heap[child_pos_1] = new_key
pos = child_pos_1
else
heap[pos] = heap[child_pos_2]
heap[child_pos_2] = new_key
pos = child_pos_2
end_if
child_pos_1 = pos * 2
child_pos_2 = pos * 2 + 1
end_while
end_if
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije h<sub>p</sub>(K) = K mod 7. Za razrešavanje kolizija se koristi tehnika kvadratnog pretraživanja. U tabelu se umeću redom ključevi 38, 31, 10, 56, 21. Odrediti prosečan broj pristupa prilikom uspešnog i neuspešnog traženja i verovatnoću popunjavanja praznih ulaza, pod pretpostavkom da su svi ključevi jednako verovatni.

=== Rešenje ===
Ovaj zadatak je rešen na [https://rti.etf.bg.ac.rs/rti/ri3sp/materijali/si2asp2/09_Hesiranje.ppt prezentaciji iz heširanja] na stranici predmeta.
{| class="wikitable"
|+ Popunjena heš tabela
| 0 || 10
|-
| 1 || 56
|-
| 2 || 21
|-
| 3 || 38
|-
| 4 || 31
|-
| 5 ||
|-
| 6 ||
|}
{| class="wikitable"
|+ Ispitni nizovi za kvadratno pretraživanje
! i / K % 7 !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6
|-
! 0
| 0 || 1 || 2 || 3 || 4 || 5 || 6
|-
! 1
| 1 || 2 || 3 || 4 || 5 || 6 || 0
|-
! 2
| 4 || 5 || 6 || 0 || 1 || 2 || 3
|-
! 3
| 2 || 3 || 4 || 5 || 6 || 0 || 1
|-
! 4
| 2 || 3 || 4 || 5 || 6 || 0 || 1
|-
! 5
| 4 || 5 || 6 || 0 || 1 || 2 || 3
|-
! 6
| 1 || 2 || 3 || 4 || 5 || 6 || 0
|}
* Umetanje:
** 38 % 7 = 3 (1 pristup)
** 31 % 7 = 3 (2 pristupa)
*** (3 + 1*1) % 7 = 4
** 10 % 7 = 3 (3 pristupa)
*** (3 + 1*1) % 7 = 4
*** (3 + 2*2) % 7 = 0
** 56 % 7 = 0 (2 pristupa)
*** (0 + 1*1) % 7 = 1
** 21 % 7 = 0 (4 pristupa)
*** (0 + 1*1) % 7 = 1
*** (0 + 2*2) % 7 = 4
*** (0 + 3*3) % 7 = 2
* Prosečan broj uspešnih pristupa: <math>P_u = \frac{1 + 2 + 3 + 2 + 4}{5} = \frac{12}{5} = 2.4</math>
* Prosečan broj neuspešnih pristupa: <math>P_nu = 1 + \frac{5}{7} + \frac{5 \cdot 4}{7 \cdot 6} + \frac{5 \cdot 4 \cdot 3}{7 \cdot 6 \cdot 5} + \frac{5 \cdot 4 \cdot 3 \cdot 2}{7 \cdot 6 \cdot 5 \cdot 4} + \frac{5 \cdot 4 \cdot 3 \cdot 2 \cdot 1}{7 \cdot 6 \cdot 5 \cdot 4 \cdot 3} =</math>
*: <math>= 1 + \frac{5}{7} + \frac{10}{21} + \frac{2}{7} + \frac{1}{7} + \frac{1}{21} = \frac{8}{3} \approx 2.67</math>
* Verovatnoća popunjavanja:
** 5: <math>\frac{0 + 1 + 0 + 1 + 1 + 1 + 0}{7} = \frac{4}{7}</math>
** 6: <math>\frac{0 + 0 + 1 + 0 + 0 + 0 + 1}{7} = \frac{2}{7}</math>

== 5. zadatak ==
=== Postavka ===
Prikazati izgled '''binomnog hipa''' nakon svake izmene, ukoliko se prvo obriše minimum, pa se nakon toga dodaju ključevi 2, 32, 4 i nakon toga ponovo obriše minimum.

=== Rešenje ===
U originalnoj postavci je umesto broja 19 stajao broj 9. Hip tada ne bi bio validan, tako da se u rešenju smatra da je tu broj 19.

Ispod je dato konačno rešenje zadatka, a koraci se mogu simulirati u [https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html simulatoru binomnih hipova,] redom umetanjem ključeva 19, 41, 15, 29, 17, 25, 3, 10 i 14, pa zatim izvršavati zadate operacije.

<gallery class="transparent-svg">
ASP2 K3 2020 zadatak 5 hip postavka.svg | Ispravljena postavka zadatka
ASP2 K3 2020 zadatak 5 hip rešenje.svg | Konačni izgleda hipa
</gallery>

== 6. zadatak ==
=== Postavka ===
Data je sekvenca ključeva: 159, 57, 103, 7, 74, 95, 8, 101, 179, 45, 303, 42, 219. Prikazati rad ''shell sort'' algoritma po koracima. Navesti korišćenu sekvencu inkremenata i obrazložiti izbor.

=== Rešenje ===
Data sekvenca ima 13 ključeva, i ono što inkrementi u ''shell sort'' algoritmu treba idealno da postignu jeste mešanje ključeva između "grupa", te se zato biraju uzajamno prosti inkrementi 7, 5, 3, 2 i 1.
{| class="wikitable"
|+ Koraci ''shell sort'' algoritma
! Inkrement !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12
|-
! Početak
| 159 || 57 || 103 || 7 || 74 || 95 || 8 || 101 || 179 || 45 || 303 || 42 || 219
|-
! 7
| 101 || 57 || 45 || 7 || 42 || 95 || 8 || 159 || 179 || 103 || 303 || 74 || 219
|-
! 5
| 95 || 8 || 45 || 7 || 42 || 101 || 57 || 159 || 179 || 103 || 303 || 74 || 219
|-
! 3
| 7 || 8 || 45 || 57 || 42 || 101 || 95 || 159 || 74 || 103 || 303 || 179 || 219
|-
! 3
| 7 || 8 || 45 || 57 || 42 || 74 || 95 || 159 || 101 || 103 || 303 || 179 || 219
|-
! 2
| 7 || 8 || 42 || 57 || 45 || 74 || 95 || 103 || 101 || 159 || 219 || 179 || 303
|-
! 1
| 7 || 8 || 42 || 45 || 57 || 74 || 95 || 101 || 103 || 159 || 179 || 219 || 303
|}

== 7. zadatak ==
=== Postavka ===
Neka se kod spoljašnjeg heširanja koristi tehnika dinamičkog heširanja. Heš tabela se sastoji od 4 baketa kapaciteta b = 2. Za heš funkciju se koriste viši bitovi heš funkcije K ''mod'' 8. Neka se u tabelu umeću redom ključevi 37, 33, 15, 24, 37, 46, 41 i 54. Ilustrovati stanje tabele nakon svakog razrešenja kolizije pri umetanju i u završnom stanju.

=== Rešenje ===
[ 00 | 01 | 10 | 11 ]
|
[37 ]

[ 00 | 01 | 10 | 11 ]
| |
[33 ] [37 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 ] [37 ][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 ][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 37][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 37][15 46]

[ 00 | 01 | 10 | 11 ]
| | |
/ \ | |
| | | |
[24 ][33 41] [37 37][15 46]
000... 001...

[ 00 | 01 | 10 | 11 ]
| | |
/ \ / / \
| | | | |
[24 ][33 41][37 37][46 54][15 ]
000... 001... 110... 111...

== 8. zadatak ==
=== Postavka ===
Neka je dat niz celih brojeva ''arr'' dužine ''n'' čiji se elementi nalaze u opsegu od 0 do ''k''-1. Napisati u pseudokodu iterativnu funkciju koja pronalazi element koji se najčešće pojavljuje u nizu. Ukoliko ima više takvih elemenata dovoljno je pronaći jedan. Funkcija treba da ima što je moguće bolju vremensku i prostornu složenost. Dozvoljeno je modifikovati polazni niz.

=== Rešenje ===
Ovde su dva rešenja pogodna:
* Pošto nam je dat opseg vrednosti u nizu, može se koristiti ''counting sort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n)</math> i prostornoj složenosti <math>\mathcal{O}(k)</math> pronašla vrednost koja se najviše ponavlja
* Pošto nam je dato da se polazni niz može modifikovati, može se koristiti ''heapsort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n \log n)</math> i prostornoj složenosti <math>\mathcal{O}(1)</math> pronašla tražena vrednost
Ispod je dato rešenje pomoću ''counting sort''.
{{Милокод|<nowiki>
FIND MAX REP(arr, n, k)
rep_max = 0
rep_elem = 0
for i = 0 to k-1 do
c[i] = 0
end_for
for i = 1 to n do
c[arr[i]] = c[arr[i]] + 1
if c[arr[i]] > rep_max then
rep_max = c[arr[i]]
rep_elem = arr[i]
end_if
end_for
return rep_elem
</nowiki>}}

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К3 2019

2024-09-13T00:09:17Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K3_1819.pdf Postavka sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Upotrebom metode heširanja implementirati funkciju FIND_NUM_OF_PAIRS koja treba da pronađe ukupan broj parova celobrojnih vrednosti u zadatom nizu ''arr'' koji u sumi po modulu ''n'' daju vrednost ''k'' koja predstavlja parametar funkcije. Za realizaciju ove funkcije treba koristiti metodu odvojenog ulančavanja.

=== Rešenje ===
Ovde nema potrebe koristiti bilo kakvo ulančavanje jer je ''counting sort'' dovoljan da izbroji ključeve koji daju neku vrednost po modulu ''n'' a zatim izmnoži izbrojano. Na primer, za ''n = 7'' i ''k = 1'' na sumu se redom dodaju:
# <math>\frac{C[0] \cdot C[1]}{2}</math>
# <math>\frac{C[1] \cdot C[0]}{2}</math>
# <math>\frac{C[2] \cdot C[6]}{2}</math>
# <math>\frac{C[3] \cdot C[5]}{2}</math>
# <math>\frac{C[4] \cdot (C[4] - 1)}{2}</math>
# <math>\frac{C[5] \cdot C[3]}{2}</math>
# <math>\frac{C[6] \cdot C[2]}{2}</math>
{{Милокод|<nowiki>
FIND NUM OF PAIRS(arr, n, k)
for i = 0 to n-1 do
C[i] = nil
end_for
for i = 1 to LENGTH(arr) do
adr = arr[i] mod n
if C[adr] = nil then
C[adr] = GETNODE
value(C[adr]) = arr[i]
next(C[adr]) = nil
else
curr = next(C[adr])
prev = C[adr]
while curr ≠ nil do
prev = curr
curr = next(curr)
end_while
next(prev) = GETNODE
value(next(prev)) = arr[i]
next(next(prev)) = nil
end_if
end_for
count = 0
for i = 0 to n-1 do
node_count_1 = 0
curr = C[i]
while curr ≠ nil do
node_count_1 = node_count_1 + 1
curr = next(curr)
end_while
node_count_2 = 0
j = (k - i) mod n
curr = C[j]
while curr ≠ nil do
node_count_2 = node_count_2 + 1
curr = next(curr)
end_while
if i = j then
count = count + node_count_1 * (node_count_1 - 1) / 2
else
count = count + node_count_1 * node_count_2 / 2
end_if
end_for
for i = 0 to n-1 do
curr = C[i]
while curr ≠ nil do
tmp = curr
curr = next(curr)
FREENODE(tmp)
end_while
end_for
return count
</nowiki>}}

== 2. zadatak ==
=== Postavka ===
Prikazati izgled '''binomnog hipa''' nakon svake izmene, ukoliko se umeću ključevi 19, 11, 25 i nakon toga obriše minimum.

=== Rešenje ===
Ispod je dato konačno rešenje zadatka, a koraci se mogu simulirati u [https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html simulatoru binomnih hipova,] redom umetanjem ključeva 14, 27, 12, 23, 15, 22, 5, 9 i 17, pa zatim izvršavati zadate operacije.

<gallery class="transparent-svg">
ASP2 K3 2019 zadatak 2 hip postavka.svg | Postavka zadatka
ASP2 K3 2019 zadatak 2 hip rešenje.svg | Konačni izgleda hipa
</gallery>

== 3. zadatak ==
=== Postavka ===
Data je sekvenca ključeva: 27, 25, 14, 34, 7, 1, 5, 193, 33, 41, 73, 124. Prikazati rad ''radix sort'' algoritma po koracima.

=== Rešenje ===
{| class="wikitable"
|+ Prvi korak ''radix sort'' algoritma
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 1 || || 193 || 14 || 25 || || 27 || ||
|-
| || 41 || || 33 || 34 || 5 || || 7 || ||
|-
| || || || 73 || 124 || || || || ||
|}
Dobijena sekvenca posle prvog koraka: 1, 41, 193, 33, 73, 14, 34, 124, 25, 5, 27, 7
{| class="wikitable"
|+ Drugi korak ''radix sort'' algoritma
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| 1 || 14 || 124 || 33 || 41 || || || 73 || || 193
|-
| 5 || || 25 || 34 || || || || || ||
|-
| 7 || || 27 || || || || || || ||
|}
Dobijena sekvenca posle drugog koraka: 1, 5, 7, 14, 124, 25, 27, 33, 34, 41, 73, 193.

Treći korak neće biti prikazan jer će u suštini samo prve dve kolone biti jako popunjene, ali se na kraju dobija poredak: 1, 5, 7, 14, 25, 27, 33, 34, 41, 73, 124, 193.

== 4. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 10 ulaza primenom heš funkcije h<sub>p</sub>(K) = K mod ''10''. Za razrešavanje kolizija se koristi metoda objedinjenog ulančavanja. Prikazati popunjavanje date tabele nakon umetanja svakog od sledećih ključeva: 37, 41, 18, 16, 12. Nakon svih umetanja, odrediti verovatnoću popunjavanja praznih ulaza, pod pretpostavkom da su svi ključevi jednako verovatni.
{| class="wikitable"
|+ Tabela iz postavke zadatka
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || || || || || || || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || -1 || -1 || -1 || -1 || -1
|-
| || || || || || || || || free ||
|}

=== Rešenje ===
{| class="wikitable"
|+ Tabela nakon umetanja 37
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || || || || || || 37 || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || -1 || -1 || -1 || -1 || -1
|-
| || || || || || || || || free ||
|}
{| class="wikitable"
|+ Tabela nakon umetanja 41
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || || || || || 41 || 37 || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || -1 || -1 || -1 || 6 || -1
|-
| || || || || || || free || || ||
|}
{| class="wikitable"
|+ Tabela nakon umetanja 18
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || || || || 18 || 41 || 37 || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || -1 || 5 || -1 || 6 || -1
|-
| || || || || || free || || || ||
|}
{| class="wikitable"
|+ Tabela nakon umetanja 16
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || || || 16 || 18 || 41 || 37 || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || 4 || 5 || -1 || 6 || -1
|-
| || || || || free || || || || ||
|}
{| class="wikitable"
|+ Tabela nakon umetanja 12
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9
|-
| || 11 || 12 || || 16 || 18 || 41 || 37 || 21 || 29
|-
| -1 || 8 || -1 || -1 || -1 || 4 || 5 || -1 || 6 || -1
|-
| || || || || free || || || || ||
|}
Verovatnoća popunjavanja ulaza 0 je <math>\frac{1}{10}</math>, jer se on popunjava samo ukoliko se umeće broj kongruentan sa 0 po modulu 10. Verovatnoća popunjavanja ulaza 3 je, stoga, <math>\frac{9}{10}</math>, jer se on popunjava za bilo koji drugi moduo.

== 5. zadatak ==
=== Postavka ===
Priloženi pseudokod prikazuje algoritam za uređivanje špila karata u jednoj kartaškoj igri. U igri se koristi špil od po 8 karata za svaki od 4 znaka (ukupno 32). Algoritam treba da grupiše karte istog znaka, pri čemu karte istog znaka sortira prema rastućoj vrednosti. Uočiti i objasniti greške ili nedostatke priloženog algoritma i napisati u pseudokodu ispravnu implementaciju u skladu sa zahtevima. Polje ''val'' predstavlja vrednost karte, a polje ''sign'' njen znak.
<pre>
for i = 2 to 32 do
k = cards[i]
j = i-1
while(j>0 and cards[j].val>k.val) do
cards[j+1] = cards[j]
j = j-1
end_while
cards[j] = k
end_for
for i = 1 to 4 do
c[i] = 0
end_for
for j = 1 to n do
c[cards[j].sign] = c[cards[j].sign]+1
end_for
for i = 3 downto 1 do
c[i] = c[i+1] - c[i]
end_for
for j = 1 to n do
b[c[cards[j].sign]] = cards[j]
c[cards[j].sign] = c[cards[j].sign]-1
end_for
</pre>

=== Rešenje ===
Sledeće greške su uočene:
* Niz <code>cards</code> počinje od 1 a na kraju <code>while</code> petlje se postavlja <code>cards[j]</code> na vrednost <code>k</code>, s tim što je jedan od uslova petlje <code>j > 0</code>. Ovde se mora prepraviti na <code>cards[j + 1]</code>.
* ''Counting sort'' implementacija za sortiranje po znaku ne radi.
{{Милокод|<nowiki>
SORT(cards)
for i = 2 to 32 do
k = cards[i]
j = i - 1
while (j > 0) and (val(cards[j]) > val(k)) do
cards[j + 1] = cards[j]
j = j - 1
end_while
cards[j + 1] = k
end_for
for i = 1 to 4 do
c[i] = 0
end_for
for j = 1 to n do
c[sign(cards[j])] = c[sign(cards[j])] + 1
end_for
for i = 2 to 4 do
c[i] = c[i-1] + c[i]
end_for
for j = n downto 1 do
b[c[sign(cards[j])]] = cards[j]
c[sign(cards[j])] = c[sign(cards[j])] - 1
end_for
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
Koristeći ideju ''quick sort'' algoritma, napisati u pseudokodu funkciju koja vraća ''k''-ti najmanji element u zadatom nizu celih brojeva ''arr''. Prilikom izbora ''pivot''-a, koristiti medijanu od tri pogodno izabrane vrednosti.

=== Rešenje ===
{{Милокод|<nowiki>
QUICK SELECT(arr, k)
min = FIND(arr, 1, n, k)
return min
</nowiki>}}
{{Милокод|<nowiki>
FIND(a, low, high, k)
j = PARTITION(a, low, high)
i = low + k - 1
if i = j then
return a[i]
end_if
if j > i then
return FIND(a, low, j - 1, k)
else
return FIND(a, j + 1, high, k - j)
end_if
</nowiki>}}
{{Милокод|<nowiki>
PARTITION(a, down, up)
i = down
j = up
pivot_pos = MEDIAN(a[i], i, a[j], j, a[(i + j) / 2], (i + j) / 2)
pivot = a[pivot_pos]
while i < j do
while (a[i] ≤ pivot) and (i < j) do
i = i + 1
end_while
while a[j] > pivot do
j = j - 1
end_while
if i < j then
if j == pivot_pos then
pivot_pos = i
end_if
a[i] ↔ a[j]
end_if
end_while
a[pivot_pos] = a[j]
a[j] = pivot
return j
</nowiki>}}
{{Милокод|<nowiki>
MEDIAN(a, pos_a, b, pos_b, c, pos_c)
if (a > b) xor (a > c) then
return pos_a
else if (b < a) xor (b < c) then
return pos_b
else
return pos_c
end_if
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 9 ulaza primenom heš funkcije hp(K)=K mod 9. Za razrešavanje kolizija se koristi metoda linearnog pretraživanja sa korakom 2. Definisati pojam primarnog i sekundarnog grupisanja, a zatim na primeru delimično popunjene tabele sa slike, ilustrovati jedan scenario umetanja kod kojeg se dešava primarno grupisanje i jedan scenario umetanja kod kojeg se dešava sekundarno grupisanje.
{| class="wikitable"
|+ Tabela iz postavke zadatka
! 0
| 27
|-
! 1
|
|-
! 2
| 11
|-
! 3
|
|-
! 4
|
|-
! 5
| 23
|-
! 6
|
|-
! 7
|
|-
! 8
| 8
|}

=== Rešenje ===
Sekundarno grupisanje je kada heš funkcija za dva različita ključa vraća istu matičnu adresu, pa su im i ispitni nizovi jednaki. Kada umetnemo ključ 18, dobijamo sekundarno grupisanje:
* 18 % 9 = 0 (ovde se desilo sekundarno grupisanje, jer ključevi 27 i 18 imaju istu matičnu adresu 0)
** (0 + 2) % 9 = 2 (ovde se desilo primarno grupisanje, jer se ispitni niz po modulu 0 i ispitni niz po modulu 2 ovde preklapaju)
** (2 + 2) % 9 = 4
{| class="wikitable"
|+ Tabela nakon umetanja ključa 18
! 0
| 27
|-
! 1
|
|-
! 2
| 11
|-
! 3
|
|-
! 4
| 18
|-
! 5
| 23
|-
! 6
|
|-
! 7
|
|-
! 8
| 8
|}
Primarno grupisanje je kada se dva ispitna niza od različitih matičnih adresa preklope. Ta pojava se takođe može ilustrovati na primeru umetanja ključa 20:
* 20 % 9 = 2 (ovde se desilo sekundarno grupisanje, jer ključevi 11 i 20 imaju istu matičnu adresu 2)
** (2 + 2) % 9 = 4 (ovde se desilo primarno grupisanje, jer se ispitni nizovi po modulu 2 i po modulu 0 ponovo preklapaju)
** (4 + 2) % 9 = 6
{| class="wikitable"
|+ Tabela nakon umetanja ključa 20
! 0
| 27
|-
! 1
|
|-
! 2
| 11
|-
! 3
|
|-
! 4
| 18
|-
! 5
| 23
|-
! 6
| 20
|-
! 7
|
|-
! 8
| 8
|}

== 8. zadatak ==
=== Postavka ===
Neka se kod spoljašnjeg heširanja koristi heš tabela sa 4 baketa, koji imaju kapacitet b = 3. Za heš funkciju se koristi metod deljenja ''K mod 4'', a za razrešavanje kolizije linearno pretraživanje. Neka se pri brisanju koristi metod selektivnog pomeranja (analogno kao kod unutrašnjeg heširanja). U tabelu treba umetnuti ključeve 60, 18, 23, 50, 47, 34, 82, 14, 67 i 38, a zatim brisati ključeve 50, 47, 23 i 34. Prikazati izgled tabele nakon svakog razrešenja kolizije pri umetanju, kao nakon svakog brisanja.

=== Rešenje ===
Konačan izgled heš tabele je:

{| class="wikitable"
! 60 !! !! !! !! !! !! 14 !! 18 !! 82 !! 38 !! 67 !!
|}

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К3 2018

2024-09-13T00:09:15Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K3_1718.pdf Postavka zadataka na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Prikazati izgled '''binarnog hipa''' nakon uklanjanja minimalnog ključa i nakon umetanja ključeva 9 i 30.
5
/ \
10 7
/ \ / \
47 32 12 31
/
54

=== Rešenje ===
Nakon uklanjanja minimalnog ključa:
7
/ \
10 12
/ \ / \
47 32 54 31
Nakon umetanja ključeva 9 i 30:
7
/ \
9 12
/ \ / \
10 32 54 31
/ \
47 30

== 2. zadatak ==
=== Postavka ===
Napisati iterativnu implementaciju sledećeg algoritma heširanja. Za heširanje se koriste dve heš funkcije, ''h<sub>1</sub>(K)'' i ''h<sub>2</sub>(K)'', dok se za razrešavanje kolizija koristi sekundarna heš funkcija ''g(k)''. Nad ključem ''K'' koji se ubacuje u tabelu se primenjuju i funkcija ''h<sub>1</sub>(K)'' i ''h<sub>2</sub>(K)'', a kao ulaz se koristi rezultat funkcije za koju se dobije manje kolizija. U slučaju jednakog broja kolizija, koristi se funkcija ''h<sub>1</sub>(K)''. Potrebno je realizovati operacije umetanja i pretrage.

=== Rešenje ===
Prilikom umetanja tražimo prvu poziciju na kojoj je prazno mesto, prvo jednom a zatim i drugom heš funkcijom. Ako se desi da se vratimo na početnu poziciju, to znači da je tabela puna i ključ se ne može umetnuti.
{{Милокод|<nowiki>
INSERT(table, K)
adr1 = adr1_init = h1(K)
adr2 = adr2_init = h2(K)
repeat
if table[adr1] = empty then
table[adr1] = K
return
else
adr1 = (adr1 + g(K)) mod n
end_if
if table[adr2] = empty then
table[adr2] = K
return
else
adr2 = (adr2 + g(K)) mod n
end_if
until (adr1 = adr1_init) or (adr2 = adr2_init)
ERROR(Tabela je puna)
</nowiki>}}
Pretraga je slična umetanju, s tim što ako naiđemo na neprazno polje prvo proveravamo da li to polje sadrži traženi ključ i nastavljamo pretragu ako ne sadrži. Pretraga se takođe završava ako su obe pretrage došle do praznog polja.
{{Милокод|<nowiki>
SEARCH(table, K)
adr1 = adr1_init = h1(K)
adr2 = adr2_init = h2(K)
repeat
if table[adr1] = K then
return true
else if table[adr1] ≠ empty then
adr1 = (adr1 + g(K)) mod n
end_if
if table[adr2] = K then
return true
else if table[adr2] ≠ empty then
adr2 = (adr2 + g(K)) mod n
end_if
until (adr1 = adr1_init) or (adr2 = adr2_init) or ((table[adr1] = empty) and (table[adr2] = empty))
return false
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Data je sekvenca ključeva: 169, 84, 99, 6, 61, 84, 9, 96, 158, 42, 495, 46, 223. Prikazati rad ''shell sort'' algoritma po koracima. Navesti korišćenu sekvencu inkremenata i obrazložiti izbor.

=== Rešenje ===
Inkrementi su izabrani kao u [[АСП2/К3 2020#6. zadatak|rešenju šestog zadatka sa trećeg kolokvijuma 2020. godine]].
{| class="wikitable"
! Inkrement !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12
|-
! Početak
| 169 || 84 || 99 || 6 || 61 || 84 || 9 || 96 || 158 || 42 || 495 || 46 || 223
|-
! 7
| 96 || 84 || 42 || 6 || 46 || 84 || 9 || 169 || 158 || 99 || 495 || 61 || 223
|-
! 5
| 84 || 9 || 42 || 6 || 46 || 96 || 61 || 169 || 158 || 99 || 495 || 84 || 223
|-
! 3
| 6 || 9 || 42 || 61 || 46 || 96 || 84 || 169 || 84 || 99 || 495 || 158 || 223
|-
! 3
| 6 || 9 || 42 || 61 || 46 || 84 || 84 || 169 || 96 || 99 || 495 || 158 || 223
|-
! 2
| 6 || 9 || 42 || 61 || 46 || 84 || 84 || 99 || 96 || 158 || 223 || 169 || 495
|-
! 1
| 6 || 9 || 42 || 46 || 61 || 84 || 84 || 96 || 99 || 158 || 169 || 223 || 495
|}

== 4. zadatak ==
=== Postavka ===
Priloženi pseudokod prikazuje jednu varijantu ''bubble sort'' algoritma za sortiranje podataka. Objasniti glavne nedostatke priloženog algoritma i napisati u pseudokodu alternativnu implementaciju ovog algoritma koja te nedostatke ispravlja.
<pre>
for i:=1 to n-1 do
for j:=n-1 downto 1 do
if arr[j]>arr[j+1] then
b:=arr[j]; arr[j]:=arr[j+1]; arr[j+1]:=b;
end_if
end_for
end_for
</pre>

=== Rešenje ===
Kod ovog algoritma jeste najveći problem to što <code>n-1</code> puta radi iteraciju kroz niz, kada je to potrebno raditi samo dok se ne desi da nije bilo nijedne zamene u unutrašnjoj petlji. Drugi problem jeste nepotreban prolazak od kraja do početka niza, kada je prolazak od početka do kraja potencijalno efikasniji zbog keš memorije. Takođe, nije potrebno prolaziti kroz sortirani deo prilikom zamene elemenata.
{{Милокод|<nowiki>
BUBBLE SORT REVISITED(arr, n)
pos = n
repeat
granica = pos
broj_zamena = 0
for i = 1 to granica - 1 do
if arr[i] > arr[i+1] then
arr[i] ↔ arr[i+1]
granica = i
broj_zamena = broj_zamena + 1
end_if
end_for
until broj_zamena = 0
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije h<sub>p</sub>(K) = K mod 7. Za razrešavanje kolizija se koristi metoda dvostrukog heširanja sa sekundarnom heš funkcijom h<sub>s</sub>(K) = 4 + K mod 3. Odrediti prosečan broj pristupa prilikom neuspešnog traženja i verovatnoću popunjavanja praznih ulaza, pod pretpostavkom da su svi ključevi jednako verovatni.
{| class="wikitable"
|+ Tabela iz postavke zadatka
! 0
| 14
|-
! 1
|
|-
! 2
| 11
|-
! 3
| 24
|-
! 4
| 18
|-
! 5
|
|-
! 6
| 13
|}

=== Rešenje ===
{| class="wikitable"
|+ Ispitni nizovi
! 0 !! 1 !! 2
|-
| 0 || 0 || 0
|-
| 4 || 5 || 6
|-
| 1 || 3 || 5
|-
| 5 || 1 || 4
|-
| 2 || 6 || 3
|-
| 6 || 4 || 2
|-
| 3 || 2 || 1
|}
* Prosečan broj neuspešnih pristupa: <math>P_{nu} = 1 + \frac{5}{7} + \frac{5 \cdot 4}{7 \cdot 6} + \frac{5 \cdot 4 \cdot 3}{7 \cdot 6 \cdot 5} + \frac{5 \cdot 4 \cdot 3 \cdot 2}{7 \cdot 6 \cdot 5 \cdot 4} + \frac{5 \cdot 4 \cdot 3 \cdot 2 \cdot 1}{7 \cdot 6 \cdot 5 \cdot 4 \cdot 3} =</math>
*: <math>= 1 + \frac{5}{7} + \frac{10}{21} + \frac{2}{7} + \frac{1}{7} + \frac{1}{21} = \frac{8}{3} \approx 2.67</math>
* Verovatnoća popunjavanja:
** 1: <math>\frac{1}{3} \left(\frac{6}{7} + \frac{2}{7} + \frac{4}{7}\right) = \frac{4}{7}</math>
** 5: <math>\frac{1}{3} \left(\frac{1}{7} + \frac{5}{7} + \frac{3}{7}\right) = \frac{3}{7}</math>

== 6. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju za uklanjanje minimalnog ključa u binomnom hipu i njegovu naknadnu reorganizaciju. Nije potrebno sprovesti potencijalno spajanje stabala nakon uklanjanja čvora sa minimalnim ključem. Binomni hip predstavljen pomoću objekta klase BinHeap koja sadrži ulančanu listu objekata BinTree koji predstavljaju pojedinačna binomna stabla. Lista je uređena rastuće po stepenu stabla. Binomno stablo se sastoji od čvorova predstavljenih objektima klase BinNode. Funkcija kao argument prima objekat klase BinHeap. U nastavku je dat spisak metoda koje su na raspolaganju, njihove povratne vrednosti i klase objekata za koje ih treba pozvati.
{| class="wikitable"
! Metoda
! Povratna vrednost
! Objekat klase
|-
| ''getFirst''
| pokazivač na početak liste šume binomnih stabala
| ''BinHeap''
|-
| ''findMin''
| pokazivač na binomno stablo u čijem korenu je minimalni ključ
| ''BinHeap''
|-
| ''getOrder''
| red stabla
| ''BinTree''
|-
| ''setOrder''
| nema
| ''BinTree''
|-
| ''getRoot''
| pokazivač na koren binomnog stabla
| ''BinTree''
|-
| ''getNumOfChildren''
| broj potomaka čvora binomnog stabla
| ''BinNode''
|-
| ''getChildAtPos(index)''
| pokazivač na čvor koji je potomak objekta ''BinNode'' na poziciji index
| ''BinNode''
|}

=== Rešenje ===
Sledeće pretpostavke su usvojene pri implementaciji:
* <code>getFirst</code> vraća promenljivu referencu na lvrednost do početka ulančane liste, kako bismo mogli da ažuriramo taj početak
* <code>getChildAtPos</code> isto vraća promenljivu referencu na lvrednost. Ovo je kako bismo decu trenutnog čvora mogli da postavimo na nil, kako ne bi bila uništena prilikom dealokacije stabla (pretpostavljamo da postoji funkcija FREETREE koja to radi, slično FREENODE)
* Postoji funkcija GETTREE koja samo alocira stablo i kao koren postavlja svoj prvi argument
* Ulančana lista je jednostruko ulančana, pa naknadno moramo dohvatati elemente liste koje sadrže stablo sa minimalnim korenom nakon pozivanja <code>findMin</code>
* Ulančana lista u hipu sadrži polje ''next'' koje pokazuje do sledećeg čvora ulančane liste i polje ''value'' koje pokazuje na ''BinTree'' objekat, i sve operacije kao što su se koristile na ASP1 su podržane
{{Милокод|<nowiki>
REMOVE MIN KEY(binheap)
first_node = binheap.getFirst()
if first_node = nil then
return
end_if
min_tree = binheap.getMin()
prev_node = nil
curr_node = first_node
while value(curr_node) ≠ min_tree do
prev_node = curr_node
curr_node = next(curr_node)
end_while
next(prev_node) = next(curr_node)
root = min_tree.getRoot()
for i = 1 to root.getNumOfChildren() do
child = root.getChildAtPos(i)
tree = GETTREE(child)
tree.setOrder(child.getNumOfChildren())
INSERT_TREE(binheap, tree)
root.getChildAtPos(i) = nil
end_for
FREETREE(min_tree)
FREENODE(curr_node)
</nowiki>}}
{{Милокод|<nowiki>
INSERT TREE(binheap, bintree)
curr = binheap.getFirst()
prev = nil
while curr ≠ nil do
if value(curr).getOrder() ≥ bintree.getOrder() then
if prev = nil then
binheap.getFirst() = GETNODE
value(binheap.getFirst()) = bintree
next(binheap.getFirst()) = curr
else
next(prev) = GETNODE
value(next(prev)) = bintree
next(next(prev)) = curr
end_if
return
end_if
prev = curr
curr = next(curr)
end_while
next(prev) = GETNODE
value(next(prev)) = bintree
next(next(prev)) = nil
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 8 ulaza primenom heš funkcije po metodu deljenja. Za razrešavanje kolizija se koristi metoda slučajnog pretraživanja (c = 3). Prikazati proces razrešavanja kolizije i generisati ispitne nizove za ključeve 21 i 18. Objasniti da li kod ovog metoda u opštem slučaju dolazi do primarnog i sekundarnog grupisanja i zašto.

=== Rešenje ===
Pošto se koristi metoda slučajnog pretraživanja, moramo generisati slučajni niz za generisanje ispitnog niza:
011 = 3
*2 110 = 6
*2 1100
-8 100
⊕3 111 = 7
*2 1110
-8 110
⊕3 101 = 5
*2 1010
-8 010
⊕3 001 = 1
*2 010 = 2
*2 100 = 4
*2 1000
-8 000
⊕3 011 ...
{| class="wikitable"
|+ Ispitni nizovi za 21 i 18
! 21 !! 18
|-
| 5 || 2
|-
| 0 || 5
|-
| 3 || 0
|-
| 4 || 1
|-
| 2 || 7
|-
| 6 || 3
|-
| 7 || 4
|-
| 1 || 6
|}
Proces razrešavanja kolizije:
* 21 % 8 = 5
* Ako je ulaz 5 zauzet: (5 + 3) % 8 = 0
* Ako je ulaz 0 zauzet: (5 + 6) % 8 = 3
* itd.
U opštem slučaju neće doći do primarnog grupisanja jer je sekvenca ključeva u ispitnom nizu nasumična a ne linearna, ali će doći do sekundarnog grupisanja jer ispitni niz zavisi samo od matične adrese i rednog broja pokušaja.

== 8. zadatak ==
=== Postavka ===
Precizno objasniti kako se dolazi do složenosti algoritama za sortiranje a) kvadratnom selekcijom b) stablom selekcije i c) spajanjem. U kojem od ovih algoritama se razlikuju najbolji, srednji i najgori slučaj složenosti.

=== Rešenje ===

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К3 2017

2024-09-13T00:09:14Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
'''Treći kolokvijum 2017. godine''' održan je 20. januara. Postavka zadataka je dostupna sa [https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K3_1617.pdf stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Kako izgleda niz sa slike nakon prvih pet iteracija ''shakersort'' algoritma?

=== Rešenje ===
{| class="wikitable"
|+ Niz nakon pet iteracija ''shakersort'' algoritma
| 12 || 3 || 34 || 83 || 21 || 95 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39
|-
| 3 || 12 || 34 || 21 || 83 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39 || 95
|-
| 1 || 3 || 12 || 34 || 21 || 83 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 95
|-
| 1 || 3 || 12 || 21 || 34 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 34 || 18 || 20 || 39 || 83 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 18 || 20 || 34 || 39 || 44 || 83 || 83 || 95
|}

== 2. zadatak ==
=== Postavka ===
Data je heš tabela sa 10 ulaza. U tabelu se unose ključevi koje se mogu sastojati od velikih i malih slova. Primarna heš funkcija je ''H<sub>1</sub>(K) = (1 + len(K)) mod 10'', gde ''len(K)'' vraća broj slova u prosleđenom ključu ''K''. Vremenska lokalnost je veoma izražena, jer se nakon umetanja svakog ključa javlja veliki broj pretraživanja na taj ključ pre nego što se umetne sledeći. Kolizije se razrešavaju nestandardnom primenom dvostrukog heširanja kod koga je sekundarna funkcija ''H<sub>2</sub>(K) = 3 + up_case_cnt(K)'', gde ''up_case_cnt(K)'' vraća ukupan broj velikih slova u ključu ''K''.
<div class="abc-list">
# Predložiti modifikaciju načina za razrešavanje kolizije tako da se minimizuje vreme uspešnog pretraživanja u datim uslovima.
# Primenom predloženog rešenja u donju tabelu umetnuti sledeće ključeve:
#: ČoKoLaDa, PalAčINka, kafA, TORtA, RoLaT, SLadoled, koLAČ
#: Prikazati finalno stanje heš tabele i celokupan postupak primenom tehnike opisane u rešenju pod a).
</div>

=== Rešenje ===
<div class="abc-list">
# Prilikom razrešavanja kolizije, postojeće ključeve možemo pomeriti da budu niže u ispitnom nizu duplim heširanjem a novoumetnuti ključ staviti na njegov početak kako bi se sa što manjim brojem kolizija dolazilo do najskorije umetnutih ključeva.
# Umetanje u tabelu ide ovako:
## ČoKoLaDa se umeće na mesto 9
## PalAčINka se umeće na mesto 0
## kafA se umeće na mesto 5
## TORtA se umeće na mesto 6
## RoLaT se umeće na mesto 6, TORtA se pomera na mesto 3
## SLadoled se umeće na mesto 9, ČoKoLaDa se pomera na mesto 6, RoLaT se pomera na mesto 2
## koLAČ se umeće na mesto 6, ČoKoLaDa se pomera na mesto 3, TORtA se pomera na mesto 0, PalAčINka se pomera na mesto 7
</div>
{| class="wikitable"
|+ Konačni izgled heš tabele nakon umetanja
! 0
| TORtA
|-
! 1
|
|-
! 2
| RoLaT
|-
! 3
| ČoKoLaDa
|-
! 4
|
|-
! 5
| kafA
|-
! 6
| koLAČ
|-
! 7
| PalAčINka
|-
! 8
|
|-
! 9
| SLadoled
|}

== 3. zadatak ==
=== Postavka ===
Napisati iterativnu implementaciju ''quicksort'' algoritma. U telu funkcije QUICKSORT koja će predstavljati ovu implementaciju, nakon izbora pivota, pozivati funkciju PARTITION koja vraća konačnu poziciju pivota u nizu. Algoritam realizovati <u>što efikasnije</u>, a za pivot uzeti element niza koji je srednji po vrednosti u izboru između elemenata sa prve tri pozicije u particiji.

=== Rešenje ===
Pošto se pominje velika efikasnost, bitno je da na stek guramo veće particije a direktno obilazimo manje kako bi dubina steka bila što manja.
{{Милокод|<nowiki>
QUICKSORT(arr, n)
STACK_INIT(S_down)
STACK_INIT(S_up)
down = 1
up = n
from_stack = false
while (not STACK_EMPTY(S_down)) or (not from_stack) do
if from_stack then
down = POP(S_down)
up = POP(S_up)
end_if
if (up - down = 0) or (up - down = 1) then
if (up - down = 1) and (arr[up] < arr[down]) then
arr[up] ↔ arr[down]
end_if
from_stack = true
continue
end_if
first = arr[down]
second = arr[down+1]
third = arr[down+2]
if (first ≤ second ≤ third) or (third ≤ second ≤ first) then
pivot = 2
else if (second ≤ first ≤ third) or (third ≤ first ≤ second) then
pivot = 1
else
pivot = 3
end_if
pivot_pos = PARTITION(arr, down, up, pivot)
lower_down = down
lower_up = pivot_pos-1
higher_down = pivot_pos+1
higher_up = up
if (lower_up - lower_down < 1) and (higher_up - higher_down < 1) then
from_stack = true
else if lower_up - lower_down < higher_up - higher_down then
up = lower_up
down = lower_down
from_stack = false
PUSH(S_down, higher_down)
PUSH(S_up, higher_up)
else
up = higher_up
down = higher_down
from_stack = false
PUSH(S_down, lower_down)
PUSH(S_up, lower_up)
end_if
end_while
</nowiki>}}
Pošto je rečeno da se izbor pivota radi u QUICKSORT, pretpostavićemo da se taj pivot zatim prosleđuje PARTITION kao parametar.
{{Милокод|<nowiki>
PARTITION(arr, down, up, pivot_pos)
i = down
j = up
pivot = arr[pivot_pos]
while i < j do
while (arr[i] ≤ pivot) and (i < j) do
i = i + 1
end_while
while arr[j] > pivot do
j = j - 1
end_while
if i < j then
if j == pivot_pos then
pivot_pos = i
end_if
arr[i] ↔ arr[j]
end_while
end_while
arr[pivot_pos] ↔ arr[j]
return j
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju za dekrementiranje ključa koji se nalazi u binarnom nerastućem (max) hipu. Smatrati da je hip smešten u nizu čiji indeksi počinju od 0. Funkcija kao svoj parametar dobija indeks ključa u nizu koga treba dekrementirati.

=== Rešenje ===
{{Милокод|<nowiki>
HEAP KEY DEC(i)
arr[i] = arr[i]-1
left = 2 * i + 1
right = 2 * i + 2
while ((left ≤ n) and (arr[left] > arr[i])) or ((right ≤ n) and (arr[right] > arr[i])) do
if right ≤ n then
if arr[right] > arr[left] then
high = right
else
high = left
end_if
else
high = left
end_if
arr[i] ↔ arr[high]
i = high
left = 2 * i + 1
right = 2 * i + 2
end_while
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije h<sub>p</sub>(K) = K mod 7. Za razrešavanje kolizija se koristi metoda dvostrukog heširanja sa sekundarnom heš funkcijom h<sub>s</sub>(K) = 4 + K mod 2. Obrazložiti na koji način u ovom slučaju može doći do sekundarnog grupisanja i navesti sekvencu od tri ključa koja proizvodi ovaj efekat u konkretnom slučaju. Navedene ključeve uneti u tabelu.

=== Rešenje ===
U ovom slučaju može doći do sekundarnog grupisanja kada uneti ključevi daju isti ostatak pri deljenju sa 7 i pri deljenju sa 2. Takvi su recimo ključevi 0, 14 i 28.
{| class="wikitable"
|+ Tabela sa unetim ključevima
! 0
| 0
|-
! 1
|
|-
! 2
|
|-
! 3
|
|-
! 4
| 14
|-
! 5
|
|-
! 6
|
|-
! 7
|
|-
! 8
| 28
|}

== 6. zadatak ==
=== Postavka ===
Fibonačijev hip
<div class="abc-list">
# Koja je razlika između dodavanja u binomni hip i Fibonačijev hip? Objasniti kratko i precizno, u jednoj do dve rečenice.
# U prazan Fibonačijev hip dodaju se elementi 10, 5, 17, 3, 12, 11, 1, potom se briše element sa vrednošću 1, nakon čega se dodaju elementi 7 i 2. Nacrtati izgled hipa nakon prvih sedam umetanja i nakon svake naredne izmene hipa.
</div>

=== Rešenje ===
<div class="abc-list">
# Pri dodavanju u Fibonačijev hip uneti čvor se samo ulančava, a grupisanje slično binomnom hipu se dešava tek kod izbacivanja najmanjeg elementa.
# Ispod su dati izgledi hipa nakon date četiri operacije.
</div>
<gallery class="transparent-svg">
ASP2 K3 2017 zadatak 6 hip umetanje 1.svg | Izgled hipa nakon umetanja 10, 5, 17, 3, 12, 11, 1.
ASP2 K3 2017 zadatak 6 hip brisanje.svg | Izgled hipa nakon brisanja 1.
ASP2 K3 2017 zadatak 6 hip umetanje 2.svg | Izgled hipa nakon umetanja 7.
ASP2 K3 2017 zadatak 6 hip umetanje 3.svg | Izgled hipa nakon umetanja 2.
</gallery>

== 7. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa ''n'' ulaza primenom heš funkcije h(K) = K mod n. Za razrešavanje kolizija se koristi metoda kvadratnog pretraživanja, ali nije dozvoljeno koristiti operaciju množenja (kvadriranja). Predložiti metod brisanja i napisati pseudokodove operacija brisanja i umetanja.

=== Rešenje ===
Možemo primetiti da <math>2^2 - 1^2 = 3, 3^2 - 2^2 = 5, 4^2 - 3^2 = 7, ...</math> što znači da umesto kvadriranja možemo da radimo samo sabiranje sa sledećim neparnim brojem.
{{Милокод|<nowiki>
DELETE(H, key)
i = init = H(key)
step = 3
while (T[i] ≠ key) and (T[i] ≠ empty) do
if (step ≠ 3) and (i = init) then
return
end_if
i = i + step
step = step + 2
end_while
if T[i] ≠ empty then
T[i] = deleted
end_if
</nowiki>}}
{{Милокод|<nowiki>
INSERT(H, key)
i = init = H(key)
step = 3
while (T[i] ≠ empty) and (T[i] ≠ deleted) do
if (step ≠ 3) and (i = init) then
ERROR(Tabela puna)
end_if
i = i + step
step = step + 2
end_while
T[i] = key
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Objasniti kako se može modelirati ponašanje algoritama sortiranja poređenjem. Za dati model izvesti teorijsku granicu složenosti u najgorem slučaju.

=== Rešenje ===
Ponašanje algoritma se može modelirati stablom odlučivanja. Svako odlučivanje se modeluje unutrašnjim čvorom a svaki ishod listom, tako da složenost u najgorem slučaju dobijamo kao visinu tog stabla. Pošto je broj ishoda ovakvog stabla odlučivanja jednak <math>n!</math>, a najveći broj listova u stablu visine <math>h</math> jednak <math>2^h</math>, možemo da izjednačimo <math>n! = 2^h</math>. Kad logaritmujemo obe strane jednačine i primenimo Stirlingovu aproksimaciju (<math>n! > \left(\frac{n}{e}\right)^n</math>) dobijamo <math>h = \log(n!) > n \log\left(\frac{n}{e}\right) > n \log n - n \log e = O(n \log n)</math>.

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К2 2019

2024-09-13T00:09:13Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K2_1920.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Izomorfizam crveno-crnih i 2-3-4 stabala.
<div class="abc-list">
# Dato binarno crveno-crno stablo transformisati u izomorfno 2-3-4 stablo. Osenčeni čvorovi su crni.
# Iz stabla dobijenog pod a) brišu se ključevi 63 i 60. Nacrtati stabla dobijena nakon svakog od ova dva brisanja.
# Ako se stablo dobijeno pod a) posmatra kao obično B stablo reda 4, da li bi bilo razlike u konačnom izgledu stabla nakon brisanja ključeva 63 i 60? Ukratko objasniti.
</div>

=== Rešenje ===
Ekvivalentno izomorfno 2-3-4 stablo je:
[57|74| ]
/ | \
[21|43| ] [60|63| ] [88|91|94]
Pri izbacivanju ključa 63, ključ 60 dolazi na njegovo mesto (i postaje crn).
[57|74| ]
/ | \
[21|43| ] [ |60| ] [88|91|94]
Pri izbacivanju ključa 60, vrši se pozajmljivanje od pravog brata, koji je ovde levi brat u izomorfnom 2-3-4 stablu, pa ključ 43 postaje razdelni a ključ 57 silazi u čvor iz kojeg se briše.
[43|74| ]
/ | \
[ |21| ] [ |57| ] [88|91|94]
Ekvivalentna crveno-crna stabla su data ispod.

Da je stablo bilo obično B stablo reda 4, u drugom koraku bi se pozajmljivalo od desnog brata umesto od levog brata, jer B stabla nemaju pravilo da se prvo pozajmljuje od pravog brata. Takođe, ključevi 21 i 57 ne bi stajali u središnjem polju čvora, već najlevljem.
<gallery class="transparent-svg">
ASP2 K2 2019 zadatak 1 stablo.svg | Originalno crveno-crno stablo
ASP2 K2 2019 zadatak 1 korak 1.svg | Crveno-crno stablo nakon brisanja čvora 63
ASP2 K2 2019 zadatak 1 korak 2.svg | Crveno-crno stablo nakon brisanja čvora 60
</gallery>

== 2. zadatak ==
=== Postavka ===
U B+ stablo sa slike redom se umeću ključevi 6, 25, 21 i 27, nakon čega se uklanjaju ključevi 33, 27 i 6. Prikazati ažuriranje stabla po koracima.
[33|64| ]
/ | \
[20|22|33]->[42|64| ]->[71|81| ]

=== Rešenje ===
* Red stabla: <math>m = 4</math>
* Minimalni broj ključeva u unutrašnjim čvorovima: <math>\left\lceil\frac{m}{2}\right\rceil-1 = 1</math>
* Minimalni broj ključeva u listovima: <math>\left\lfloor\frac{m}{2}\right\rfloor = 2</math>
Ključ 6 se umeće levo od čvora 20. Dolazi do preloma i 6 i 20 ostaju u čvoru, 20 ide u roditelja, a 22 i 33 se odvajaju u novi čvor.
(20|33|64)
/ | | \
[ 6|20| ]->[22|33| ]->[42|64| ]->[71|81| ]
Ključ 25 se umeće između ključeva 22 i 33.
(20|33|64)
/ | | \
[ 6|20| ]->[22|25|33]->[42|64| ]->[71|81| ]
Ključ 21 se umeće levo od ključa 22. Dolazi do preloma, 21 i 22 ostaju u čvoru, 22 ide u roditeljski čvor, a 25 i 33 se odvajaju u novi čvor. Pošto u roditelju nema mesta, i on se prelama tako da koren postaje čvor sa 22, levi čvor sa 20 i desni sa 33 i 64.
(22| | )
/ \
(20| | ) (33|64| )
/ | / | \
[ 6|20| ]->[21|22| ]->[25|33| ]->[42|64| ]->[71|81| ]
Ključ 27 se umeće između ključeva 25 i 33.
(22| | )
/ \
(20| | ) (33|64| )
/ | / | \
[ 6|20| ]->[21|22| ]->[25|27|33]->[42|64| ]->[71|81| ]
Pri uklanjanju ključa 33, pošto je najveći ključ u čvoru, mora se ažurirati roditeljski čvor tako da 33 u roditeljskom čvoru postaje 27.
(22| | )
/ \
(20| | ) (27|64| )
/ | / | \
[ 6|20| ]->[21|22| ]->[25|27| ]->[42|64| ]->[71|81| ]
Pri uklanjanju ključa 27, ostaje manje nego dovoljno ključeva u tom čvoru. Pozajmica od oba brata nije moguća, i zato se taj čvor spaja sa svojim desnim bratom. U tom procesu se takođe izbacuje ključ iz roditeljskog čvora.
(22| | )
/ \
(20| | ) (64| | )
/ | / |
[ 6|20| ]->[21|22| ]->[25|42|64]->[71|81| ]
Pri uklanjanju ključa 6, ostaje manje nego dovoljno ključeva u tom čvoru. Pozajmica od brata nije moguća, i zato se taj čvor spaja sa svojim desnim bratom. U tom procesu roditeljski čvor ostaje prazan, tako da se spajaju svi unutrašnji čvorovi u jedan, čime se dobija konačno stablo:
(22|64| )
/ | \
[20|21|22]->[25|42|64]->[71|81| ]

== 3. zadatak ==
=== Postavka ===
Dato digitalno stablo je potrebno transformisati u kompaktniju formu kako bi se smanjila veličina stabla.
<div class="abc-list">
# Predložiti i objasniti način na koji se može ostvariti transformacija digitalnog stabla u kompaktniju formu i prikazati izgled digitalnog stabla nakon opisane transformacije.
# Implementirati funkciju <u>TRIE COMPACTION</u> koja transformiše stablo na prethodno opisani način. Pokazivač na koren stabla ''root'' je prosleđen funkciji. Smatrati da je digitalno stablo predstavljeno po principu levi sin - desni brat.
</div>
A
/ | \
B C S
| | |
K J 4
/ \ | |
D T M 6
| | | |
9 * * A
| |
3 *
|
*

=== Rešenje ===
Kompaktnija forma ovog stabla može se dobiti tako što sve čvorove koji imaju samo jednu putanju do listova zamenimo sa listovima koji sadrže pokazivače na zapise na koje su listovi prethodno pokazivali i celu vrednost ključa. U tom slučaju ne mora da postoji čvor za kraj ključa.

{{Милокод|<nowiki>
TRIE COMPACTION(root)
if root ≠ nil then
compacted_root = COMPACT(root, "")
if compacted_root ≠ nil then
root = compacted_root
end_if
end_if
</nowiki>}}
{{Милокод|<nowiki>
COMPACT(node, str)
if key(node) = '*' then
FREENODE(node)
return str
end_if
compacted_child = COMPACT(left(node), str + key(node))
if right(node) = nil then
FREENODE(node)
return compacted_child
else
COMPACT(right(node), str)
if compacted_child ≠ nil then
left(node) = compacted_child
end_if
return nil
end_if
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju koja iz '<nowiki />''top-down''' stabla ''m''-arnog pretraživanja na čiji koren pokazuje pokazivač ''root'' briše zadati ključ key.

=== Rešenje ===
{{Милокод|<nowiki>
DELETE(root, m, key)
parent = nil
parent_index = 0
p = root
i = 0
found = false
while (p ≠ nil) and (not found) do
for i = 1 to num(p) do
if keys(p)[i] = key then
found = true
break
else if keys(p)[i] > key then
parent = p
parent_index = i
p = pointers(p)[i-1]
break
end_if
end_for
if i = num(p) + 1 then
p = pointers(p)[i-1]
end_if
end_while
if p = nil then
ERROR(Ključ nije pronađen)
end_if
q = pointers(p)[i]
if q ≠ nil then
prev = p
while q ≠ nil do
parent = prev
parent_index = 1
prev = q
q = pointers(q)[0]
end_while
keys(p)[i] = key(prev)
p = prev
i = 1
end_if
for j = i to num(p) do
keys(node)[i-1] = keys(node)[i]
end_for
num(p) = num(p) - 1
if num(p) = 0 then
FREENODE(p)
pointers(parent)[parent_index-1] = nil
end_if
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
U B* stablo reda 5 sa slike se umeću ključevi 18, 23, 7, 37, 19. Nakon toga se redom brišu ključevi 80, 55, 18, 9 i 15. Nacrtati izgled stabla nakon svake izmene.
[15|24|41|80]
/ / | \ \
[ 2| 9|10| ] [16|20|21| ] [27|33|40| ] [55|75| | ] [93|96| | ]

=== Rešenje ===
* Red stabla: <math>m = 5</math>
* Minimalan broj ključeva u ne-korenskim čvorovima: <math>\left\lceil\frac{2m - 1}{3}\right\rceil-1 = 3 - 1 = 2</math>
* Maksimalan broj ključeva u korenu: <math>2\left\lfloor\frac{2m - 2}{3}\right\rfloor = 4</math>
* Raspodela ključeva pri prelomu: 2-3-3
Ključ 18 umećemo između ključeva 16 i 20.
[15|24|41|80]
/ / | \ \
[ 2| 9|10| ] [16|18|20|21] [27|33|40| ] [55|75| | ] [93|96| | ]
Ključ 23 umećemo desno od ključa 21. Dešava se prelivanje u desni čvor, 23 završava u roditelju a 24 u desnom čvoru.
[15|23|41|80]
/ / | \ \
[ 2| 9|10| ] [16|18|20|21] [24|27|33|40] [55|75| | ] [93|96| | ]
Ključ 7 umećemo između ključeva 2 i 9.
[15|23|41|80]
/ / | \ \
[ 2| 7| 9|10] [16|18|20|21] [24|27|33|40] [55|75| | ] [93|96| | ]
Ključ 37 umećemo između ključeva 33 i 40. Dešava se prelivanje u desni čvor, 40 završava u roditelju a 41 u desnom čvoru.
[15|23|40|80]
/ / | \ \
[ 2| 7| 9|10] [16|18|20|21] [24|27|33|37] [41|55|75| ] [93|96| | ]
Ključ 19 umećemo između ključeva 18 i 20. Prelivanje u levog i desnog brata je nemoguće, pa se dešava prelom. Ključevi 16 i 18 ostaju u čvoru, 19 ide u roditeljski čvor, 20, 21 i 23 idu u novi čvor, 24 ide u roditeljski čvor i 27, 33 i 37 ostaju u desnom bratu. Prelom se dešava i u roditeljskom čvoru, tako da 15 i 19 idu u levo dete novog korena, 24 ide u novi koren a 40 i 80 idu u desno dete novog korena.
[24| | | ]
/ \
[15|19| | ] [40|80| | ]
/ | \ / | \
[ 2| 7| 9|10] [16|18| | ] [20|21|23| ] [27|33|37| ] [41|55|75| ] [93|96| | ]
Ključ 80 menjamo svojim sledbenikom, 93, pa ga brišemo iz lista. U listu ostaje nedovoljno mnogo ključeva, pa vršimo pozajmicu od levog brata. Tom prilikom se ključ 93 vraća nazad u list u kojem je bio a 75 dolazi na mesto gde je ranije bio ključ 80.
[24| | | ]
/ \
[15|19| | ] [40|75| | ]
/ | \ / | \
[ 2| 7| 9|10] [16|18| | ] [20|21|23| ] [27|33|37| ] [41|55| | ] [93|96| | ]
Pri brisanju ključa 55 iz lista ostaje nedovoljno ključeva, pa pozajmljujemo od levog brata. Tom prilikom ključ 37 dolazi na mesto 40 u roditeljskom čvoru a 40 se spušta u list.
[24| | | ]
/ \
[15|19| | ] [37|75| | ]
/ | \ / | \
[ 2| 7| 9|10] [16|18| | ] [20|21|23| ] [27|33| | ] [40|41| | ] [93|96| | ]
Pri brisanju ključa 18 iz lista ostaje nedovoljno ključeva, pa pozajmljujemo od desnog brata. Tom prilikom ključ 20 ide u roditeljski čvor a ključ 19 se spušta u list.
[24| | | ]
/ \
[15|20| | ] [37|75| | ]
/ | \ / | \
[ 2| 7| 9|10] [16|19| | ] [21|23| | ] [27|33| | ] [40|41| | ] [93|96| | ]
Brišemo ključ 9 iz lista.
[24| | | ]
/ \
[15|20| | ] [37|75| | ]
/ | \ / | \
[ 2| 7|10| ] [16|19| | ] [21|23| | ] [27|33| | ] [40|41| | ] [93|96| | ]
Ključ 15 menjamo svojim sledbenikom, 16, pa brišemo ključ iz lista. U tom listu ostaje nedovoljno mnogo ključeva, pa se pozajmljuje od levog brata tako što se ključ 16 vrati na svoje prethodno mesto a ključ 10 ode u roditeljski čvor.
[24| | | ]
/ \
[10|20| | ] [37|75| | ]
/ | \ / | \
[ 2| 7| | ] [16|19| | ] [21|23| | ] [27|33| | ] [40|41| | ] [93|96| | ]

== 6. zadatak ==
=== Postavka ===
Posmatra se baza podataka studenata.
<div class="abc-list">
# Ukoliko se zna da je najčešći upit nad zadatom bazom dohvatanje svih studenata koji su fakultet upisali u zadatom periodu (između dve godine), predložiti strukturu podataka koja bi podržala efikasno izvršavanje ovakvog upita i detaljno opisati razloge.
# Implementirati funkciju FIND_STUDENTS_IN_RANGE koja nad odabranom strukturom vrši pretragu i vraća rezultat upita navedenog pod tačkom a). Parametri funkcije su pokazivač na odabranu strukturu, početna godina i krajnja godina traženog perioda, respektivno. Rezultat vratiti u formi niza.
</div>

=== Rešenje ===
Struktura koja se ovde može upotrebiti je B+ stablo, jer nam dozvoljava lak sekvencijalni pristup (za izlistavanje svih studenata u rasponu od dve godine) kao i brzo pronalaženje prvog ključa (za prvog studenta iz raspona). Ključevi ovakvog stabla mogu biti kombinacija godine i broja indeksa studenta, tako da je godina primarni a broj indeksa sekundarni ključ.

{{Милокод|<nowiki>
FIND STUDENTS IN RANGE(structure, year1, year2)
p = structure
while (not IS_LEAF(p)) do
for i = 1 to num(p) do
if keys(p)[i] > year1 then
p = pointers(p)[i-1]
break
end_if
end_for
if i = num(p)+1 then
p = pointers(p)[num(p)]
end_if
end_while
length = 0
q = p
key_index = 1
while (q ≠ nil) and (years(q)[key_index] ≤ year2) do
length = length + 1
if node_index = num(q) then
key_index = 1
q = next(q)
else
key_index = key_index + 1
end_if
end_while
arr = ALLOCATE(length)
for i = 1 to length do
j = 1
while j < num(p) and i < length do
arr[i] = students(p)[j]
i = i + 1
j = j + 1
end_while
p = next(p)
end_for
return arr
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Neka se za indeksnu strukturu datoteke koristi B stablo reda ''m''. U okviru datoteke se smeštaju zapisi veličine 256 bitova zajedno sa 32-bitnim poljem ključa. Neka se na datom sistemu adrese predstavljaju na 64 bita. Odrediti vrednosti ''m'' u zavisnosti od toga da li se u čvoru B stabla smešta samo ključ ili čitav podataka, pod pretpostavkom da je veličina bloka na disku 2KB. Diskutovati rešenje.

=== Rešenje ===
Jedan čvor B stabla mora stati u jedan blok na disku, što je 2KiB, odnosno 2048B, odnosno 16384b. Zapis čvora obuhvata:
* <math>m-1</math> ključeva (32b) zajedno sa adresama njihovih zapisa (64b), odnosno u drugoj varijanti ceo zapis (256b)
* <math>m</math> adresa (64b) podstabala
Tako je veličina jednog čvora stabla u prvoj varijanti jednaka <math>(m-1) \cdot (32 + 64) + m \cdot 64 = m \cdot 96 + m \cdot 64 - 96 = m \cdot 160 - 96</math>. Ako pretpostavimo da je ovo jednako veličini bloka, dobijamo <math>m \cdot 160 = 16480 \implies m = \frac{16480}{160} = 103</math>.

U drugoj varijanti, ako pretpostavimo da se ključ može zaključiti iz strukture pa se ne čuva odvojeno, veličina čvora je jednaka <math>(m-1) \cdot 256 + m \cdot 64 = m \cdot 256 - 256 + m \cdot 64 = m \cdot 320 - 256</math>. Sa istom pretpostavkom dobijamo <math>m \cdot 320 = 16640 \implies m = \frac{16640}{320} = 52</math>.

== 8. zadatak ==
=== Postavka ===
Heširanje.
<div class="abc-list">
# Kako funkcioniše metod deljenja i koje su njegove osnovne osobine? Koje vrednosti delioca treba izbegavati?
# Neka je dat skup ključeva 19, 10, 4, 37, 49, 52. Ukoliko je poznatao da se prilikom heširanja koristi metod deljenja i veličina tabele ''n'' = 9, komentarisati izbor veličine tabele u odnosu na verovatnoću mogućih kolizija zadatog skupa ključeva. Predložiti alternativnu, blisku veličinu tabele kako bi se verovatnoća kolizija smanjila.
</div>

=== Rešenje ===
Metod deljenja funkcioniše tako što heš funkcija ima oblik <math>h(K) = K mod n</math>, gde je <math>n</math> broj ulaza tabele. Loši brojevi <math>n</math> su parni brojevi, brojevi deljivi s 10 i, ako su svi ključevi kongurentni po modulu <math>d</math>, brojevi koji nisu uzajamno prosti sa <math>d</math>.

Za dati skup ključeva dobijamo sledeću tabelu:
{| class="wikitable"
|+ Heš tabela nakon umetanja datog skupa ključeva
|-
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8
|-
|
|
* 19
* 10
* 37
|
|
|
* 4
* 49
|
|
| 52
|
|}
Ovde se kolizija desila u 50% slučajeva. Predlažemo malo izmenjen broj ulaza <math>n = 8</math>:
{| class="wikitable"
|+ Heš tabela nakon umetanja datog skupa ključeva s predloženom heš funkcijom
|-
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7
|-
|
| 49
| 10
| 19
|
* 4
* 52
| 37
|
|
|}
Ovde se kolizija dešava u 16.66% slučajeva.

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К2 2018

2024-09-13T00:09:13Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K2_1819.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
U 2-3-4 stablo sa slike ubaciti ključeve 17 i 25 i prikazati ekvivalentno crveno-crno stablo.
[ |23|45]
/ | \
[ 1|15|20] [28|36| ] [ |72| ]

=== Rešenje ===
[[Датотека:ASP2 K2 2018 zadatak 1 stablo.svg|thumb|Ekvivalentno crveno-crno stablo u rešenju 1. zadatka.]]
Ključ 17 dolazi između ključeva 15 i 20. Pošto je taj čvor pun, crni ključ 15 ide u roditeljski čvor, ključ 1 dolazi u sredinu i postaje crn, ključ 20 se odvaja u desni čvor i postaje crn a ključ 17 završava kao crveni ključ levo od ključa 20.
[15|23|45]
/ | \
[ | 1| ] [17|20| ] [28|36| ] [ |72| ]
Ključ 25 dolazi levo od ključa 28.
[15|23|45]
/ | | \
[ | 1| ] [17|20| ] [25|28|36] [ |72| ]

== 2. zadatak ==
=== Postavka ===
B+-stabla
<div class="abc-list">
# Prikazati maksimalno popunjeno B+-stablo reda ''m'' = 3 i visine ''h'' = 1. Odrediti za ovo stablo prosečan broj pristupa prilikom uspešne i neuspešne pretrage.
# Posmatra se B+-stablo reda 4 koje sadrži 7 ključeva. Odrediti za ovo stablo srednji broj pristupa prilikom uspešne i neuspešne pretrage i obrazložiti odgovor.
</div>

=== Rešenje ===
(2|4)
/ | \
[1|2]->[3|4]->[5|6]
2 je prosečan broj pristupa i pri uspešnoj i pri neuspešnoj pretrazi.
(3|5| )
/ | \
[1|2|3]->[4|5| ]->[6|7| ]
Pretpostavljajući da se ovde radi o broju ključeva u listovima (pošto se ključevi iz unutrašnjih čvorova dupliciraju u listovima), prosečan broj pristupa je ponovo 2. Sve uspešne pretrage, kao i neuspešne, moraju završiti u listovima jer se samo u listovima nalaze pokazivači ka traženim strukturama, a visina ovako napravljenog stabla je 1.

== 3. zadatak ==
=== Postavka ===
Posmatra se ''trie'' stablo čiji su ključevi znakovni nizovi koji sadrže cifre u brojnom sistemu sa osnovom 10. Napisati u pseudokodu funkciju koja za dato stablo na čiji koren pokazuje pokazivač ''root'' računa razliku najvećeg i najmanjeg tako predstavljenog broja.

=== Rešenje ===
{{Милокод|<nowiki>
CALC(root)
if root = nil then
return 0
end_if
min, max = CALC_R(root)
return max - min
</nowiki>}}
{{Милокод|<nowiki>
CALC R(root)
min = +∞
max = -∞
for i = 0 to 9 do
field = fields(root)[i]
if field ≠ nil then
if is_leaf(field) then
f_max = f_min = value(field)
else
f_max, f_min = CALC_R(field)
end_if
if f_max > max then
max = f_max
end_if
if f_min < min then
min = f_min
end_if
end_if
end_for
return max, min
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Posmatra se B stablo reda m u kojem su svi listovi minimalno popunjeni, a njihovi roditelji su popunjeni iznad minimuma. Iz takvog stabla se briše ključ key iz lista sa adresom node. Napisati iterativnu funkciju u pseudokodu za datu situaciju brisanja. Smatrati da u čvoru postoji pokazivač na roditelja i podatak o broju ključeva smeštenih u njemu.

=== Rešenje ===
{{Милокод|<nowiki>
B-DELETE-NO-BORROW(root, m, node, key)
child_index = 0
parent = parent(node)
for i = 0 to num(parent) do
if pointers(parent)[i] = node then
child_index = i
break
end_if
end_for
if child_index = num(parent) then
left_node = pointers(parent)[child_index-1]
num(left_node) = num(left_node) + 1
keys(left_node)[num(left_node)] = keys(parent)[child_index]
for i = 1 to num(node) do
if keys(node)[i] ≠ key then
num(left_node) = num(left_node) + 1
keys(left_node)[num(left_node)] = keys(node)[i]
end_if
end_for
FREENODE(node)
else
right_node = pointers(parent)[child_index+1]
offset = 0
for i = 1 to num(node) do
if keys(node)[i] = key then
offset = 1
else
keys(node)[i-offset] = keys(node)[i]
end_if
end_for
keys(node)[num(node)] = keys(parent)[child_index+1]
for i = 1 to num(right_node) do
num(node) = num(node) + 1
keys(node)[num(node)] = keys(right_node)[i]
end_for
for i = child_index to num(parent)-1 do
keys(parent)[i+1] = keys(parent)[i+2]
pointers(parent)[i] = pointers(parent)[i+1]
end_for
FREENODE(right_node)
end_if
num(parent) = num(parent) - 1
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
U B* stablo reda 4 se umeću ključevi od 1 do 14. Nakon toga se redom brišu ključevi 4, 11 i 9. Nacrtati izgled stabla nakon svake izmene.

=== Rešenje ===
* Red stabla: <math>m = 4</math>
* Minimalni broj ključeva u ne-korenskom čvoru: <math>\left\lceil\frac{2m - 1}{3}\right\rceil - 1 = 2</math>
* Maksimalni broj ključeva u korenu: <math>2 \left\lfloor\frac{2m - 2}{3}\right\rfloor = 4</math>
* Raspodela ključeva pri prelomu: 2-2-2
Umećemo ključ 1 u prazno stablo.
[ 1| | | ]
Umećemo ključ 2.
[ 1| 2| | ]
Umećemo ključ 3.
[ 1| 2| 3| ]
Umećemo ključ 4.
[ 1| 2| 3| 4]
Pri umetanju ključa 5 dolazi do prelamanja čvora, tako da ključevi 1 i 2 idu u levi a 4 i 5 u desni čvor.
[ 3| | | ]
| |
[ 1| 2| ] [ 4| 5| ]
Umećemo ključ 6.
[ 3| | | ]
| |
[ 1| 2| ] [ 4| 5| 6]
Pri umetanju ključa 7 desni čvor se prepunjuje, pa se dešava prelivanje u levi čvor. Ključ 3 iz roditeljskog čvora silazi u levi a ključ 4 iz desnog ide u roditeljski.
[ 4| | | ]
| |
[ 1| 2| 3] [ 5| 6| 7]
Pri umetanju ključa 8 desni čvor se ponovo prepunjuje, pa se dešava prelamanje. Ključevi 1 i 2 ostaju u levom čvoru, ključ 3 ide u roditeljski čvor, 4 i 5 dolaze u novi, srednji čvor, 6 ide u roditeljski čvor a 7 i 8 ostaju u desnom čvoru.
[ 3| 6| | ]
/ | \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| ]
Umećemo ključ 9.
[ 3| 6| | ]
/ | \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| 9]
Pri umetanju ključa 10 dešava se prelivanje iz desnog u srednji čvor.
[ 3| 7| | ]
/ | \
[ 1| 2| ] [ 4| 5| 6] [ 8| 9|10]
Pri umetanju ključa 11 dešava se prelamanje.
[ 3| 6| 9| ]
/ | \ \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| ] [10|11| ]
Umećemo ključ 12.
[ 3| 6| 9| ]
/ | \ \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| ] [10|11|12]
Pri umetanju ključa 13 dešava se prelivanje.
[ 3| 6|10| ]
/ | \ \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| 9] [11|12|13]
Pri umetanju ključa 14 dešava se prelamanje.
[ 3| 6| 9|12]
/ / | \ \
[ 1| 2| ] [ 4| 5| ] [ 7| 8| ] [10|11| ] [13|14| ]
Pri brisanju ključa 4, zbog nemogućnosti pozajmice, spajanje tri čvora u dva.
[ 5| 9| 12 |]
/ / | \
[ 1| 2| 3 ] [ 6| 7| 8 ] [ 10|11| ] [13|14| ]
Pri brisanju ključa 11 moguća je pozajmica, ali od levog brata.
[ 5| 8| 12 |]
/ / | \
[ 1| 2| 3 ] [ 6| 7|] [ 9 |10| ] [13|14| ]
Pri brisanju ključa 9 moguća je pozajmica ali od brata sa udaljenošću dva.
[ 3| 7| 12 |]
/ / | \
[ 1| 2| ] [ 5| 6| ] [ 8 |10| ] [13|14| ]

== 6. zadatak ==
=== Postavka ===
Dato je digitalno stablo formirano od nekog skupa ključeva tipa znakovnih nizova. Implementirati funkciju COUNT_KEYS koja pronalazi broj ključeva u stablu koji odgovaraju zadatom formatu znakovnog niza. Pokazivač na koren stabla i zadati format su prosleđeni kao parametri funkcije. Format znakovnog niza pored cifara i slova može sadržati i simbole koji imaju specijano značenje. Specijalni simboli su tačka (.) koja menja bilo koji znak niza i zvezda (*) koja predstavlja ponavljanje nekog znaka niza 0 ili više puta. Smatrati da se zvezda odnosi na prvi znak koji joj prethodi.

Primer:

skup ključeva u stablu: abccc4a, ab3a, aacda

format: abc*.a

rezultat: 2

=== Rešenje ===
{{Милокод|<nowiki>
COUNT KEYS(root, format)
len = STRING_LENGTH(format)
if len = 0 then
if key(node) = EOK then
return 1
else
return 0
end_if
end_if
count = 0
for i = 1 to num(root) do
node = pointers(root)[i]
if (len > 1) and (format[2] = '*') then
if (key(node) = format[1]) or (format[1] = '.') then
count = count + COUNT_KEYS(node, format)
end_if
else if (key(node) = format[1]) or (format[1] = '.') then
count = count + COUNT_KEYS(node, format + 1)
end_if
end_for
if (len > 1) and (format[2] = '*') then
count = count + COUNT_KEYS(root, format + 2)
end_if
return count
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Neka se u ''top-down'' stablo ''m''-arnog pretraživanja redom ubacuju ključevi ''k'', 2''k'', 3''k'', …, ''nk'', ''nk'' – 1, ''nk'' – 2, ''nk'' – 3, …, ''n''(''k'' – 1) +1. Nacrtati izgled stabla i odrediti visinu. Pretpostaviti da su ''n'' i ''k'' mnogo veći od ''m''.

=== Rešenje ===
Nakon ubacivanja ključa ''nk'' dobiće se degenerisano stablo udesno, tj. jedino najdesniji pokazivači u svakom unutrašnjem čvoru će pokazivati na sledeći list, i većina ključeva će biti popunjena, tako da će visina stabla biti <math>\left\lceil\frac{n}{m - 1}\right\rceil</math> a u listu će ostati <math>(m - 1) - (n \bmod (m - 1))</math> slobodnih mesta. Nakon ubacivanja svih ključeva stablo će u listovima krenuti da raste ulevo iz listova, tako da će visina porasti na ukupno: <math>h = \left\lceil\frac{n}{m - 1}\right\rceil + \left\lceil\frac{n - 1 - (m - 1) + (n \bmod (m - 1))}{m - 1}\right\rceil</math>.

== 8. zadatak ==
=== Postavka ===
Heširanje.
<div class="abc-list">
# Šta je minimalna savršena heš funkcija?
# Za ključeve 54, 91, 57, 23 i 28 naći što jednostavniju minimalnu savršenu heš funkciju i ispisati je. Obrazložiti odgovor i nacrtati heš tabelu sa umetnutim ključevima.
</div>

=== Rešenje ===
<div class="abc-list">
# Minimalna savršena heš funkcija je heš funkcija koja preslikava ''n'' ključeva u ''n'' ulaza tabele bez kolizije.
# Jedna moguća savršena heš funkcija je <math>h(K) = \left\lfloor\frac{K}{2}\right\rfloor \mod 5</math>. Kad sortiramo ključeve, dobijamo redosled 23, 28, 54, 57. Možemo primetiti da su oni svi različiti po modulu 10, ali pošto tabela ima 5 ulaza možemo prvo podeliti ključeve sa dva pa uzeti vrednost po modulu 5. Tabela nakon primene ove heš funkcije je data ispod.
</div>
{| class="wikitable"
|+ Tabela nakon primene heš funkcije
! 0 !! 1 !! 2 !! 3 !! 4
|-
| 91 || 23 || 54 || 57 || 28
|}

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К2 2017

2024-09-13T00:09:12Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K2_1718.pdf Postavka zadataka na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
U trie stablo umetnuti ključeve 35, 128, 1236, 1234 i 125, a zatim obrisati ključ 1234. Prikazati izgled stabla nakon poslednjeg umetanja i nakon brisanja. Izračunati prosečan broj pristupa pri uspešnoj pretrazi.

=== Rešenje ===
Ispod su data trie stabla nakon umetanja i nakon brisanja. Broj pristupa pri pretraživanju na ključ 35 je 3, pri pretraživanju na 128 i 125 je 4 a pri pretraživanju na 1236 je 5, tako da je prosečan broj pristupa pri uspešnom pretraživanju <math>\frac{3 + 4 + 4 + 5}{4} = 4</math>.
<gallery>
ASP2 K2 2017 zadatak 1 stablo umetanje.svg | Trie stablo dobijeno nakon umetanja.
ASP2 K2 2017 zadatak 1 stablo brisanje.svg | Trie stablo dobijeno nakon brisanja.
</gallery>

== 2. zadatak ==
=== Postavka ===
Neka se uz ključeve B stabla reda ''m'' čuva i broj pristupa podatku pridruženom tom čvoru. Ključevi čijim podacima se češće pristupa treba da se nađu što bliže korenu stabla. Objasniti kako bi trebalo modifikovati strukturu i operacije pretraživanja i brisanja da bi se to realizovalo.

=== Rešenje ===

== 3. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju za umetanje ključa u B+ stablo reda ''m'' na čiji koren ukazuje pokazivač ''root''. Pretpostaviti da otac lista u koji se vrši umetanje nije maksimalno popunjen. Smatrati da je struktura čvora fiksna i da čvor sadrži alociran prostor za maksimalan broj ključeva i pokazivača. Dodatno, svaki čvor sadrži pokazivač na oca i podatak o broju ključeva smeštenih u njemu.

=== Rešenje ===
Prvo pronalazimo list u koji umećemo, čuvajući indeks našeg podstabla u roditeljskom čvoru (<code>parent_index</code>) i bacajući grešku ukoliko naiđemo na postojeći ključ s istom vrednošću. Zatim formiramo stablo ukoliko roditeljski čvor ne postoji ili formiramo novi poredak ključeva u čvoru u pomoćnom nizu (<code>arr</code>) sa dovoljno alociranog mesta. Ako se radi o umetanju u pun čvor, u starom čvoru ostavljamo pola ključeva, alociramo novi čvor u koji ubacujemo drugo pola ključeva a najveći ključ ubacujemo u roditeljski čvor i ažuriramo pokazivače i ulančanu listu.
{{Милокод|<nowiki>
B PLUS INSERT(root, m, key)
new_key_index = ceil(m/2) + 1
p = root
prev = nil
while p ≠ nil do
for i = 1 to num(p) do
if keys(p)[i] = key then
ERROR(Key already inserted)
else if keys(p)[i] > key then
prev = p
p = pointers(p)[i-1]
parent_index = i-1
end_if
end_for
if i = num(p)+1 then
prev = p
p = pointers(p)[i-1]
parent_index = i-1
end_if
end_while
if prev = nil then
root = GETNODE
num(root) = 1
keys(root)[1] = key
else
inserted = false
for i = 1 to m do
if ((i = m) or (keys(prev)[i] = nil) or (keys(prev)[i] > key)) and (not inserted) then
inserted = true
arr[i] = key
end_if
end_for
if num(prev) = m-1 then
for i = 1 to new_key_index-1 do
keys(prev)[i] = arr[i]
end_for
new_node = GETNODE
num(new_node) = m + 1 - new_key_index
num(prev) = new_key_index-1
for i = new_key_index to m do
keys(new_node)[i-new_key_index+1] = arr[i]
end_for
for i = num(parent(prev)) downto parent_index do
pointers(parent(prev))[i+1] = pointers(parent(prev))[i]
keys(parent(parent))[i] = keys(parent(parent))[i-1]
end_for
keys(parent(prev))[parent_index+1] = keys(prev)[num(prev)]
pointers(parent(prev))[parent_index+1] = new_node
next(new_node) = next(prev)
next(prev) = new_node
else
for i = 1 to num(prev)+1 do
keys(prev)[i] = arr[i]
end_for
num(prev) = num(prev)+1
end_if
end_if
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Na primeru B* stabla reda 5 sa slike, prikazati i objasniti situaciju brisanja ključa kada dolazi do spajanja čvorova po sistemu „3-u-2“.
[13|54|78| ]
/ / \ \
[6 |9 | | ] [27|37| | ] [57|60|65| ] [80|85|90| ]

=== Rešenje ===
Iz datog primera nije moguće odmah izvršiti brisanje tako da se spoje čvorovi, tako da prvo brišemo ključ 9. Dešava se pozajmica od drugog desnog brata, tako da 13 silazi u čvor iz kojeg je izbačeno, 27 ide u koren, 54 silazi u čvor iz kojeg je izašlo 27 a 57 ide u koren.
[27|57|78| ]
/ / \ \
[6 |13| | ] [37|54| | ] [60|65| | ] [80|85|90| ]
Zatim izbacujemo ključ 13. Dešava se spajanje tako što tretiramo 6, 27, 37, 54, 57, 60, 65 kao sortiran niz, njegov srednji ključ šaljemo u koren, njegovu levu polovinu u levo dete a desnu u desno dete tog srednjeg ključa.
[54|78| | ]
/ / \
[6 |27|37| ] [57|60|65| ] [80|85|90| ]

== 5. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju koja crveno-crno stablo, dato pokazivačem na koren ''root'', pretvara u 2-3-4 stablo i vraća pokazivač na njegov koren. Čvor crveno-crnog stabla sadrži informaciju o boji.

=== Rešenje ===
Odvajamo na slučajeve 2-čvora, 3-čvora i 4-čvora i rekurzivno transformišemo čvorove crveno-crnog stabla.
{{Милокод|<nowiki>
TRANSFORM(root)
if root = nil then
return nil
end_if
new_node = GETNODE
if (left(root) ≠ nil) and (red(left(root))) and (right(root) ≠ nil) and (red(right(root))) then
keys(new_node)[1] = key(left(root))
keys(new_node)[2] = key(root)
keys(new_node)[3] = key(right(root))
pointers(new_node)[0] = TRANSFORM(left(left(root)))
pointers(new_node)[1] = TRANSFORM(right(left(root)))
pointers(new_node)[2] = TRANSFORM(left(right(root)))
pointers(new_node)[3] = TRANSFORM(right(right(root)))
else if (left(root) ≠ nil) and (red(left(root))) then
keys(new_node)[1] = key(left(root))
keys(new_node)[2] = key(root)
pointers(new_node)[0] = TRANSFORM(left(left(root)))
pointers(new_node)[1] = TRANSFORM(right(left(root)))
pointers(new_node)[2] = TRANSFORM(right(root))
else if (right(root) ≠ nil) and (red(right(root))) then
keys(new_node)[2] = key(root)
keys(new_node)[3] = key(right(root))
pointers(new_node)[1] = TRANSFORM(left(root))
pointers(new_node)[2] = TRANSFORM(left(right(root)))
pointers(new_node)[3] = TRANSFORM(right(right(root)))
else
keys(new_node)[2] = key(root)
pointers(new_node)[1] = TRANSFORM(left(root))
pointers(new_node)[2] = TRANSFORM(right(root))
end_if
return new_node
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
U digitalnom stablu implementiranom po principu levi sin – desni brat smeštaju se ključevi sa alfa-numeričkim vrednostima. Implemetirati funkciju za uklanjanje svih ključeva koji počinju prefiksom koji je prosleđen kao parametar funkcije. Vrednosti znakova koji predstavljaju „braću“ u stablu uređene su rastuće prema leksikografskom poretku.

=== Rešenje ===
Odvajamo rešenje na tri rekurzivne funkcije, traženu, funkciju za silazak niz stablo do čvora sa traženim prefiksom i funkciju za brisanje svih čvorova u podstablu.
{{Милокод|<nowiki>
DELETE KEYS(prefix)
TRAVERSE(prefix, root, nil)
</nowiki>}}
Funkcija za silazak niz stablo kao treći i četvrti argument prima pokazivače na bratski i/ili roditeljski čvor u kojima je potrebno ažurirati pokazivače na čvor koji se izbacuje.
{{Милокод|<nowiki>
TRAVERSE(prefix, root, parent, sibling)
if root = nil then
return
end_if
len = STRING_LENGTH(prefix)
if (len = 1) and (prefix[0] = value(root)) then
if parent ≠ nil then
left(parent) = right(root)
end_if
if sibling ≠ nil then
right(sibling) = right(root)
end_if
DELETE(left(root))
FREENODE(root)
else if (len > 1) and (prefix[0] = value(root)) then
TRAVERSE(prefix+1, left(root), root, nil)
else
TRAVERSE(prefix, right(root), nil, root)
end_if
</nowiki>}}
{{Милокод|<nowiki>
DELETE(root)
if root ≠ nil then
DELETE(left(root))
DELETE(right(root))
FREENODE(root)
end_if
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Neka ''top-down'' stablo ''m''-arnog pretraživanja ima ''n'' ključeva:
<div class="abc-list">
# Izvesti i objasniti izraze za maksimalnu i minimalnu visinu ovog stabla.
# Koliko najmanje i koliko najviše čvorova može imati ovo stablo. Objasniti.
</div>

=== Rešenje ===
<div class="abc-list">
# Maksimalna visina ovakvog stabla se dobija kada napravimo degenerisano stablo umetanjem sortiranog niza ključeva u njega. Tom prilikom će svaki čvor biti popunjen sa ''m-1'' ključeva (osim možda čvora na poslednjem nivou) i na svakom nivou će biti po jedan čvor, čime se dobija visina <math>h = \left\lceil\frac{n}{m-1}\right\rceil</math>. Minimalna visina se dobija u skoro-kompletnom stablu. Na svakom nivou takvog stabla nalazi se <math>m^h</math> čvorova, tako da za stablo visine <math>h</math> imamo da je ukupan broj čvorova <math>m^0 + m^1 + m^2 + ... + m^h = \frac{m^{h+1} - 1}{m-1} = \left\lceil\frac{n}{m-1}\right\rceil</math>, iz čega dobijamo <math>h = \left\lceil\log_m\left(n + 1\right)\right\rceil - 1</math>.
# Broj ključeva potrebnih da bi se napravilo <math>m</math> čvorova je <math>2m-2</math>, tako što napunimo jedan čvor a zatim u njegovu decu stavimo po još jedan ključ (ne računajući jedan ključ koji iskoristimo da formiramo koren), tako da je najveći broj čvorova za fiksirano <math>n</math> jednako <math>m \cdot \frac{n-1}{2m-2}</math>. S druge strane, najmanji broj čvorova dobijamo kada popunimo svaki čvor do maksimuma, što je jednako maksimalnoj visini ovakvog stabla.
</div>

== 8. zadatak ==
=== Postavka ===
<div class="abc-list">
# Neka je dat neki celobrojni ključ ''key''. Interpretirati ga kao broj u dekadnom sistemu, a zatim napisati heš funkciju H(''key'') koja po metodu konverzije osnove hešira ključ u tabelu T od 100 ulaza.
# Ako ''n'' ključeva iz niza ''K'' treba da se mapira u heš tabelu gornjom funkcijom, napisati funkciju koja izračunava broj klasa ekvivalencije.
</div>

=== Rešenje ===
Za osnovu u koju konvertujemo biramo 13, jer je uzajamno prosto sa 10.
{{Милокод|<nowiki>
H(key)
q = 13
p = key
num = 0
exp = 1
while p > 0 do
num = num + (p % 10) * exp
p = p / 10
exp = exp * 13
end_while
return num % 100
</nowiki>}}
{{Милокод|<nowiki>
EQUIV CLASS(K, n)
for i = 0 to 99 do
arr[i] = false
end_for
num_classes = 0
for i = 1 to n do
k = H(K[i])
if (not arr[k]) then
num_classes = num_classes + 1
end_if
arr[k] = true
end_for
return num_classes
</nowiki>}}

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К2 2016

2024-09-13T00:09:11Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K2_1617.pdf Postavka zadataka na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
U digitalno stablo umetnuti ključeve 25, 23, 367, 3698, 3692, 4, a zatim obrisati ključeve 367 i 23. Koristiti reprezentaciju „najlevlji sin – desni brat“. Prikazati stablo nakon poslednjeg umetanja i brisanja.

=== Rešenje ===
Ispod su data stabla nakon poslednjeg umetanja i brisanja.
<gallery>
ASP2 K2 2016 zadatak 1 stablo umetanje.svg | Stablo nakon poslednjeg umetanja.
ASP2 K2 2016 zadatak 1 stablo brisanje.svg | Stablo nakon poslednjeg brisanja.
</gallery>

== 2. zadatak ==
=== Postavka ===
Izomorfizam crveno-crnih stabala i 2-3-4 stabala.
<div class="abc-list">
# Na koji način se vrši umetanje u pun čvor 2-3-4 stabla da bi se očuvao izomorfizam sa crveno crnim stablima? Da li postoje razlike u odnosu na klasično B stablo?
# U 2-3-4 stablo sa slike umetnuti ključeve 30 i 35. Nacrtati izgled stabla posle svake od izmena i označiti crvene i crne čvorove.
</div>
[25|44|58]
/ | | \
[ |15| ] [27|37| ] [ |47|50] [ |60| ]

=== Rešenje ===
Pri umetanju u pun čvor 2-3-4 stabla dešava se prelom. Razlika je u tome da crni ključ uvek ide u koren a trenutni čvor se razdvaja na dva čvora, u levom čvoru kao crni ključ dolazi levi crveni ključ prethodnog čvora, u desnom kao crni ključ dolazi desni crveni ključ prethodnog čvora a novoumetnuti ključ postaje crven u levom ili desnom čvoru u zavisnosti od toga da li je manji ili već od crnog ključa iz prethodnog čvora.

Ključ 30 umećemo u list i tom prilikom se ključ 37 pomera kao crveni.
[25|44|58]
/ | | \
[ |15| ] [27|30|37] [ |47|50] [ |60| ]
Ključ 35 umećemo u taj isti list i tom prilikom se dešava prelom, 27 postaje crni ključ levog čvora, 37 postaje crni ključ desnog čvora, ključ 30 ide u koren a ključ 35 postaje levi crveni ključ desnog čvora. Prelom se dešava i u korenu, tako da 25 postaje crni ključ levog čvora, 58 postaje crni ključ desnog čvora, 44 ide u novi koren a 30 postaje desni crveni ključ levog čvora.
[ |44| ]
/ \
[ |25|30] [ |58| ]
/ | \ | |
[ |15| ] [ |27| ] [35|37| ] [ |47|50] [ |60| ]
Bojenje ovde neće biti odrađeno, ali crni ključevi su 15, 27, 25, 44, 58, 47 i 60, a svi ostali su crveni.

== 3. zadatak ==
=== Postavka ===
Dato je B stablo reda ''m''. Napisati u pseudokodu funkciju koja vrši pozajmicu ključeva prilikom brisanja. Ukoliko je pozajmica nemoguća, funkcija treba da signalizira grešku. Funkcija dobija pokazivač na čvor ''node'' za koji se pokušava pozajmica. Smatrati da svaki čvor sadrži pokazivač na oca i podatak o broju ključeva smeštenih u njemu.

=== Rešenje ===
Prvo proveravamo da li pozajmljujemo u čvoru koji se nalazi u praznom stablu ili u čvoru koji je koren i u tom slučaju signaliziramo grešku. Ukoliko se u čvoru nalazi dovoljan broj ključeva, pozajmica je nepotrebna pa samo izlazimo iz funkcije. Zatim, nalazimo koji je indeks trenutnog čvora u nizu pokazivača na decu njegovog roditelja i na osnovu toga pronalazimo njegovu braću, prvo desnog pa levog. Ako braća ne postoje ili nemaju dovoljno čvorova signaliziramo grešku, u suprotnom premeštamo ključeve i prevezujemo pokazivače.
{{Милокод|<nowiki>
B-DEL-BORROW(node)
min_nodes = ceil(m/2)-1
if (node = nil) or (parent(node) = nil) then
ERROR(Borrow impossible)
end_if
if (num(node) ≥ min_nodes) then
return
end_if
parent = parent(node)
for i = 0 to num(parent) do
if pointers(parent)[i] = node then
parent_index = i
break
end_if
end_for
if (parent_index < num(parent)) and (num(pointers(parent)[parent_index+1]) > min_nodes) then
sibling = pointers(parent)[parent_index+1]
keys(node)[num(node)+1] = keys(parent)[parent_index+1]
keys(parent)[parent_index+1] = keys(sibling)[1]
num(node) = num(node)+1
num(sibling) = num(sibling)-1
pointers(node)[num(node)] = pointers(sibling)[0]
for i = 0 to num(sibling) do
pointers(sibling)[i] = pointers(sibling)[i+1]
if i < num(sibling) then
keys(sibling)[i+1] = keys(sibling)[i+2]
end_if
end_for
else if (parent_index > 0) and (num(pointers(parent)[parent_index-1]) > min_nodes) then
sibling = pointers(parent)[parent_index-1]
for i = num(node) downto 0 do
pointers(node)[i+1] = pointers(node)[i]
if i < num(node) then
keys(node)[i+2] = keys(node)[i+1]
end_if
end_for
keys(node)[1] = keys(parent)[parent_index]
keys(parent)[parent_index] = keys(sibling)[num(sibling)]
pointers(node)[0] = pointers(sibling)[num(sibling)]
num(node) = num(node)+1
num(sibling) = num(sibling)-1
else
ERROR(Borrow impossible)
end_if
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
[[Датотека:ASP2 K2 2016 zadatak 4 graf.svg|thumb|Graf iz postavke 4. zadatka.]]
Neka se zbog uštede memorije za smeštanje ključeva koji imaju zajedničke sufikse umesto digitalnog stabla koristi usmereni aciklični graf, kao na slici. Objasniti na koji način bi se implementirale operacije pretraživanja i brisanja ključa.

=== Rešenje ===
Pretraživanje ključa se implementira isto kao i kod digitalnog stabla ako se za implementaciju grafa koristi lista susednosti. Brisanje ključa se vrši tako što prilikom pretraživanja pamtimo poslednji čvor sa izlaznim stepenom većim od 1 (kraj zajedničkog prefiksa) i prvi čvor sa ulaznim stepenom većim od 1 (početak zajedničkog sufiksa) i brišemo sve čvorove između ta dva. Ako ovaj drugi čvor ne postoji, brišemo sve od prvog do kraja ključa (sufiks je jedinstven) a ako ovaj prvi čvor ne postoji brišemo celo stablo (prefiks je jedinstven, što znači da postoji samo jedna reč u stablu).

== 5. zadatak ==
=== Postavka ===
Neki sistem datoteka koristi B+ stabla za indeksiranje datoteka unutar kataloga. Veličina čvora B+ stabla je 256b, a pokazivači zauzimaju 16b. Za smeštanje ključa B+ stabla koristi se 64b.
<div class="abc-list">
# Za date parametre, odrediti maksimalni red stabla.
# Neka se posmatra katalog u kojem već postoje datoteke, sa ključevima 6, 12, 18, 45, 58, 66, 73, 81. Pod pretpostavkom da su svi listovi popunjeni minimalnim brojem ključeva, nacrtati inicijalni izgled B+ stabla za indeksiranje takvog kataloga. Nakon toga, u katalog se dodaju datoteke sa ključevima 41, 53, 32, a potom se brišu datoteke sa ključevima 12 i 66. Nacrtati izgled stabla posle svakog umetanja i brisanja. Red stabla je određen vrednošću koja je izračunata u tački a).
</div>

=== Rešenje ===
Maksimalni red stabla je <math>m = 4</math>. Raspored memorije u čvoru dat je ispod.
{| class="wikitable"
|+ Raspored memorije u čvoru B+ stabla.
| 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b || 16b
|-
| <math>p_0</math>
| colspan="4" | <math>k_1</math>
| <math>p_1</math>
| colspan="4" | <math>k_2</math>
| <math>p_2</math>
| colspan="4" | <math>k_3</math>
| <math>p_3</math>
|}
Pošto je minimalan broj ključeva u listu B+ stabla jednak <math>\left\lfloor\frac{m}{2}\right\rfloor = \left\lfloor\frac{4}{2}\right\rfloor = 2</math>, inicijalni izgled zadatog B+ stabla je:
(12|45|66)
/ | | \
[6 |12| ]->[18|45| ]->[58|66| ]->[73|81| ]
Ključ 41 se dodaje u list:
(12|45|66)
/ | | \
[6 |12| ]->[18|41|45]->[58|66| ]->[73|81| ]
Ključ 53 se isto dodaje u list:
(12|45|66)
/ | | \
[6 |12| ]->[18|41|45]->[53|58|66]->[73|81| ]
Pri dodavanju ključa 32 dešava se prelom u listu, koji se razdvaja na listove sa 18 i 32 i sa 41 i 45, a ključ 32 odlazi u koren. Pošto je i koren pun, dešava se prelom i 12 ostaje u levom čvoru, 32 odlazi u novi koren a 45 i 66 idu u desni čvor.
(32| | )
/ \
(12| | ) (45|66| )
| \ / | \
[6 |12| ]->[18|32| ]->[41|45| ]->[53|58|66]->[73|81| ]
Pri brisanju ključa 12 pozajmica je nemoguća, pa se spajaju dva lista i na sledećem nivou se dešava pozajmica od desnog brata, čime se pozajmljuje ključ 45.
(45| | )
/ \
(32| | ) (66| | )
| \ | \
[6 |18|32]->[41|45| ]->[53|58|66]->[73|81| ]
Ključ 66 se briše iz lista i tom prilikom se ažurira roditeljski čvor.
(45| | )
/ \
(32| | ) (58| | )
| \ | \
[6 |18|32]->[41|45| ]->[53|58| ]->[73|81| ]

== 6. zadatak ==
=== Postavka ===
Napisati u pseudokodu iterativnu implementaciju funkcije koja formira ''trie'' stablo svih podstringova stringa koji je prosledjen<sup>[sic]</sup> kao argument toj funkciji. Data je pomoćna funkcija ''getPosition(chr)'', koja za prosledjeni<sup>[sic]</sup> karakter ''chr'' vraća indeks odgovarajućeg pokazivača u čvoru ''trie'' stabla.

=== Rešenje ===
{{Милокод|<nowiki>
TRIE SUBSTRINGS(str)
root = GETNODE
for i = 1 to length(str) do
node = root
substr = ""
for j = i to length(str) do
substr = substr + str[j]
pos = getPosition(str[j])
if nodes(node)[pos] = nil then
nodes(node)[pos] = GETNODE
end_if
node = nodes(node)[pos]
value(node) = substr
end_for
end_for
return root
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Neka su ključevi neuniformne dužine i neka se oni u čvoru stabla ''m''-arnog pretraživanja pakuju bez gubitka prostora.
<div class="abc-list">
# Predložiti efikasnu organizaciju čvora koja dozvoljava najbrže pretraživanje ovakvog čvora.
# Precizno nacrtati organizaciju čvora za stablo reda 6 koji trenutno sadrži ključeve IPSILON, DELTA, IKS, ALFA.
</div>

=== Rešenje ===
U čvor možemo dodati polje od m-2 celobrojnih vrednosti koje nam govore od koje memorijske lokacije počinje koji ključ. Na taj način, kad vidimo da se neki pretraživani ključ ne poklapa sa vrednošću u trenutnom polju, umesto da nastavimo da čitamo vrednost do sledećeg ključa možemo odmah da nađemo početak sledećeg ključa.
{| class="wikitable"
|+ Organizacija čvora
| colspan="7" |
| 4 || 9 || 12 || 12 || 12
| colspan="7" |
|-
| A || L || F || A || D || E || L || T || A || I || K || S || I || P || S || I || L || O || N
|}

== 8. zadatak ==
=== Postavka ===
Heširanje:
<div class="abc-list">
# Analitički definisati osobinu uniformnosti heš funkcije u tabeli veličine ''n'' ulaza i objasniti je jednom rečenicom.
# Ako je heš funkcija uniformna i ako je u tabeli sa ''n'' ulaza uneseno ''k'' ključeva, izvesti izraz koji predstavlja očekivani broj kolizija koje su se desile prilikom tih umetanja.
</div>

=== Rešenje ===
<div class="abc-list">
# Uniformnost heš funkcije je osobina koja znači da je svaki od <math>n</math> izlaza podjednako verovatan: <math>P(H(K)) = \frac{1}{n}, 1 \leq H(K) \leq n</math>
# Zamislimo da ključeve umećemo u tabelu jedan po jedan. Pošto je naša heš funkcija uniformna, prvih <math>n</math> umetanja nećemo imati nijednu koliziju. Narednih <math>n</math> umetanja ćemo imati jednu koliziju po umetanju, sledećih <math>n</math> dve kolizije, i tako dalje. Ukupan broj puta koliko će se povećanje broja kolizija po ključu desiti jeste <math>m = \left\lfloor\frac{k}{n}\right\rfloor</math>, i on će na kraju biti povećan na <math>m</math>. To znači da će ukupan očekivani broj kolizija biti <math>n \cdot (0 + 1 + 2 + ... + m-1) + m \cdot (k \mod n) = n \cdot \frac{(m-1)(m-2)}{2} + m \cdot (k \mod n)</math>. Drugi deo jednačine ima veze sa time što kada umetnemo <math>m \cdot n</math> ključeva naš broj kolizija će biti jednak <math>m</math>, ali će nama i dalje ostati <math>k - m \cdot n</math>, odnosno <math>k \mod n</math> ključeva koji nisu umetnuti (pri računanju <math>m</math> smo zaokružili na manji broj) i na njima će broj kolizija biti <math>m</math>.
</div>

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К1П 2012

2024-09-13T00:09:10Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
'''Popravni prvi kolokvijum 2012. godine''' održan je 9. januara 2012. Postavka zadataka je dostupna sa [https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/arhiva/SI2AS2_K1p_1112.pdf stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
'''(30p)''' Predložiti adekvatnu strukturu podataka i detaljno navesti uslove njene upotrebe, a zatim skicirati algoritam za efikasnu pretragu na više celobrojnih ključeva nad neopadajuće uređenom tabelom. Smatrati da u tabeli ne postoje duplirani ključevi niti da se više puta vrši pretraga nad istim ključem.
=== Rešenje ===
Pretraživanje ide od početka niza K sa prvim ključem iz S dok se ne pronađe (i njegova pozicija zapamti u P) ili do prve veće vrednosti. Pretraživanje na sledeći ključ iz S počinje tamo gde se sa pretraživanjem na prethodni ključ stalo, pa se zato niz K prolazi samo jednom. Niz K je rastuće uređeni niz sa n ključeva koji se pretražuje na pojavu m ključeva zadatih u nizu S. Izlaz predstavlja vektor P gde se na poziciji koja odgovara ključu u nizu S nalazi pozicija ključa u nizu K, ako se on tamo pronađe, ili vrednost 0 ako se ne pronađe. Složenost ovog algoritma je O(n) za slučaj kada je m << n.
{{Милокод|<nowiki>
SEQ-SEARCH-MUL(K,S)
for(int i=0;i<m;i++) P[i] = 0;
i=j=1;
while(i<=n) and (j<=m)
while(i<n) and (S[j] > K[i]) i++;
if(S[j] = K[i]) P[j] = i;
j++;
end_while
return P;
</nowiki>}}
== 2. zadatak ==
=== Postavka ===
'''(20p)''' U AVL stablo se redom umeću sledeći celobrojni ključevi: 13, 32, 14, 28, 15, 35, 44, 47, 22, 30, 24, 19, 20, a zatim se brišu ključevi 15, 30, 28, 24. Nacrtati izgled stabla nakon svake od navedenih izmena. Izračunati prosečan broj pristupa stablu za uspešnu pretragu nakon svih umetanja i u konačnom stanju.
=== Rešenje ===
Ukoliko želite da zadatak proverite korak po korak, to možete uraditi na [https://www.cs.usfca.edu/~galles/visualization/AVLtree.html linku.]
[[Датотека:ASP2 K1 2011p Zadatak 2 umetanje.svg|thumb|600px|center|Stablo nakon svih umetanja]]
[[Датотека:ASP2 K1 2011p Zadatak 2 brisanje.svg|thumb|600px|center|Stablo nakon svih brisanja]]
Nakon svih umetanja: <math>S_{n} = \frac{5 + 5\cdot4 + 4\cdot3 + 2\cdot2 + 1}{13} = \frac{42}{13} = 3.23</math>

Nakon svih brisanja: <math>S_{n} = \frac{2\cdot4 + 4\cdot3 + 2\cdot2 + 1}{9} = \frac{25}{9} = 2.78</math>
== 3. zadatak ==
=== Postavka ===
'''(20p)''' Dati pseudokod i objasniti algoritam za određivanje sledbenika proizvoljno zadatog čvora u stablu binarnog pretraživanja.
=== Rešenje ===
Ukoliko čvor ima desnog sina, onda je njegov sledbenik najlevlji čvor u desnom podstablu, a ako nema, onda je njegov sledbenik najbliži predak čiji je levi sin takođe predak zadatog čvora.
{{Милокод|<nowiki>
BST-SUCC(k)
if(right(k) != nil)
p = right(k);
while(left(p) != nil) p = left(p);
return p;
end_if
p = parent(k), s = k;
while(p != nil and right(p) = s)
s = p;
p = parent(p);
end_while
return s;
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
'''(30p)''' Pitanja:
<div class="abc-list">
# Objasniti kako i zašto metod transpozije optimizuje sekvencijalno pretraživanje.
# Ako se stablo binarnog pretraživanja koristi kao prioritetni red, objasniti kako izgedaju operacije PQ_INSERT i PQ_MIN_DELETE. Kolika je vremenska složenost ovih operacija?
# Precizno definisati optimalno stablo binarnog pretraživanja.
</div>
=== Rešenje ===
<div class="abc-list">
# Metod transpozicije optimizuje sekvencijalno pretraživanje tako što svaki put kada se traženi element nađe, on zameni mesto sa elementom levo od sebe i tako se priblližava početku niza. Time se obezbeđuje da su oni elementi kojima se češće pristupa bliže početku, pa pošto se sekvencijalno pristupa, i samo vreme pristupa tim elementima je skraćeno.
# <ref>Ovo više nije gradivo K1</ref>
# Optimalno stablo binarnog pretraživanja je ono stablo čija je cena najmanja, gde cenu definišemo kao: <math>C = \sum_{i}^{m-n} p_{i}(h_{i} + 1) + \sum_{i}^{m-n} q_{i}h_{i}</math>, gde su Pi verovatnoće pristupa ključevima Kn...Km, a Qi verovatnoće pristupa eksternim čvorovima. Osobina na kojoj se zasniva algoritam za nalaženje optimalnog stabla binarnog pretraživanja je da su sva podstabla optimalnog stabla pretraživanja takođe optimalna.
</div>

== Napomene ==
<references/>


[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП2/К1 2020

2024-09-13T00:09:10Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_2021.pdf Zadaci na stranici predmeta.]

'''Prvi kolokvijum 2020. godine''' održan je 3. novembra 2020.

== 1. zadatak ==
=== Postavka ===
'''(10p)''' Posmatra se tabela celobrojnih ključeva data na slici. Prikazati izgled tabele u svakom
koraku prilikom pretrage na skup ključeva {25, 40, 25, 40} metodom transpozicije kao i
metodom prebacivanja na početak i u oba slučaja izračunati prosečan broj poređenja
prilikom pretraživanja.

{| class="wikitable"
|+ Stanje niza iz postavke zadatka
! 12
! 7
! 3
! 27
! 25
! 78
! 98
! 21
! 22
! 40
! 51
|}
=== Rešenje ===
'''Transpozicija:'''
{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 25
! 12
! 7
! 3
! 25
! 27
! 78
! 98
! 21
! 22
! 40
! 51
|}

Broj poređenja u ovom koraku - 5

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 40
! 12
! 7
! 3
! 25
! 27
! 78
! 98
! 21
! 40
! 22
! 51
|}

Broj poređenja u ovom koraku - 10

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 25
! 12
! 7
! 25
! 3
! 27
! 78
! 98
! 21
! 40
! 22
! 51
|}

Broj poređenja u ovom koraku - 4

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 40
! 12
! 7
! 25
! 3
! 27
! 78
! 98
! 40
! 21
! 22
! 51
|}

Broj poređenja u ovom koraku - 9

Prosečan broj poređenja: <math>\frac{5+10+4+9}{4} = \frac{28}{4} = 7</math>

'''Prebacivanje na početak:'''
{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 25
! 25
! 12
! 7
! 3
! 27
! 78
! 98
! 21
! 22
! 40
! 51
|}

Broj poređenja u ovom koraku - 5

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 40
! 40
! 25
! 12
! 7
! 3
! 27
! 78
! 98
! 21
! 22
! 51
|}

Broj poređenja u ovom koraku - 10

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 25
! 25
! 40
! 12
! 7
! 3
! 27
! 78
! 98
! 21
! 22
! 51
|}

Broj poređenja u ovom koraku - 2

{| class="wikitable"
|+ Stanje niza nakon pretrage na ključ 40
! 40
! 25
! 12
! 7
! 3
! 27
! 78
! 98
! 21
! 22
! 51
|}

Broj poređenja u ovom koraku - 2

Prosečan broj poređenja: <math>\frac{5+10+2+2}{4} = \frac{19}{4} = 4.75</math>

== 2. zadatak ==
=== Postavka ===
'''(10p)''' Ukratko objasniti i ilustrovati primerima slučajeve pronalaženja čvora prethodnika po
inorder poretku za zadati čvor u stablu binarnog pretraživanja.
=== Rešenje ===
Ukoliko čvor ima levo podstablo, njegov prethodnik je najdešnji potomak njegovog levog sina, a ukoliko nema levo podstablo, njegov prethodnik je njegov najniži predak čiji je desni sin takođe njegov predak. U primeru ispod, prethodnik od 3 je 1, a prethodnik od 6 je 5.

[[Датотека:ASP2 K1 2020 Zadatak 1.svg|thumb|600px|center|Primer]]
== 3. zadatak ==
=== Postavka ===
'''(15p)''' U AVL stablo sa slike se redom umeću ključevi 44, 72, 19, 22, 21, 5 i 1, nakon čega se
uklanjaju ključevi 23 i 39. Prikazati stanja stabla nakon svake promene.<ref> Prepisivač ovog roka je zaboravio kako se postupno radi umetanje i brisanje, tako da su dostupna rešenja samo posle svih umetanja i posle svih brisanja (u prevodu nisam radio postupno)</ref>
[[Датотека:ASP2 K1 2020 Zadatak 3 Pocetno.svg|thumb|400px|center|Početno stanje]]
=== Rešenje ===
[[Датотека:ASP2 K1 2020 Zadatak 3 Posle umetanja.svg|thumb|400px|center|Posle svih umetanja]]

[[Датотека:ASP2 K1 2020 Zadatak 3 Posle brisanja.svg|thumb|400px|center|Posle svih brisanja]]
== 4. zadatak ==
=== Postavka ===
'''(15p)''' Neka je data velika, uređena jednostruko ulančana lista list koju treba pretražiti na zadati
ključ key. Kao pomoćna struktura, raspoloživ je indeks index veličine size.
<div class="abc-list">
# '''(5p)''' Objasniti i nacrtati strukturu indeksa i način povezivanja sa listom koja se pretražuje.
# '''(10p)''' Napisati u pseudokodu implementaciju funkcije za sekvencijalnu pretragu liste list uz korišćenje indeksa index na ključ key.
</div>
=== Rešenje ===
<div class="abc-list">
# Struktura index predstavlja niz čvorova koji sadrže informaciono polje sa vrednošću pronađenih ključeva i polje-pokazivač na taj pronađen ključ. Struktura index se čuva uređenom.
[[Датотека:ASP2 K1 2020 Zadatak 4a.svg|thumb|400px|center|Struktura indeksa]]

# {{Милокод|<nowiki>
FIND KEY LIST(list, index, size, key)
int i=0;
for(i<size)
if(key<index[i].info) Node poc = index[i];
if(key>=index[i].info) break;
while(poc!=nil)
if(key==poc.info) return poc;
if(key>poc.info) return nil;
poc=poc.next
end_while
end_for
</nowiki>}}
</div>

== 5. zadatak ==
=== Postavka ===
'''(10p)''' Neka se u dato samopodešavajuće stablo ubacuje ključ 30, nakon čega se brišu ključevi
29 i 61, i na kraju se ubacuje ključ 33. Prikazati izgled stabla nakon svakog izvršenog koraka
pri umetanju i brisanju.
[[Датотека:ASP2 K1 2020 Zadatak 5.png|thumb|400px|center|Početno stanje]]
=== Rešenje ===
U stablu se već nalazi ključ 33, tako da on ne treba da se ubacuje.
<gallery>
ASP2 K1 2020 Zadatak 5 korak 1.svg | Nakon umetanja ključa 30.
ASP2 K1 2020 zadatak 5 korak 2.svg | Nakon brisanja ključa 29.
ASP2 K1 2020 Zadatak 5 korak 3.svg | Nakon brisanja ključa 61.
</gallery>

== 6. zadatak ==
=== Postavka ===
'''(15p)''' Napisati u pseudokodu implementaciju funkcije koja u datom binarnom stablu na čiji
koren ukazuje pokazivač root pronalazi i ispisuje adrese korenova svih podstabala koja
zadovoljavaju osobine stabla binarnog pretraživanja. Dozvoljeno je uvoditi dodatna polja u
čvor stabla koja mogu olakšati implementaciju funkcije.
=== Rešenje ===
U ovom rešenju su korišćene funkcije inicijalizacije, brisanja i dodavanja u red, kao i funkcija provere da li je red prazan, koje su podrazumevano znanje sa ASP1 i kao takve mogu da se koriste bez posebnog pseudokoda za te operacije.
{{Милокод|<nowiki>
PRINT ALL BST(root)
Q.insert(root)
while(!Q.empty())
tr = Q.delete
CHECK(tr)
if(tr.bst) print(tr)
if(tr.left) Q.insert(tr.left)
if(tr.right) Q.insert(tr.right)
end_while
</nowiki>}}

{{Милокод|<nowiki>
CHECK(root)
Q.insert(root, -∞,+∞)
while(!Q.empty())
{tr,min.max} = Q.delete
if(tr.left)
if(tr.left.info < min || tr.left.info > tr.info)
root.bst = 0
return
end_if
Q.insert(tr.left,min,tr.info)
end_if
if(tr.right)
if(tr.right.info < key || tr.right.info > tr.info)
root.bst = 0
return
end_if
end_if
end_while
root.bst=1
return
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
'''(15p)''' Neka se posmatra jedna strogo monotono rastuća funkcija f(x). Na primer,<math>x^3 - 3x^2 +6x - 1</math> ili <math>3^x</math>. Korišćenjem strategije binarnog pretraživanja, napisati u pseudokodu iterativnu implementaciju funkcije koja pronalazi vrednost n za koju funkcija f(x) postaje pozitivna prvi put, ukoliko važi da je x ≥ 0. Kratko objasniti postupak.
=== Rešenje ===
U rešenju se koristi binarno pretraživanje u tabeli nepoznate veličine.
{{Милокод|<nowiki>
FIND FIRST POSITIVE(f)
int high=1;
while(f(high)<0)
high *= 2;
end_while
int low = high/2;
while(low<=high)
mid = (high+low)/2;
if(f(mid)>=0 && f(mid-1)<0) return mid;
if(f(mid)>0) high = mid-1;
else low=mid+1;
end_while
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
'''(10p)''' Analiza performansi stabla binarnog pretraživanja.
<div class="abc-list">
# '''(5p)''' Formalno definisati i objasniti prosečan broj poređenja Sn prilikom uspešnog pretraživanja i prosečan broj poređenja Un prilikom neuspešnog pretraživanja u stablu binarnog pretraživanja koje je nastalo umetanjem n čvorova u proizvoljnom poretku.
# '''(5p)''' Izvesti i kratko objasniti vezu između Sn i Un koji su definisani pod a). Odgovor ilustrovati slikom.
</div>
=== Rešenje ===
<div class="abc-list">
# Sn možemo predstaviti kao <math> Sn = (PI + n)/n</math>, jer ima za 1 više poređenja nego čvorova, a Un možemo predstaviti kao <math> Un = PE/n_{e} = PE/(n+1)</math>.
# <math>PE = PI + 2n</math>

<math>Un(n+1) - 2n = PI</math>

<math>Sn = (Un \frac{n+1}{n}) - 1</math>
</div>
== Napomene ==
<references/>


[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП2/К1 2019

2024-09-13T00:09:09Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_1920.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Data je neopadajuće uređena proširena tabela i odgovarajući vektor bitova validnosti. Prikazati izgled povećane tabele i vektora validnosti nakon umetanja svakog od ključeva: 5, 28 i 29, a zatim ukloniti ključeve: 14 i 15 i prikazati finalno stanje.
{| class="wikitable"
|+ Stanje niza iz postavke zadatka
| 4 || 7 || 10 || 14 || 15 || 15 || 21 || 24 || 25 || 40 || 45
|-
| 1 || 0 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 0
|}

=== Rešenje ===
{| class="wikitable"
|+ Stanje niza nakon unosa broja 5
| 4 || 5 || 5 || 14 || 15 || 15 || 21 || 24 || 25 || 40 || 45
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 0
|}
{| class="wikitable"
|+ Stanje niza nakon unosa broja 28
| 4 || 5 || 5 || 14 || 15 || 15 || 21 || 24 || 25 || 28 || 40
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 1
|-
| colspan="11" | Takođe je moguće da se, uz napomenu, pri nailasku na ključ veći od traženog gleda levo umesto desno.
|}
{| class="wikitable"
|+ Stanje niza nakon unosa broja 29
| 4 || 5 || 5 || 14 || 15 || 15 || 21 || 24 || 28 || 29 || 40
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 1 || 1 || 1
|-
| colspan="11" | Postoje dva načina na koji možemo da rešimo situaciju kad naiđemo na 40 i ne možemo da ga pomerimo udesno:
* kažemo da se desila greška pošto ne možemo dalje da umećemo, ili
* pomerimo ključ 28 ulevo (preporučeno).
|}
{| class="wikitable"
|+ Stanje niza nakon brisanja broja 14
| 4 || 5 || 5 || 14 || 15 || 15 || 21 || 24 || 28 || 29 || 40
|-
| 1 || 1 || 0 || 0 || 0 || 0 || 0 || 1 || 1 || 1 || 1
|}
Pri brisanju ključa 15 dešava se greška jer taj ključ ne postoji.

== 2. zadatak ==
=== Postavka ===
Neka je dat veoma veliki uređeni niz ''arr'' dužine ''n''. Poznato je da verovatnoća pretraživanja ključeva monotono opada od početka ka kraju niza.
<div class="abc-list">
# Predložiti i kratko objasniti tehniku binarnog pretraživanja koja obećava naveću<sup>[sic]</sup> efikasnost pod zadatim uslovima.
# Napisati u pseudokodu iterativnu implementaciju funkcije koja implementira binarno pretraživanje niza ''arr'' dužine ''n'' u skladu sa tehnikom predloženom pod a).
</div>

=== Rešenje ===
Način za efikasno binarno pretraživanje ovog niza jeste tako što se prvo ispituju ključevi na pozicijama <math>2^i, i \in \mathbb{N}, 2^m \leq 2^n \leq n</math> i zatim kada se odrede <math>m, n \in \mathbb{N}</math> tako da <math>arr[2^m] < k < arr[2^n]</math> na intervalu od <math>2^m</math> do <math>2^n</math> se sprovodi binarna pretraga.

U postavci funkcije u zadatku nije bio dat parametar ''k'', odnosno ključ koji se pretražuje, ali je ovde dodat.
{{Милокод|<nowiki>
BINARY SEARCH PROB(arr, n, k)
low = 1
high = 2
while (high ≤ n) and (arr[high] < k) do
low = high
high = 2 * high
end_while
if (high > n) then
high = n
end_if
while (low ≤ high) do
mid = (low + high) / 2
if (arr[mid] = k) then
return mid
else if (arr[mid] < k) then
low = mid + 1
else
high = mid - 1
end_if
end_while
return nil
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Na slici je dato stablo binarnog pretraživanja. Potrebno je transformisati ovo stablo u AVL stablo. Prikazati transformaciju stabla po koracima.
25
/ \
9 38
/ \
36 49
/ /
31 42
/ / \
27 40 45
\
47

=== Rešenje ===
<div class="mw-collapsible mw-collapsed" data-expandtext="Prikaži postupak">
Prvo pronađemo kritične čvorove u stablu:
'''25'''
/ \
9 38
/ \
'''36''' '''49'''
/ /
31 42
/ / \
27 40 45
\
47
Zatim radimo rotaciju udesno oko čvora 36 (njegovo levo dete naginje na levu stranu):
25
/ \
9 38
/ \
31 49
/ \ /
27 36 42
/ \
40 45
\
47
čime postižemo da čvor 36 više nije kritičan. Zatim radimo rotaciju ulevo oko čvora 42 (levo dete čvora 49 naginje na desnu stranu):
25
/ \
9 38
/ \
31 49
/ \ /
27 36 45
/ \
42 47
/
40
pa rotaciju udesno oko čvora 49:
25
/ \
9 38
/ \
31 45
/ \ / \
27 36 42 49
/ /
40 47
čime postižemo da čvor 49 više nije kritičan. Na kraju radimo rotaciju ulevo oko čvora 25 (njegovo desno dete naginje na desnu stranu) i dobijamo...
</div>
'''Konačno stablo:'''
38
/ \
25 45
/ \ / \
9 31 42 49
/ \ / /
27 36 40 47

== 4. zadatak ==
=== Postavka ===
Na slici je prikazano stablo binarnog pretraživanja nakon brisanja ključa 19. Ako je poznato da se prilikom brisanja koristi prethodnik, prikazati sve moguće izglede stabla neposredno pre brisanja navedenog ključa.
10
/ \
5 18
/ / \
3 14 20
\
15
\
17

=== Rešenje ===
10
/ \
5 18
/ / \
3 14 19
\ \
15 20
\
17

10
/ \
5 18
/ / \
3 14 20
\ /
15 19
\
17

10
/ \
5 19
/ / \
3 18 20
/
14
\
15
\
17

10
/ \
5 19
/ / \
3 14 20
\
15
\
17
\
18

10
/ \
5 19
/ / \
3 14 20
\
18
/
15
\
17

10
/ \
5 19
/ / \
3 14 20
\
15
\
18
/
17

== 5. zadatak ==
=== Postavka ===
Neka se u dato samopodešavajuće stablo redom ubacuju ključevi 37, 32, 34, nakon čega se pretražuje na ključeve 33 i 20, a zatim se brišu ključevi 60 i 31. Prikazati izgled stabla nakon svakog izvršenog koraka pri umetanju i brisanju.
50
/ \
30 60
/ \
20 40

=== Rešenje ===
<div class="mw-collapsible mw-collapsed" data-expandtext="Prikaži postupak" data-collapsetext="Sakrij postupak">
Prvo dodajemo čvor 37 u stablo:
50
/ \
30 60
/ \
20 40
/
37
Pošto od dede do oca i od oca do sine vode grane u suprotnim smerovima, prvo rotiramo udesno oko čvora 40:
50
/ \
30 60
/ \
20 40
\
37
a zatim ulevo oko čvora 30:
50
/ \
37 60
/ \
30 40
/
20
Pošto još uvek nismo u korenu, rotiramo ulevo oko čvora 50:
37
/ \
30 50
/ / \
20 40 60
Zatim dodajemo čvor 32:
37
/ \
30 50
/ \ / \
20 32 40 60
Pošto od dede do oca i od oca do sine vode grane u suprotnim smerovima, prvo rotiramo ulevo oko čvora 30:
37
/ \
32 50
/ / \
30 40 60
/
20
a onda udesno oko čvora 37:
32
/ \
30 37
/ \
20 50
/ \
40 60
Dodajemo čvor 34:
32
/ \
30 37
/ / \
20 34 50
/ \
40 60
Pošto od dede do oca i od oca do sine vode grane u suprotnim smerovima, prvo rotiramo udesno oko čvora 37:
32
/ \
30 34
/ \
20 37
\
50
/ \
40 60
a zatim ulevo oko čvora 32:
34
/ \
32 37
/ \
30 50
/ / \
20 40 60
Pretražujemo ključ 33 putem 34 → 32 → nil, pa 32 moramo da pomerimo do korena, tako da radimo rotaciju udesno oko 34:
32
/ \
30 34
/ \
20 37
\
50
/ \
40 60
Pretražujemo ključ 20 putem 32 → 30 → 20. Pošto grana od oca do sina i od dede do oca imaju isti smer, radimo rotaciju udesno oko 32.
30
/ \
20 32
\
34
\
37
\
50
/ \
40 60
a zatim rotaciju udesno oko 30:
20
\
30
\
32
\
34
\
37
\
50
/ \
40 60
Zatim brišemo čvor 60. Prvo radimo rotaciju ulevo oko 37:
20
\
30
\
32
\
34
\
50
/ \
37 60
\
40
a zatim rotaciju ulevo oko 50:
20
\
30
\
32
\
34
\
60
/
50
/
37
\
40
60 i dalje nije u korenu, tako da radimo rotaciju ulevo oko 32:
20
\
30
\
34
/ \
32 60
/
50
/
37
\
40
pa rotaciju ulevo oko 34:
20
\
30
\
60
/
34
/ \
32 50
/
37
\
40
60 i dalje nije u korenu, pa radimo rotaciju ulevo oko 20:
30
/ \
20 60
/
34
/ \
32 50
/
37
\
40
a zatim rotaciju ulevo oko 30:
60
/
30
/ \
20 34
/ \
32 50
/
37
\
40
Pošto 60 ima samo jedno dete, samo ga uklanjamo:
30
/ \
20 34
/ \
32 50
/
37
\
40
Zatim brišemo čvor 31, prolazeći putem 30 → 34 → 32 → nil. Pošto je 32 poslednji čvor kojem smo pristupili, njega guramo u koren tako da prvo radimo rotaciju udesno oko 34:
30
/ \
20 32
\
34
\
50
/
37
\
40
a zatim rotaciju ulevo oko 30, čime dobijamo...
</div>
'''Konačno stablo:'''
32
/ \
30 34
/ \
20 50
/
37
\
40

== 6. zadatak ==
=== Postavka ===
Posmatra se samopodešavajuće stablo dato pokazivačem na koren ''root''. Napisati pseudokod operacije ''split'', koja od jednog datog stabla pravi dva nova tako da se u jednom stablu nalaze svi ključevi manji ili jednaki od zadatog ključa ''k'', a u drugom stablu se nalaze svi ključevi veći od ključa ''k''. Sam ključ ''k'' ne mora da se nalazi u početnom stablu. Smatrati da operacija SPLAY(''x'') koja vrši širenje zadatog čvora ''x'' postoji već implementirana.

=== Rešenje ===
{{Милокод|<nowiki>
SPLAY SPLIT(root, k)
if (root = nil) then
return nil, nil
end_if
x = root
prev = left = right = nil
while (x ≠ nil) do
prev = x
if (key(x) = k) then
break
else if (key(x) < k) then
x = right(x)
else
x = left(x)
end_if
end_while
SPLAY(prev)
if key(prev) ≤ k then
left = prev
right = right(prev)
right(left) = nil
else
right = prev
left = left(prev)
left(right) = nil
end_if
return left, right
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Napisati u pseudokodu iterativnu implementaciju funkcije koja u stablu binarnog pretraživanja na koje ukazuje pokazivač ''root'' pronalazi čvor koji sadrži najveći ključ koji je jednak ili manji od zadatog ključa ''key''. Ključ ''key'' ne mora postojati u stablu.

=== Rešenje ===
{{Милокод|<nowiki>
FIND BST FLOOR(root, key)
largest = nil
p = root
while (p ≠ nil) do
if (key(p) = key) then
return key
else if (key(p) < key) then
largest = p
p = right(p)
else
p = left(p)
end_if
end_while
if (largest ≠ nil) then
return key(largest)
end_if
return nil
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Neka se posmatra stablo binarnog pretraživanja sa slike sa poznatim verovatnoćama uspešnog pretraživanja <math>p_i</math> i neuspešnog pretraživanja <math>q_i</math> u tabelama u prilogu.
25
/ \
12 33
\
19
{| class="wikitable"
! <math>K_i</math> !! 12 !! 19 !! 25 !! 33
|-
! <math>p_i</math>
| 0.2 || 0.2 || 0.15 || 0.05
|}
{| class="wikitable"
! <math>K_i</math>
! <math>K_i < 12</math>
! <math>12 < K_i < 19</math>
! <math>19 < K_i < 25</math>
! <math>25 < K_i < 33</math>
! <math>33 < K_i</math>
|-
! <math>q_i</math>
| 0.05 || 0.1 || 0.15 || 0.05 || 0.05
|}
<div class="abc-list">
# Formalno definisati, a zatim izračunati cenu ''C'' ovog stabla.
# Ukoliko se od ključeva u stablu formira suboptimalno stablo binarnog pretraživanja kod koga se koren bira tako da razlika težina levog i desnog podstabla bude minimalna, odrediti takvo stablo i obrazložiti odgovor.
</div>

=== Rešenje ===
Cena binarnog stabla pretraživanja definiše se kao: <math>C = \sum_{i = 1}^{n} p_i (h_i + 1) + \sum_{i = 0}^{n} q_i h_i</math> gde su:
* <math>p_i</math> verovatnoće pretraživanja za neki od postojećih ključeva (<math>i</math> odgovara poziciji ključa u uređenom nizu ključeva),
* <math>q_i</math> verovatnoće pretraživanja koje će završiti u jednom od eksternih čvorova stabla binarnog pretraživanja (<math>i</math> odgovara poziciji eksternog čvora pri ''inorder'' obilasku svih eksternih čvorova) i
* <math>h_i</math> odgovara nivou čvora.
S gornjom definicijom u vidu, stablu možemo docrtati eksterne čvorove:
p3
/ \
p1 p4
/ \ / \
q1 p2 q4 q5
/ \
q2 q3
i zatim izračunati cenu po formuli:
: <math>C = 2 \cdot 0.2 + 3 \cdot 0.2 + 1 \cdot 0.15 + 2 \cdot 0.05 +</math>
: <math>+ 2 \cdot 0.05 + 3 \cdot 0.1 + 3 \cdot 0.15 + 2 \cdot 0.05 + 2 \cdot 0.05 =</math>
: <math>= 0.4 + 0.6 + 0.15 + 0.1 + 0.1 + 0.3 + 0.45 + 0.1 + 0.1 = 2.3</math>

U zavisnosti od izbora korena imaćemo različite čvorove u levom i desnom podstablu. Izračunavamo razliku težina u datom stablu kao <math>(p_1 + p_2 + q_1 + q_2 + q_3) - (p_4 + q_4 + q_5) = (0.2 + 0.2 + 0.05 + 0.1 + 0.15) - (0.05 + 0.05 + 0.05) = 0.7 - 0.15 = 0.55</math>. Prebacivanjem korena na čvor 33 vidimo da će doći do još manjeg balansa težina, stoga koren prebacujemo na čvor 19 i dobijamo stablo ispod:
p2
/ \
p1 p3
/ \ / \
q1 q2 q3 p4
/ \
q4 q5

Za ovo stablo izračunavamo razliku težina kao <math>(p_1 + q_1 + q_2) - (p_3 + p_4 + q_3 + q_4 + q_5) = (0.2 + 0.05 + 0.1) - (0.15 + 0.05 + 0.15 + 0.05 + 0.05) = 0.35 - 0.45 = -0.1</math>. Sada vidimo da je balans veći i da je prešao na drugu stranu, tako da znamo da će prebacivanjem korena na čvor 12 balans biti manji.

[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП2/К1 2018

2024-09-13T00:09:09Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_1819.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Optimalno stablo binarnog pretraživanja
<div class="abc-list">
# Navesti formulu za izračunavanje cene optimalnog stabla binarnog pretraživanja i objasniti je.
# Ukoliko se posmatraju tri ključa <math>K_1 < K_2 < K_3</math> sa poznatim verovatnoćama uspešnog pretraživanja p1 = 0.2, p2 = 0.05, p3 = 0.1 i neuspešnog pretraživanja q0 = 0.15, q1 = 0.2, q2 = 0.1 i q3 = 0.2, odrediti i nacrtati optimalno stablo binarnog pretraživanja.
</div>

=== Rešenje ===
Formula je napisana i objašnjena u [[АСП2/К1 2019#8. zadatak|osmom zadatku na prvom kolokvijumu 2019. godine]].

Postoji pet rasporeda ovih čvorova (<math>p_i</math> označavaju ključeve a <math>q_i</math> eksterne čvorove stabla):
p1
/ \
q0 p2
/ \
q1 p3
/ \
q2 q3
: <math>C = 1 \cdot 0.2 + 2 \cdot 0.05 + 3 \cdot 0.1 +</math>
: <math>+ 1 \cdot 0.15 + 2 \cdot 0.2 + 3 \cdot 0.1 + 3 \cdot 0.2 =</math>
: <math>= 0.2 + 0.1 + 0.3 + 0.15 + 0.4 + 0.3 + 0.6 = 2.05</math>
p2
/ \
p1 p3
/ \ / \
q0 q1 q2 q3
: <math>C = 2 \cdot 0.2 + 1 \cdot 0.05 + 2 \cdot 0.1 +</math>
: <math>+ 2 \cdot 0.15 + 2 \cdot 0.2 + 2 \cdot 0.1 + 2 \cdot 0.2 =</math>
: <math>= 0.4 + 0.05 + 0.2 + 0.3 + 0.4 + 0.2 + 0.4 = 1.95</math>
p3
/ \
p2 q3
/ \
p1 q2
/ \
q0 q1
: <math>C = 3 \cdot 0.2 + 2 \cdot 0.05 + 1 \cdot 0.1 +</math>
: <math>+ 3 \cdot 0.15 + 3 \cdot 0.2 + 2 \cdot 0.1 + 1 \cdot 0.2 =</math>
: <math>= 0.6 + 0.1 + 0.1 + 0.45 + 0.6 + 0.2 + 0.2 = 2.25</math>
p1
/ \
q0 p3
/ \
p2 q3
/ \
q1 q2
: <math>C = 1 \cdot 0.2 + 3 \cdot 0.05 + 2 \cdot 0.1 +</math>
: <math>+ 1 \cdot 0.15 + 3 \cdot 0.2 + 3 \cdot 0.1 + 2 \cdot 0.2 =</math>
: <math>= 0.2 + 0.15 + 0.2 + 0.15 + 0.6 + 0.3 + 0.4 = 2</math>
p3
/ \
p1 q3
/ \
q0 p2
/ \
q1 q2
: <math>C = 2 \cdot 0.2 + 3 \cdot 0.05 + 1 \cdot 0.1 +</math>
: <math>+ 2 \cdot 0.15 + 3 \cdot 0.2 + 3 \cdot 0.1 + 1 \cdot 0.2 =</math>
: <math>= 0.4 + 0.15 + 0.1 + 0.3 + 0.6 + 0.3 + 0.2 = 2.05</math>
Ovim dobijamo da je optimalno stablo binarnog pretraživanja za ova tri ključa stablo u kojem je <math>K_2</math> u korenu.

== 2. zadatak ==
=== Postavka ===
Napisati u pseudokodu efikasnu iterativnu implementaciju funkcije koja u stablu binarnog pretraživanja na čiji koren ukazuje pokazivač ''root'' pronalazi sledbenika čvora koji sadrži ključ ''key''. U okviru čvora stabla ne postoji pokazivač na oca.

=== Rešenje ===
Ideja je da umesto ''inorder'' obilaska iskoristimo činjenicu da se sledbenik čvora sa ključem ''key'' može pronaći jednim spuštanjem niz stablo u pretrazi za ključem ''key''. Postoje dva slučaja:
# kada čvor sa ključem ''key'' ima desno podstablo, znamo da se u njemu sigurno nalazi njegov sledbenik kao najlevlje dete desnog podstabla, i
# kada taj čvor nema desno podstablo, uzimamo poslednji čvor kod koga smo utvrdili da mu je ključ veći od ključa koji tražimo (poslednji čvor kod koga smo "otišli levo").
{{Милокод|<nowiki>
FIND BST SUCC(root, key)
p = root
succ = nil
while (key(p) ≠ key) do
if (key(p) < key) then
p = right(p)
else if (key(p) > key) then
succ = p
p = left(p)
end_if
end_while
if (right(p) ≠ nil) then
p = right(p)
while (p ≠ nil) do
succ = p
p = left(p)
end_while
end_if
return succ
</nowiki>}}

== 3. zadatak ==
{{делимично решено}}
=== Postavka ===
[[Датотека:ASP2 K1 2018 zadatak 3 stablo.svg|thumb|Crveno-crno stablo iz postavke zadatka.]]
Neka se posmatra crveno-crno stablo sa slike. Prikazati izgled stabla po koracima nakon umetanja ključeva 81 i 79 i uklanjanja ključa 23.

=== Rešenje ===

== 4. zadatak ==
=== Postavka ===
U stablu binarne pretrage greškom su dva čvora zamenila svoje pozicije. Implementirati funkciju CORRECT_BST koja ispravlja grešku i vraća ova dva čvora na svoje prave pozicije. Svaki čvor osim celobrojnog ključa i pokazivača na levo i desno podstablo sadrži i pokazivač na oca.

=== Rešenje ===
Pod zamenom čvorova se ne misli samo na zamenu ključeva u tim čvorovima već na zamenu zajedno sa podstablima, tako da jedna zamena ne može imati kaskadne posledice već će samo dva čvora ostati nekonzistentna.

Ideja je na stek guramo decu čvorova za koje odredimo da upadaju u granice pretrage po stablu binarnog pretraživanja, a ako ne upadaju smestimo ih u jednu od dve promenljive i nakon toga zamenimo, pazeći da zamenimo i pokazivače na roditelje i roditeljske pokazivače.
{{Милокод|<nowiki>
CORRECT BST(root)
STACK_INIT(S_nodes)
STACK_INIT(S_low)
STACK_INIT(S_high)
PUSH(S_nodes, root)
PUSH(S_low, -∞)
PUSH(S_high, +∞)
while not STACK_EMPTY(S_nodes) do
node = POP(S_nodes)
low = POP(S_low)
high = POP(S_high)
if low < key(node) < high then
if left(node) ≠ nil then
PUSH(S_nodes, left(node))
PUSH(S_low, low)
PUSH(S_high, key(node))
end_if
if right(node) ≠ node then
PUSH(S_nodes, right(node))
PUSH(S_low, key(node))
PUSH(S_high, high)
end_if
else
if first = nil then
first = node
else
second = node
break
end_if
end_if
end_while
tmp = parent(first)
parent(first) = parent(second)
parent(second) = tmp
if left(parent(first)) = second then
left(parent(first)) = first
else
right(parent(first)) = first
end_if
if left(parent(second)) = first then
left(parent(second)) = second
else
right(parent(second)) = second
end_if
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Neka se u prazno AVL stablo redom ubacuju ključevi 27, 12, 7, 34, 31, 5, 6, a zatim se brišu ključevi 31, 34, 12. Prilikom brisanja koristiti '''prethodnika'''. Prikazati izgled stabla nakon svakog izvršenog koraka pri umetanju i brisanju.

=== Rešenje ===
Konačno stablo je:
7
/ \
6 27
/
5
Postupak možete simulirati u nekom od [https://www.cs.usfca.edu/~galles/visualization/AVLtree.html simulatora] za AVL stabla.

== 6. zadatak ==
=== Postavka ===
Koristeći metodu binarne pretrage kao ideju, napisati u pseudokodu funkciju koja efikasno proverava da li je tačka T teme ''n''-tougla M. Mnogougao M se zadaje pomoću niza tačaka – temena. Tačke su određene koordinatama ''x'' i ''y''. Niz temena mnogougla je uređen rastuće po vrednosti koordinate ''x'', pri čemu za istu vrednost koordinate ''x'' važi rastuća uređenost po vrednosti koordinate ''y''.

=== Rešenje ===
Ovde se radi obična binarna pretraga s tim što se uslovi za odlazak ulevo ili udesno menjaju: ukoliko je ''x'' koordinata trenutne tačke veća od tražene, ili ukoliko su iste ali je ''y'' koordinata veća od tražene, ide se ulevo, a ukoliko je ''x'' koordinata trenutne tačke manja od tražene, ili ukoliko su iste ali je ''y'' koordinata manja od tražene, ide se udesno.
{{Милокод|<nowiki>
CHECK VERTEX(M, n, T)
low = 1
high = n
while low ≤ high do
mid = (high + low) / 2
if (x(M[mid]) = x(T)) and (y(M[mid]) = y(T)) then
return true
else if (x(M[mid]) < x(T)) or ((x(M[mid]) = x(T)) and (y(M[mid]) < y(T))) then
low = mid + 1
else
high = mid - 1
end_if
end_while
return false
</nowiki>}}
Postupak se mogao pojednostaviti ukoliko se pretpostavi da ne može postojati više od dve tačke sa istom ''x'' koordinatom, jer bi u tom slučaju te tačke bile kolinearne i ne bi mogle da budu temena ''n''-tougla.

== 7. zadatak ==
=== Postavka ===
Dat je neuređeni niz ''A'' dužine ''n'' celobrojnih ključeva u opsegu vrednosti 1..100 koji se pretražuje i neuređeni niz ključeva ''K'' mnogo veće dužine ''m'' na koje se vrši pretraga. U nizu ''K'' ima veliki broj ponovljenih ključeva. Zbog neravnomerne verovatnoće pretrage ključeva, koristi se sledeća tehnika optimizacije. Nakon svakog uspešnog pretraživanja, vrši se prebacivanje za ''p'' pozicija unapred, gde je ''p'' broj uspešnih nalaženja tog ključa. Napisati u pseudokodu funkciju koja redom pretražuje niz ''A'' na ključeve iz niza ''K'' i vraća prosečan broj poređenja po nađenom ključu.

=== Rešenje ===
{{Милокод|<nowiki>
SEARCH(A, K, n, m)
for i = 1 to 100 do
P[i] = 0
end_for
sum = 0
num = 0
for i = 1 to m do
key = K[i]
found = 0
for j = 1 to n do
if A[j] = key then
found = j
break
end_if
end_for
if found ≠ 0 then
sum = sum + j
num = num + 1
P[key] = P[key] + 1
for k = found downto found - P[key] + 1 do
A[k] = A[k-1]
end_for
A[found - P[key]] = key
end_if
end_for
if num = 0 then
return 0
else
return sum/num
end_if
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Obrazložiti da li je sledeća sekvenca ključeva validna u stablu binarnog pretraživanja:
<div class="abc-list">
# Ako se prilikom uspešnog pretraživanja u jednom stablu redom proveravaju ključevi 23, 87, 158, 348, 160, 200, 150, 158.
# Ako se prilikom neuspešnog pretraživanja u drugom stablu redom proveravaju ključevi 546, 453, 427, 68, 415, 231, 247, 417, 300.
</div>

=== Rešenje ===
Ovde gledamo naš silazak niz potencijalni BST i na osnovu prethodno pogledanih čvorova određujemo granice ''high'' i ''low'' u kojima se moraju nalaziti naredni ključevi kako bi stablo bilo validan BST. Dobijamo da oba slučaja nisu moguća u binarnom stablu pretraživanja.
<div class="abc-list">
#
## 23 → 87, low = 23, high = +∞
## 87 → 158, low = 87, high = +∞
## 158 → 348, low = 158, high = +∞
## 348 → 160, low = 158, high = 348
## 160 → 200, low = 160, high = 348
## 200 → 150, 150 < low => ⚡
#
## 546 → 453, low = -∞, high = 546
## 453 → 427, low = -∞, high = 453
## 427 → 68, low = -∞, high = 427
## 68 → 415, low = 68, high = 427
## 415 → 231, low = 68, high = 415
## 231 → 247, low = 231, high = 415
## 247 → 417, 417 > high => ⚡
</div>

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К1 2017

2024-09-13T00:09:08Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_1718.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Uporediti metode binarne i višestruke sekvencijalne pretrage nad uređenim nizom celih brojeva 3, 7, 10, 11, 18, 22, 25, 27, 39, 41, 45, 48, 56, 64, 65, 78, 86. Odrediti broj poređenja pri pretrazi ključeva 25 i 44 za obe tehnike.
{| class="wikitable"
|+ Tabela iz postavke zadatka.
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12 !! 13 !! 14 !! 15 !! 16
|-
| 3 || 7 || 10 || 11 || 18 || 22 || 25 || 27 || 39 || 41 || 45 || 48 || 56 || 64 || 65 || 78 || 86
|}

=== Rešenje ===
Višestrukom sekvencijalnom pretragom prvo idemo od ključa 3 do ključa 25, čime radimo 7 poređenja na nejednakost i jedno poređenje na jednakost, a zatim idemo od ključa 25 do ključa 45 čime radimo 5 poređenja na nejednakost i jedno poređenje na jednakost, što ukupno daje 14 poređenja na vrednost ključa.

Binarnom pretragom prvo gađamo ključ 39 (2), pa 11 (2), pa 22 (2) i na kraju 25 (1), a zatim u drugoj pretrazi 39 (2), pa 56 (2), pa 45 (2), pa 41 (2) i tu se pretraga završava neuspešno, čime vršimo 15 poređenja na vrednost ključa.

== 2. zadatak ==
=== Postavka ===
Funkciji FIND_BST prosleđen je pokazivač root na koren jednog kompletnog binarnog stabla. Struktura čvora ovog stabla osim ključa, pokazivača na levo i desno podstablo, sadrži i pokazivač na oca. Implementirati iterativnu funkciju FIND_BST čija povratna vrednost treba da bude pokazivač na koren onog podstabla koje predstavlja stablo binarne pretrage. Ukoliko postoji više ovakvih podstabala, treba vratiti pokazivač na koren onog podstabla sa maksimalnim brojem čvorova. Proveru da li je neko podstablo stablo binarne pretrage izdvojiti u posebnu funkciju. Obavezno kratko prokomentarisati rešenje.

=== Rešenje ===
Ovde nam je najpogodnije da ''postorder'' obilaskom određujemo da li su čvorovi binarna stabla pretraživanja, jer tako kad stignemo do viših čvorova već znamo da li su im deca ispravna binarna stabla pretraživanja. S tim u vidu, implementacija tražene funkcije za proveru izgleda ovako:
{{Милокод|<nowiki>
IS BST(node, left_max, right_min)
if left_max < key(node) < right_min then
return true
end_if
return false
</nowiki>}}
Kao pozivne argumente ove funkcije primamo najveći ključ iz levog podstabla i najmanji ključ iz desnog podstabla, što znači da bi trebalo da te podatke čuvamo u nekom redu kako bismo iz roditelja mogli da tim informacijama pristupimo. Obilazak kreće od reda listova i kreće se tako što svaki list gura svog roditelja u red, a duplikati roditelja se izbacuju iz reda prilikom njihovog obilaska.
{{Милокод|<nowiki>
FIND BST(root)
if root = nil then
return nil
end_if
last_bst = nil
QUEUE_INIT(Q_valid_bst)
QUEUE_INIT(Q_nodes)
QUEUE_INIT(Q_inv_nodes)
QUEUE_INIT(Q_max)
QUEUE_INIT(Q_min)
INSERT(Q_nodes, root)
while (not QUEUE_EMPTY(Q_nodes)) do
node = DELETE(Q_nodes)
if left(node) ≠ nil then
INSERT(Q_nodes, left(node))
INSERT(Q_nodes, right(node))
else
INSERT(Q_inv_nodes, node)
end_if
end_while
while (not QUEUE_EMPTY(Q_inv_nodes)) do
node = DELETE(Q_inv_nodes)
if left(node) = nil then
valid_bst = true
curr_max = key(node)
curr_min = key(node)
else
DELETE(Q_inv_nodes)
left_valid = DELETE(Q_valid_bst)
right_valid = DELETE(Q_valid_bst)
left_min = DELETE(Q_min)
right_min = DELETE(Q_min)
left_max = DELETE(Q_max)
right_max = DELETE(Q_max)
if left_valid and right_valid and IS_BST(node, left_max, right_min) then
valid_bst = true
else
valid_bst = false
end_if
curr_max = max(key(node), left_max, right_max)
curr_min = min(key(node), left_min, right_min)
end_if
if valid_bst then
last_bst = node
end_if
INSERT(Q_valid_bst, valid_bst)
INSERT(Q_inv_nodes, parent(node))
INSERT(Q_min, curr_min)
INSERT(Q_max, curr_max)
end_while
return last_bst
</nowiki>}}

== 3. zadatak ==
{{делимично решено}}
=== Postavka ===
[[Датотека:ASP2 K1 2018 zadatak 3 stablo.svg|thumb|Crveno-crno stablo iz postavke zadatka.]]
Neka se posmatra crveno-crno stablo sa slike. Prikazati izgled stabla po koracima nakon umetanja ključeva 7 i 10.

=== Rešenje ===

== 4. zadatak ==
=== Postavka ===
Koristeći modifikovanu binarnu pretragu, napisati u pseudukodu iterativnu funkciju koja vraća poziciju prethodnika i sledbenika zadate vrednosti ''k'' u zadatom uređenom nizu ''arr''. Vrednost k ne mora postojati u nizu.

=== Rešenje ===
Ovde se pretpostavlja da se ključevi u nizu ne mogu ponavljati.
{{Милокод|<nowiki>
ARR PRED SUCC(arr, k)
while (low ≤ high) do
mid = (high + low) / 2
if arr[mid] = k then
return mid-1, mid+1
else if arr[mid] < k then
low = mid + 1
else
high = mid - 1
end_if
end_while
if arr[mid] < k then
return mid, mid+1
else
return mid-1, mid
end_if
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Neka se u prazno AVL stablo redom ubacuju ključevi 12, 43, 23, 55, 72, 2, 60, 57, 89, a zatim se brišu ključevi 12, 23 i 57. Prilikom brisanja koristiti '''prethodnika'''. Prikazati izgled stabla nakon svakog izvršenog koraka pri umetanju i brisanju

=== Rešenje ===
Konačno stablo je:
60
/ \
43 72
/ \ \
2 55 89
Postupak možete simulirati u nekom od [https://www.cs.usfca.edu/~galles/visualization/AVLtree.html simulatora] za AVL stabla.

== 6. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju koja efikasno proverava da li je dato binarno stablo pretrage ''bst'' balansirano po AVL kriterijumu. Pored pokazivača na oca i levog i desnog sina, čvor stabla sadrži i podatke o visini levog i desnog podstabla.

=== Rešenje ===
Pošto ne moramo da izračunavamo visine podstabla, ovaj zadatak se svodi na posećivanje svih čvorova kako bismo uporedili sve visine levih i desnih podstabala u jednom čvoru. Ukoliko se u nekom razlikuju za više od 1, stablo nije balansirano po AVL kriterijumu.
{{Милокод|<nowiki>
CHECK AVL BALANCED(bst)
INIT_STACK(S)
PUSH(S, bst)
while (not STACK_EMPTY(S)) do
node = POP(S)
if abs(height_l(node) - height_r(node)) > 1 then
return false
end_if
if height_l(node) > 2 then
PUSH(S, left(node))
end_if
if height_r(node) > 2 then
PUSH(S, right(node))
end_if
end_while
return true
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Suboptimalno stablo binarnog pretraživanja
<div class="abc-list">
# Objasniti algoritam za određivanje suboptimalnog stabla binarnog pretraživanja koji je zasnovan na težinama podstabala.
# Ako su za ''n'' ključeva date verovatnoće uspešnog pretraživanja u nizu ''P'', a neuspešnog u nizu ''Q'', napisati efikasnu implementaciju funkcije koja nalazi samo koren tog stabla.
</div>

=== Rešenje ===
Određivanje suboptimalnog stabla binarnog pretraživanja zasnovanog na težinama podstabala, gde je težina podstabla koje uključuje čvorove na pozicijama od <math>i+1</math> do <math>j</math> u tabeli definisana kao <math>w_{ij} = q_i + p_{i+1} + q_{i+1} + ... + p_j + q_j</math>, se vrši tako što se prvo odredi ključ koji, kad postavljen za koren, daje najmanju razliku težina levog i desnog podstabla, a zatim se taj proces primeni rekurzivno na levo i desno podstablo (podniz) kako bi se i njihovi koreni odredili.
{{Милокод|<nowiki>
FIND ROOT(P, Q, n)
min_key = 1
left = Q[1]
right = 1 - left - P[1]
min_diff = abs(right - left)
for i = 2 to n do
left = left + Q[i] + P[i-1]
right = 1 - left - P[i]
diff = abs(right - left)
if diff < min_diff then
min_diff = diff
min_key = i
end_if
end_for
return min_key
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Neka se u samopodešavajuće stablo umeću redom ključevi 50, 70, 30, 60, 40, zatim se pretražuje na 70, pa se umeće 45 i, na kraju, pretražuje na 30. Prikazati izgled stabla nakon svake operacije.

=== Rešenje ===
Konačno stablo je:
30
\
40
\
45
\
60
/ \
50 70
Postupak možete simulirati u nekom od [https://www.cs.usfca.edu/~galles/visualization/SplayTree.html simulatora] za samopodešavajuća stabla.

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К1 2016

2024-09-13T00:09:07Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_1617.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Ako je ''inorder'' obilaskom nekog stabla binarnog pretraživanja dobijen niz ključeva 1 5 8 9 11 14 prikazati tri moguća izgleda ovog stabla sa: (a) najmanjom visinom, (b) najvećom visinom i (c) visinom između najmanje i najveće. Obeležiti stablo sa najboljim i najlošijim performansama operacija.

=== Rešenje ===
Stablo A ima najbolje performanse operacija:
9
/ \
5 11
/ \ \
1 8 14
Stablo B ima najlošije performanse operacija:
1
\
5
\
8
\
9
\
11
\
14
Stablo C nema ni najbolje ni najlošije performanse operacija:
11
/ \
9 14
/
8
/
5
/
1

== 2. zadatak ==
=== Postavka ===
Dat je niz celih brojeva. Koristeći stablo binarnog pretraživanja, napisati funkciju koja menja svaki element njegovim sledbenikom. U slučaju da element nema sledbenika, zadržati originalnu vrednost. Rezultat funkcije je niz preuredjen na opisani način.

=== Rešenje ===
Ovde prvo prebacujemo zadati niz u binarno stablo pretraživanja koristeći funkciju za umetanje čvora a zatim za svaki element niza pronalazimo sledbenika slično kao u [[АСП2/К1 2018#2. zadatak|drugom zadatku sa prvog kolokvijuma 2018]].
{{Милокод|<nowiki>
ARR TRANSFORM(arr, n)
bst = nil
for i = 1 to n do
BST-INSERT(bst, arr[i])
end_for
for i = 1 to n do
key = arr[i]
p = bst
prev = nil
while (p ≠ nil) and (key(p) ≠ key) do
if key(p) > key then
prev = p
p = left(p)
else
p = right(p)
end_if
end_while
p = right(p)
while p ≠ nil do
prev = p
p = left(p)
end_while
if prev ≠ nil then
arr[i] = key(prev)
end_if
end_for
</nowiki>}}
{{Милокод|<nowiki>
BST-INSERT(bst, key)
node = GETNODE
key(node) = key
if bst = nil then
bst = node
else
p = bst
while true do
if key(p) > key then
if left(p) = nil then
left(p) = node
break
else
p = left(p)
end_if
else
if right(p) = nil then
right(p) = node
break
else
p = right(p)
end_if
end_if
end_while
end_if
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Neka je dat rastuće uređeni niz celih brojeva (npr., 1 2 3 5 7 9) ili neka njegova rotacija (npr., 5 7 9 1 2 3). Vrednosti se ne ponavljaju u nizu. Napisati u pseudokodu iterativnu funkciju koja na efikasan način pronalazi minimalnu vrednost u nizu.

=== Rešenje ===
Ovaj problem se svodi na binarnu pretragu sa izmenjenim uslovima: sada detektujemo da li se nalazimo levo ili desno od tražene vrednosti poredeći se sa prvim elementom (ukoliko je trenutni element veći od prvog, levo smo od tražene vrednosti) a detekciju tražene vrednosti tako što proverimo da li je element levo od trenutnog veći od njega (to znači da smo došli na početak nerotiranog niza).
{{Милокод|<nowiki>
FIND MIN(arr, n)
low = 1
high = n
if arr[1] ≤ arr[n] then
return arr[1]
end_if
while low ≤ high do
mid = (high + low) / 2
if arr[mid] < arr[mid-1] then
return arr[mid]
else if arr[mid] < arr[1] then
high = mid - 1
else
low = mid + 1
end_if
end_while
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Binarno pretraživanje u povećanoj tabeli
<div class="abc-list">
# Objasniti na koji način se vrši umetanje i brisanje u povećanoj tabeli.
# Data je povećana tabela uređena neopadajuće i odgovarajući vektor sa bitovima validnosti. Na slici je prikazano trenutno stanje. Prikazati izgled povećane tabele i vektora validnosti nakon umetanja svakog od kljuceva: 6, 29 i 35, a zatim ukloniti ključeve : 18 i 23 i prikazati finalno stanje.
</div>
{| class="wikitable"
|+ Početno stanje povećane tabele
| 5 || 5 || 9 || 18 || 22 || 22 || 23 || 25 || 28 || 38 || 40
|-
| 1 || 0 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 0
|}

=== Rešenje ===
Umetanje se vrši tako što prvo uradimo (binarnu) pretragu za neki ključ i ako utvrdimo da postoji (da postoji ključ sa traženom vrednošću u tabeli i da mu je bit validnosti postavljen na 1) bacamo grešku, u suprotnom proveravamo bit validnosti na polju do kojeg smo došli: ako je 1, moramo pomeriti sve validne ključeve koji slede nakon tog polja za jedno mesto unapred kako bismo mogli da ubacimo ključ na to polje. Pri ubacivanju se bit validnosti tog ključa postavi na 1, svi sledeći nevalidni ključevi se postave na tu vrednost a svi prethodni na vrednost prethodnog validnog ključa.

Pri brisanju se nakon pretrage za dati ključ, bit validnosti ključa samo postavi na 0 ukoliko postoji ili baci greška ukoliko ne postoji.

{| class="wikitable"
|+ Stanje povećane tabele nakon unosa ključa 6
| 5 || 6 || 6 || 18 || 22 || 22 || 23 || 25 || 28 || 38 || 40
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 0
|}
{| class="wikitable"
|+ Stanje povećane tabele nakon unosa ključa 29
| 5 || 6 || 6 || 18 || 22 || 22 || 23 || 25 || 25 || 29 || 38
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 1 || 1
|-
| colspan="11" | Takođe je moguće da se, uz napomenu, pri nailasku na ključ veći od traženog gleda levo umesto desno.
|}
{| class="wikitable"
|+ Stanje povećane tabele nakon unosa ključa 35
| 5 || 6 || 6 || 18 || 22 || 22 || 23 || 25 || 29 || 35 || 38
|-
| 1 || 1 || 0 || 1 || 0 || 0 || 0 || 1 || 1 || 1 || 1
|-
| colspan="11" | Postoje dva načina na koji možemo da rešimo situaciju kad naiđemo na 38 i ne možemo da ga pomerimo udesno:
* kažemo da se desila greška pošto ne možemo dalje da umećemo, ili
* pomerimo ključ 29 ulevo (preporučeno).
|}
{| class="wikitable"
|+ Stanje povećane tabele nakon uklanjanja ključa 18
| 5 || 6 || 6 || 18 || 22 || 22 || 23 || 25 || 29 || 35 || 38
|-
| 1 || 1 || 0 || 0 || 0 || 0 || 0 || 1 || 1 || 1 || 1
|}
Brisanjem ključa 23 dešava se greška jer taj ključ ne postoji.

== 5. zadatak ==
=== Postavka ===
Dato je stablo binarnog pretraživanja. Da li stablo zadato na slici zadovoljava kriterijum AVL stabla? Ukoliko ne, izvršiti balansiranje stabla po AVL kriterijumu, a zatim iz dobijenog stabla obrisati ključeve 55 i 20, pa u stablo umetnuti ključ 30. Prilikom brisanja, koristiti sledbenika. Prikazati izgled stabla nakon svake izvršene izmene.
20
/ \
17 32
/ / \
10 25 33
/ / \ \
5 22 27 57
/ \
55 71

=== Rešenje ===
<div class="mw-collapsible mw-collapsed" data-expandtext="Prikaži postupak" data-collapsetext="Sakrij postupak">
Vidimo da su kritični čvorovi ovde 17 i 33. Prvo radimo desnu rotaciju oko čvora 17:
20
/ \
10 32
/ \ / \
5 17 25 33
/ \ \
22 27 57
/ \
55 71
čime taj čvor više nije kritičan, ali zbog skraćivanja dužine levog podstabla čvor 20 postaje kritičan. Zatim radimo levu rotaciju oko čvora 33:
20
/ \
10 32
/ \ / \
5 17 25 57
/ \ / \
22 27 33 71
\
55
čime čvor 33 više nije kritičan. Na kraju, radimo levu rotaciju oko čvora 20:
32
/ \
20 57
/ \ / \
10 25 33 71
/ \ / \ \
5 17 22 27 55
Briše se čvor 55. Čvor je list tako da je brisanje trivijalno. Stablo ostaje balansirano nakon brisanja ovog čvora.
32
/ \
20 57
/ \ / \
10 25 33 71
/ \ / \
5 17 22 27
Brišemo čvor 20. Na njegovo mesto stavljamo njegovog sledbenika 22.
32
/ \
22 57
/ \ / \
10 25 33 71
/ \ \
5 17 27
Umećemo čvor 30 kao desnog sina 27.
32
/ \
22 57
/ \ / \
10 25 33 71
/ \ \
5 17 27
\
30
Njegovim umetanjem čvor 25 postaje kritičan pa zato radimo rotaciju ulevo oko njega i time dobijamo...
</div>
'''Konačno stablo:'''
32
/ \
22 57
/ \ / \
10 27 33 71
/ \ / \
5 17 25 30

== 6. zadatak ==
=== Postavka ===
[[Датотека:ASP2 K1 2016 zadatak 6 stablo.svg|thumb|Crveno-crno stablo iz postavke zadatka.]]
U crveno-crnom stablu sa slike se najpre izvrši brisanje ključa 35, a zatim umetanje ključeva 9, 43, 10. Prikazati izgled stabla nakon svake od navedenih promena.

=== Rešenje ===

== 7. zadatak ==
=== Postavka ===
<div class="abc-list">
# U pseudokodu napisati funkciju koja za AVL stablo zadate visine ''h'' izračunava najmanji broj čvorova koje stablo može da sadrži.
# Na kojoj visini može da se nalazi list najbliži korenu?
# Kako se nazivaju ovakva stabla i po čemu su dobila ime?
</div>

=== Rešenje ===
<div class="abc-list">
# Pseudokod je dat ispod.
# ''ceil(h / 2)''. Ovo je zato što su podstabla Fibonačijevih stabala isto Fibonačijeva stabla, tako da se najmanja visina lista izračunava kao najmanja visina lista Fibonačijevog stabla čija je visina za 2 manja od trenutnog uvećana za 1.
# Ovakva stabla, koja su najgori slučajevi AVL stabala, dobila su ime po Fibonačijevim brojevima  čija se rekurzivna definicija veoma malo razlikuje od rekurzivne definicije broja čvorova ovakvih stabala u zavisnosti od njihove visine.
</div>
{{Милокод|<nowiki>
AVL MIN NODES(h)
if h = 0 then
return 1
else if h = 1 then
return 2
else
return AVL_MIN_NODES(h - 1) + AVL_MIN_NODES(h - 2) + 1
end_if
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Za stablo binarnog pretraživanja koje sadrži ključeve K1 < K2 < ... < Kn i čiji je koren ključ Kr izvesti vezu cene stabla i cena podstabla. Obavezno objasniti postupak.

=== Rešenje ===
Cena podstabla se definiše kao:
: <math>C_{ij} = \sum_{k = i+1}^j p_k (h_k + 1) + \sum_{k = i}^j q_k h_k</math>
gde su <math>p_i</math> verovatnoće uspešnog, <math>q_i</math> neuspešnog pretraživanja a <math>h_i</math> visine čvorova <math>K_i</math>.

Uzimamo da su prvi čvor levog podstabla i poslednji čvor desnog podstabla trenutnog čvora po ''inorder'' poretku <math>K_i</math> i <math>K_j</math> a trenutni čvor <math>K_k</math>. Pošto je visina u formuli za cene levog i desnog podstabla sada povećana za 1, dobijamo da je ukupna cena trenutnog čvora jednaka:
: <math>C_{ij} = \left(\sum_{m = i+1}^{k-1} p_m (h_m + 2) + \sum_{m = i}^{k-1} q_m (h_m + 1)\right) + p_k + \left(\sum_{m = k+1}^{j} p_m (h_m + 2) + \sum_{m = k}^{j} q_m (h_m + 1)\right) =</math>
: <math>= \left(\sum_{m = i+1}^{k-1} p_m (h_m + 1) + \sum_{m = i+1}^{k-1} p_m + \sum_{m = i}^{k-1} q_m h_m + \sum_{m = i}^{k-1} q_m\right) + p_k + \left(\sum_{m = k+1}^{j} p_m (h_m + 1) + \sum_{m = k+1}^{j} p_m + \sum_{m = k}^{j} q_m h_m + \sum_{m = k}^{j} q_m\right) =</math>
: <math>= \left(\sum_{m = i+1}^{k-1} p_m (h_m + 1) + \sum_{m = i}^{k-1} q_m h_m\right) + \left(\sum_{m = k+1}^{j} p_m (h_m + 1) + \sum_{m = k}^{j} q_m h_m\right) + w_{ij} =</math>
: <math>= C_{i,k-1} + C_{k,j} + w_{ij}</math>

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К1 2015

2024-09-13T00:09:07Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K1_1516.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Skup ključeva smešten je u stablo binarnog pretraživanja. Nakon brisanja ključa 12, dobijen je izgled stabla prikazan na slici. Pod pretpostavkom da je ključ 9 umetnut u stablo nakon ključa 12, da nije bilo prethodnih brisanja ključeva i da se prilikom brisanja koristi sledbenik, prikazati izgled stabla neposredno pre brisanja ključa 12.
6
/ \
5 15
/ / \
3 7 18
\ \ /
4 9 16
/ \
8 17

=== Rešenje ===
6
/ \
5 15
/ / \
3 12 18
\ / /
4 7 16
\ \
9 17
/
8

6
/ \
5 15
/ / \
3 7 18
\ \ /
4 12 16
/ \
9 17
/
8

6
/ \
5 12
/ / \
3 7 15
\ \ \
4 9 18
/ /
8 16
\
17

6
/ \
5 12
/ / \
3 7 18
\ \ /
4 9 15
/ \
8 16
\
17

6
/ \
5 12
/ / \
3 7 18
\ \ /
4 9 16
/ / \
8 15 17

== 2. zadatak ==
=== Postavka ===
Dat je krug K, sa centrom u tački C, poluprečnika r. Data je duž D čije je teme T1 unutar K, a teme T2 izvan K. Koristeći metodu binarne pretrage kao ideju, napisati u pseudokodu funkciju koja približno određuje tačku preseka K i D. Preciznost aproksimacije kontrolisati posebnim parametrom funkcije.

=== Rešenje ===
Koristi se modifikovana binarna pretraga koja se izvršava dok se tačka ne nađe na kružnici ili dok je greška manja od <code>err</code>. Parametar <code>err</code> je prosleđen funkciji.
{{Милокод|<nowiki>
INTERSECT(K, D, err)
low = T1
high = T2
prev = low
while true do
x(mid) = (x(low) + x(high)) / 2
y(mid) = (y(low) + y(high)) / 2
dist = distance(C, mid)
if (dist = r) or (distance(mid, prev) < err) then
return mid
else if dist > r then
high = mid
else
low = mid
end_if
prev = mid
end_while
</nowiki>}}
{{Милокод|<nowiki>
DISTANCE(A, B)
return sqrt(pow(x(A) - x(B), 2) + pow(y(A) - y(B), 2))
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Stabla binarnog pretraživanja
<div class="abc-list">
# Na koji način se u stablo binarnog pretraživanja može dozvoliti umetanje ključeva sa istom vrednošću?
# Napisati u pseudokodu iterativnu implementaciju funkcije koja umeće vrednost ''x'' u stablo binarnog pretraživanja na koje pokazuje pokazivač ''root''. U stablo je dozvoljeno umetati ključeve sa istom vrednošću.
</div>

=== Rešenje ===
Postoje dva načina na koje se može dozvoliti umetanje ključeva sa istom vrednošću u binarno stablo pretraživanja:
# U svakom čvoru stabla se čuva niz čvorova koje imaju istu vrednost ključa - ovim se postiže da se struktura stabla ne povećava.
# Čvorovi sa istom vrednošću se tretiraju kao veći, odnosno čuvaju u desnom podstablu - ovim se postiže veća pogodnost kod korišćenja za realizaciju struktura poput prioritetnog reda.
{{Милокод|<nowiki>
BST INSERT MOD(root, x)
node = GETNODE
value(node) = x
if root = nil then
root = node
return
end_if
p = root
while true do
if key(p) ≤ x then
if right(p) = nil then
right(p) = node
break
else
p = right(p)
end_if
else
if left(p) = nil then
left(p) = node
break
else
p = left(p)
end_if
end_if
end_while
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Crveno-crna stabla
<div class="abc-list">
# Definisati pojam crne visine (eng. ''black height'') nekog čvora crveno-crnog stabla.
# Napisati u pseudokodu funkciju koja u zadatom crveno-crnom stablu određuje crnu visinu zadatog čvora X.
</div>

=== Rešenje ===
Crna visina nekog čvora je broj crnih čvorova na putu od tog čvora do listova, i po definiciji crveno-crnog stabla je jednaka za sve puteve do listova.
{{Милокод|<nowiki>
BH CALC(x)
p = x
bh = 0
while p ≠ nil do
if (black(p)) then
bh = bh + 1
end_if
p = left(p)
end_while
return bh
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Neka se u prazno AVL stablo redom umeću ključevi 35, 75, 51, 61, 65, 80, 44, 48, 39, 77, a zatim brišu ključevi 65, 44, 80. Prilikom brisanja, koristiti sledbenika. Prikazati izgled stabla nakon svakog izvršenog umetanja i brisanja.

=== Rešenje ===
Postupak umetanja možete simulirati u nekom od [https://www.cs.usfca.edu/~galles/visualization/AVLtree.html simulatora] za AVL stabla. Nakon umetanja dobije se sledeće stablo:
65
/ \
44 77
/ \ / \
35 51 75 80
\ / \
39 48 61
Po brisanju čvora 65, njegov sledbenik čvor 75 dolazi na njegovo mesto:
75
/ \
44 77
/ \ \
35 51 80
\ / \
39 48 61
Zatim se briše čvor 44 i njegov sledbenik čvor 48 dolazi na njegovo mesto:
75
/ \
48 77
/ \ \
35 51 80
\ \
39 61
Na kraju, briše se čvor 80 čime čvor 75 postaje kritičan čvor pa radimo rotaciju ulevo oko njega:
48
/ \
35 75
\ / \
39 51 77
\
61

== 6. zadatak ==
{{делимично решено}}
=== Postavka ===
[[Датотека:ASP2 K1 2015 zadatak 6 stablo.svg|thumb|Crveno-crno stablo iz postavke zadatka.]]
U crveno-crno stablo sa slike se najpre vrši umetanje ključa 50, a zatim vrši brisanje ključa 13. Prikazati izgled stabla nakon svake od navedenih promena.

=== Rešenje ===

== 7. zadatak ==
=== Postavka ===
Dati pseudokod i objasniti algoritam određivanja prethodnika čvora sa zadatom adresom ''x'' u stablu binarnog pretraživanja. '''Napomena:''' Prilikom kretanja uz stablo ne koristiti proveru na pripadnost podstablu, već na vrednosti ključeva.

=== Rešenje ===
Prvo proveravamo da li čvor ima levo podstablo. Ukoliko ima, vraćamo najdesniji čvor u levom podstablu kao prethodnika čvora. Ukoliko nema, penjemo se uz stablo poredeći ključ čvora ''x'' sa ključevima njegovih roditelja i ako nađemo čvor sa manjim ključem vratimo ga.
{{Милокод|<nowiki>
PRED NODE(x)
if left(x) = nil then
p = parent(x)
while p ≠ nil do
if key(p) < key(x) then
return p
end_if
p = parent(p)
end_while
return nil
else
p = left(x)
while right(p) ≠ nil do
p = right(p)
end_while
return p
end_if
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
a) Objasniti jednu strategiju za dobijanje suboptimalnog stabla binarnog pretraživanja koja uključuje i uspešna i neuspešna pretraživanja. b) Postupak ilustrovati po koracima ako su dati ključevi <math>K_i, i = 1..6</math>, sa verovatnoćama uspešnog pretraživanja <math>p_i, i = 1..6</math>, (0.1, 0.05, 0.05, 0.1, 0.05, 0.1, respektivno) i verovatnoćama neuspešnog pretraživanja <math>q_i, i = 0..6</math> (0.2, 0.05, 0.05, 0.0, 0.0, 0.05, 0.2, respektivno).

=== Rešenje ===
<div class="abc-list">
# Možemo formirati suboptimalno binarno stablo pretraživanja odabiranjem korena sa najmanjom razlikom težina između podstabala i rekurzivno ponavljati proces za oba podstabla.
#
## Kandidati za koren su nam K3 i K4. K3 nam daje razliku -0.05 između težina podstabla, a K4 0.1, pa zato biramo K3 i proces nastavljamo za [1, 2] i [4, 5, 6].
## Sa K1 u korenu razlika između levog i desnog podstabla od levog suboptimalnog podstabla je -0.05 a sa K2 je 0.3, tako da postavljamo K1 kao koren levog podstabla.
## Sa K6 u korenu razlika između levog i desnog podstabla od desnog suboptimalnog podstabla je 0, sa K5 -0.25 a sa K4 -0.4, tako da postavljamo K6 kao koren desnog podstabla.
## Na kraju, sa K5 kao korenom levog podstabla od desnog podstabla dobijamo da je razlika težina 0.05, a sa K4 -0.1, tako da K5 postavljamo za koren levog podstabla od desnog podstabla.
</div>
3
/ \
1 6
\ /
2 5
/
4

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К1 2014

2024-09-13T00:09:06Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/SI2AS2_K1_1415.pdf Zadaci na stranici predmeta.]

'''Prvi kolokvijum 2014. godine''' održan je 28. oktobra 2014.

== 1. zadatak ==
=== Postavka ===
'''(5p)''' Neka je dat uređeni niz M i sekvenca ključeva 15, 8, 33, 21, 25 na koje se vrši pretraga. Predložiti neophodne strukture podataka i prikazati njihov sadržaj nakon simultane pretrage zadatog niza na više ključeva.
{| class="wikitable"
|+ Uređeni niz M
! 1
! 2
! 3
! 4
! 5
! 6
! 7
! 8
! 9
! 10
! 11
! 12
! 13
! 14
! 15
|-
| 1
| 3
| 7
| 10
| 11
| 15
| 17
| 20
| 25
| 28
| 29
| 31
| 33
| 36
| 40
|}
=== Rešenje ===
Neophodan je dodatni vektor za elemente koji su već nađeni i njihove indekse. Nakon simultane pretrage zadatog niza na više ključeva, vektor će ovako izgledati (primetimo da se brojevi 8 i 21 ne nalaze u nizu):
{| class="wikitable"
|-
! 15
! 25
! 33
|-
| 6
| 9
| 13
|}
== 2. zadatak ==
=== Postavka ===
'''(10p)''' Za stablo binarnog pretraživanja sa slike odrediti prosečan broj pristupa prilikom uspešne pretrage i prilikom neuspešne pretrage, ako je poznato da je vrednost ključeva koji se mogu umetnuti u stablo u opsegu od 1 do 30. Smatrati da su svi ključevi jednako verovatni.
[[Датотека:ASP2 K1 2014 Zadatak 2.png|thumb|600px|center|Stablo iz postavke zadatka]]
=== Rešenje ===
Iz nepoznatog razloga rešenje ovog zadatka je bilo dato u pdfu sa zadacima.
{| class="wikitable"
|-
! Prosečan broj pristupa prilikom uspešne pretrage:
! 36/11=3.28
|-
| Prosečan broj pristupa prilikom neuspešne pretrage:
| 62/19=3.26
|}
== 3. zadatak ==
=== Postavka ===
'''(10p)''' Prikazati po koracima izgled binarnog stabla pretraživanja sa slike, ukoliko izvrši
sledeća sekvenca operacija: umetanje ključeva 19 i 2, a zatim brisanje ključeva 15, 5 i 22.
Prilikom brisanja, koristiti '''sledbenika'''.
[[Датотека:ASP2 K1 2014 Zadatak 3.png|thumb|600px|center|Stablo iz postavke zadatka]]
=== Rešenje ===
[[Датотека:ASP2 K1 2014 Zadatak 3 korak 1.svg|thumb|600px|center|Stablo nakon umetanja ključeva 19 i 2]]
[[Датотека:ASP2 K1 2014 Zadatak 3 korak 2.svg|thumb|600px|center|Stablo nakon brisanja ključeva 15, 5 i 22]]
== 4. zadatak ==
=== Postavka ===
'''(10p)''' U AVL stablo se redom umeću ključevi: 5, 3, 4, 6, 12, 9, 7, 16, 18. Prikazati, postupno, izgled stabla nakon svakog umetanja ključa.
=== Rešenje ===
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 1.png|thumb|600px|center|Stablo nakon umetanja ključeva 5 i 3]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 2.png|thumb|600px|center|Stablo nakon umetanja ključa 4]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 3.png|thumb|600px|center|Stablo nakon umetanja ključa 6]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 4.png|thumb|600px|center|Stablo nakon umetanja ključa 12]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 5.png|thumb|600px|center|Stablo nakon umetanja ključa 9]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 6.png|thumb|600px|center|Stablo nakon umetanja ključa 7]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 7.png|thumb|600px|center|Stablo nakon umetanja ključa 16]]
[[Датотека:ASP2 K1 2014 Zadatak 4 korak 8.png|thumb|600px|center|Konačni izgled stabla]]

== 5. zadatak ==
=== Postavka ===
'''(15p)''' Napisati u pseudokodu operaciju '''dvostruke rotacije ulevo'''. Nacrtati '''opštu''' sliku koja objašnjava napisani pseudokod i na kojem su čvorovi obeleženi odgovarajućim identifikatorima upotrebljenim u pseudokodu.
=== Rešenje ===
U ovom zadatku je iskorišćeno rešenje iz knjige, tj ono što je u knjizi nazvano dvostrukom rotacijom (dve rotacije suprotnog smera, prvo leva oko levog sina kritičnog čvora a zatim desna oko kritičnog čvora). Dve rotacije ulevo oko kritičnog čvora '''nemaju smisla'''.<ref>Na K1 2022 je bio isti ovaj zadatak i jedan student je uradio dve rotacije ulevo oko x, na šta je Mišić rekao da to nema smisla iako tako piše u zadatku.</ref>
{{Милокод|<nowiki>
L-ROT(x)
y = x.right
temp = y.left
y.left = x
x.right = temp
</nowiki>}}

{{Милокод|<nowiki>
R-ROT(x)
y = x.left
temp = y.right
y.right = x
x.left = temp
</nowiki>}}

{{Милокод|<nowiki>
L-DOUBLE-ROT(x)
L-ROT(x.left)
R-ROT(x)
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
'''(15p)''' Napisati u pseudokodu i kratko objasniti iterativnu implementaciju algoritma za binarno pretraživanje na ključ k, ukoliko je veličina tabele nepoznata. Smatrati da postoji funkcija IN(index) koja vraća vrednost true ukoliko zadati indeks pripada tabeli, a false u suprotnom.
=== Rešenje ===
U ovom zadatku se koristi algoritam za '''Binarno pretraživanje u tabeli nepoznate veličine''' iz knjige.
{{Милокод|<nowiki>
EX-SEARCH(L, key)
high=low=1;
if(IN(high)=false) return -1;
if(key = L[1]) return 1;
while(IN(high)=true && key>L[high]) high *= 2;
low = high/2;
while(low<=high)
mid = (low+high)/2;
if(key=L[mid]) return mid;
if(key<L[mid]) high = mid-1;
else low = mid+1;
end_while
return -1;
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
'''(15p)''' Objasniti šta je samopodešavajuće stablo, kao i motivaciju za ovu strukturu. Ukratko načelno opisati operacije pretraživanja, umetanja i brisanja. Koji algoritam pretraživanja nizova koristi sličnu strategiju?
=== Rešenje ===
Samopodešavajuća stabla su stabla koja održavaju balansiranost bez nekog eksplicitnog kriterijuma pri umetanju i brisanju. Umesto toga, reorganizacija stabla se vrši pri svakom pristupu stablu, pa i pretraživanju. Pritom se ključevi kojima se češće pristupa postavljaju bliže korenu, tako da im se omogući brži pristup pri narednim obraćanjima. Za ovo se koriste operacije koje se zasnivaju na rotacijama. Motivacija je optimizacija zasnovana na vremenskoj lokalnosti, slično kao kod transpozicije i prebacivanja na početak kod sekvencijalne pretrage. Pretraživanje se vrši tako što nađeni ili poslednji ne-null ključ nizom rotacija prebacujemo u koren. Umetanje se vrši tako što prvo uradimo pretraživanje na zadati ključ, a ako on ne postoji, umetnemo ga na odgovarajuće mesto. Brisanje se vrši tako što se prvo vrši pretraživanje na zadati ključ, pa ako se on pronađe, prebacuje se u koren, koji se potom briše i menja prethodnikom.

== 8. zadatak ==
=== Postavka ===
'''(20p)''' Odgovoriti na sledeća pitanja u vezi optimalnog stabla binarnog pretraživanja. '''Napomena:''' Svaki korišćeni simbol treba definisati i objasniti.
<div class="abc-list">
# Precizno definisati optimalno stablo binarnog pretraživanja za ključeve sa vrednostima Kn < Kn+1 < ... < Km.
# Ako je ključ Kr koren ovog stabla, nacrtati opštu sliku.
# Izraziti cenu stabla preko cena njegovih podstabala.
</div>
=== Rešenje ===
<div class="abc-list">
# Optimalno stablo binarnog pretraživanja je ono stablo čija je cena najmanja, gde cenu definišemo kao: <math>C = \sum_{i}^{m-n} p_{i}(h_{i} + 1) + \sum_{i}^{m-n} q_{i}h_{i}</math>, gde su Pi verovatnoće pristupa ključevima Kn...Km, a Qi verovatnoće pristupa eksternim čvorovima.
# [[Датотека:ASP2 K1 2014 Zadatak 8.png|thumb|600px|center|Opšta slika optimalnog stabla binarnog pretraživanja]]
# <math>C_{ij} = min\left \{ C_{i-1k-1} + C_{kj} \right \} + w_{ij}</math>.

<math>w_{ij} = q_{i} + p_{i+1} + q_{i+1} + ... + p_{j} + q_{j}</math>.

<math>i< k\leq j</math>
</div>
== Napomene ==
<references/>
[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП2/К1 2011

2024-09-13T00:09:06Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
'''Prvi kolokvijum 2011. godine''' održan je 24. oktobra 2011. Postavka zadataka je dostupna sa [https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/arhiva/SI2AS2_K1_1112.pdf stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
'''(30p)''' Koristeći algoritam binarne pretrage uređenog vektora kao osnovu, napisati na jeziku C (ili C++) funkciju za pretragu uređenog vektora jedinstvenih celobrojnih ključeva dužine n na zadati ključ deljenjem intervala pretrage na tri podintervala približno jednake dužine. Napisati glavni program koji demonstrira upotrebu prethodne funkcije. Koristiti fiksne podatke (nije potrebno čitati podatke iz datoteke ili standardnog ulaza). Komentarisati vremensku i prostornu složenost napisane funkcije. Porediti vremensku složenost napisane funkcije i algoritma binarne pretrage.
=== Rešenje ===
Vremenska složenost je <math>O(log_3{n})</math>, a prostorna <math>O(n)</math>.
{{Милокод|<nowiki>
FUN(arr,key)
high = n;
low = 1;
while(low <= high)
left = (low+high)/3;
right = 2(low+high)/3;
if(arr[left]=key) return left;
if(arr[right]=key) return right;
if(key < arr[left]) high = left-1;
if(key > arr[right]) low = right+1;
if(key>arr[left] and key<arr[right])
low = left+1;
high = right-1;
end_if
end_while
return 0;
</nowiki>}}
== 2. zadatak ==
=== Postavka ===
'''(20p)''' U stablo binarnog pretraživanja se redom umeću sledeći ključevi: 22, 31, 24, 28, 26, 41, 45, 10, 6, 8, 9, 7, 4, 5, 2. Nakon umetanja se redom brišu ključevi: 41, 6, 22, 10. Prikazati izgled stabla pretraživanja nakon svake od navedenih izmena. Ako dobijeno stablo ne zadovoljava kriterijum balansiranosti AVL stabla, transformisati stablo primenom osnovnih transformacija za održavanje balansiranosti da bi se dobilo AVL stablo. Prikazati izgled stabla nakon primene svake transformacije. Napomena: prilikom brisanja ključeva, koristiti sledbenike.
=== Rešenje ===
[[Датотека:ASP K1 2011 Zadatak 2.svg|thumb|600px|center|Stablo nakon umetanja ključeva 22,31,24,28,26 i 41]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 2.svg|thumb|600px|center|Stablo nakon umetanja ključeva 45,10,6 i 8]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 3.svg|thumb|600px|center|Stablo nakon umetanja ključeva 9 i 7]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 4.svg|thumb|600px|center|Stablo nakon umetanja ključeva 4 i 5]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 5.svg|thumb|600px|center|Stablo nakon svih umetanja]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 6.svg|thumb|600px|center|Stablo nakon brisanja ključeva 41,6 i 22]]
[[Датотека:ASP K1 2011 Zadatak 2 korak 7.svg|thumb|600px|center|Stablo nakon svih brisanja]]
== 3. zadatak ==
=== Postavka ===
'''(20p)''' Definisati AVL stablo i kritični čvor. Kada se javlja potreba za dvostrukom rotacijom? Objasniti ovu operaciju i ilustrovati opštim slikama.
=== Rešenje ===
AVL stablo je stablo binarnog pretraživanja koje ispunjava kriterijum da svaki čvor mora da ima balans 0, 1 ili -1, gde balans predstavlja razliku visina levog i desnog podstabla.

Kritični čvor je koren najmanjeg podstabla koje nije visinski balansirano.

Dvostruka rotacija se vrši kada kritični čvor i sin sa one strane na koju naginje kritični čvor naginju na suprotne strane (npr kritični čvor na desno a njegov levi sin na levo). Prvo se vrši odgovarajuća rotacija nad sinom tako da kritični čvor i sin naginju na istu stranu, a zatim se vrši rotacija u suprotnu stranu nad kritičnim čvorom, čime se dobija visinski balansirano stablo.

[[Датотека:ASP K1 2011 Zadatak 3.svg|thumb|300px|center|Početno stanje]]
[[Датотека:ASP K1 2011 Zadatak 3 korak 2.svg|thumb|300px|center|Stablo nakon prve rotacije udesno oko sina]]
[[Датотека:ASP K1 2011 Zadatak 3 korak 3.svg|thumb|300px|center|Stablo nakon rotacije ulevo oko kritičnog čvora]]

== 4. zadatak ==
{{делимично решено}}
=== Postavka ===
'''(30p)''' Pitanja:
<div class="abc-list">
# Dati pseudokod i objasniti sekvencijalno pretraživanje sa graničnikom. Kakvo poboljšanje ono donosi?
# Objasniti organizaciju 2-3-4 stabla. Kakva je njihova prednost i kako se implementiraju?<ref>Ovo više nije gradivo K1</ref>
# Objasniti strategiju dobijanja približno optimalnog stabla koja uzima u obzir i uspešna i neuspešna pretraživanja.
</div>
=== Rešenje ===
c) Približno optimalno stablo se formira od korena na dole i bira se tako da se minimizira težina levog i desnog podstabla, a zatim se u blizini korena traži mogući novi koren sa većom verovatnoćom pristupa, i ako se takav čvor pronađe, pređašnji čvor se pomera malo ulevo ili udesno. Postupak se ponavlja rekurzivno.

== Napomene ==
<references/>
[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП2/К1 2009

2024-09-13T00:09:05Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
'''Prvi kolokvijum 2009. godine''' održan je 29. oktobra 2009. Postavka zadataka je dostupna sa [https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/arhiva/SI2AS2_K1_0910.pdf stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
'''(20p)'''
<div class="abc-list">
# Objasniti strategiju binarnog pretraživanja. Koji su preduslovi primene binarne pretrage? Koje uslove mora da zadovolji struktura podataka nad kojom se primenjuje binarno pretraživanje da bi primena bila efikasna?
# Nad tabelom u koju su umetnuti ključevi 2, 18, 33, 14, 25, 5, 7, 12, 11, 16, 20, 22, 26 se vrši pretraga na ključeve 14, 7 i 18 primenom strategije binarnog pretraživanja. Odrediti prosečan broj poređenja vrednosti ključeva.
# Napisati na jeziku C (ili C++) funkciju koja u zadatom nizu celih brojeva zadate dužine traži zadati celobrojni ključ. Funkcija vraća indeks pod kojim je ključ nađen u nizu ili -1 u slučaju neuspešne pretrage.
</div>
=== Rešenje ===
<div class="abc-list">
# Strategija binarnog pretraživanja se zasniva na nalaženju medijane, a zatim polovljenju intervala pretraživanja. Postupak se ponavla sve dok se ne nađe traženi ključ ili se zaključi da se on ne nalazi u nizu. Preduslovi su da je niz uređen i da je moguć linearan pristup. Struktura mora biti linearna.
# Pri pretrazi na ključ 14 vrše se 4 poređenja, kao i pri pretrazi na ključ 18. Pri pretrazi na ključ 7 vrše se 2 poređenja, što nam u proseku daje <math>\frac{10}{3} = 3.33</math> poređenja.
# {{Милокод|<nowiki>
BIN(arr, key, n)
high = n;
low = 1;
while(high>=low)
mid = (low+high)/2;
if(arr[mid]=key) return mid;
if(arr[mid]<key) low = mid+1;
else high = mid-1;
end_while
return -1;
</nowiki>}}
</div>
== 2. zadatak ==
=== Postavka ===
'''(30p)''' U AVL stablo prikazano na slici se redom umeću sledeći ključevi: 20, 21, 19, 7, 10, 12, 14. Nakon umetanja se redom brišu ključevi: 22, 15, 18. Prikazati izgled stabla nakon svake od navedenih izmena. Izračunati prosečan broj pristupa stablu prilikom uspešne pretrage nakon svih umetanja i u konačnom stanju. '''Napomena''': prilikom brisanja ključeva, koristiti sledbenike.
[[Датотека:ASP2 K1 2009 Zadatak 2.png|thumb|600px|center|Stablo iz postavke zadatka]]
=== Rešenje ===
[[Датотека:ASP2 K1 2009 Zadatak 2 umetanje.svg|thumb|600px|center|Stablo nakon svih umetanja]]
[[Датотека:ASP2 K1 2009 Zadatak 2 brisanje.svg|thumb|600px|center|Stablo nakon svih brisanja]]
Nakon svih umetanja: <math>PI = \sum R_{i} \cdot n_{i} = 3\cdot5 + 4\cdot4 + 4\cdot3 + 5 = 15+16+12+5=48</math>, pa je <math>S_{n} = \frac{48}{14} = 3.43</math>

Nakon svih brisanja: <math>PI = \sum R_{i} \cdot n_{i} = 33</math>, pa je <math>S_{n} = \frac{33}{11} = 3</math>.

== 3. zadatak ==
=== Postavka ===
'''(20p)''' Dati pseudokod i objasniti algoritam za istovremeno sekvencijalno pretraživanje uređenog niza na više ključeva. Kolika je složenost algoritma?
=== Rešenje ===
Pretraživanje ide od početka niza K sa prvim ključem iz S dok se ne pronađe (i njegova pozicija zapamti u P) ili do prve veće vrednosti. Pretraživanje na sledeći ključ iz S počinje tamo gde se sa pretraživanjem na prethodni ključ stalo, pa se zato niz K prolazi samo jednom. Niz K je rastuće uređeni niz sa n ključeva koji se pretražuje na pojavu m ključeva zadatih u nizu S. Izlaz predstavlja vektor P gde se na poziciji koja odgovara ključu u nizu S nalazi pozicija ključa u nizu K, ako se on tamo pronađe, ili vrednost 0 ako se ne pronađe. Složenost ovog algoritma je O(n) za slučaj kada je m << n.
{{Милокод|<nowiki>
SEQ-SEARCH-MUL(K,S)
for(int i=0;i<m;i++) P[i] = 0;
i=j=1;
while(i<=n) and (j<=m)
while(i<n) and (S[j] > K[i]) i++;
if(S[j] = K[i]) P[j] = i;
j++;
end_while
return P;
</nowiki>}}
== 4. zadatak ==
=== Postavka ===
'''(30p)''' Pitanja:
<div class="abc-list">
# Kolike su performanse pretraživanja u stablu binarnog pretraživanja u najboljem, srednjem i najgorem slučaju i diskutovati implikacije.
# Definisati Fibonacci-jeva stabla i navesti njihove glavne osobine.
# Zašto se uvode 2-3 stabla? Objasniti njihovu organizaciju i glavne osobine.
</div>
=== Rešenje ===
<div class="abc-list">
# Složenost je u funkciji visine - O(h). U najboljem slučaju h = log(n), a u najgorem h = n.
# Fibonačijevo stablo je najgori slučaj AVL stabla, tj. stablo najveće visine za određen broj čvorova. Broj čvorova u Fibonačijevom stablu visine h je <math>n_{h} = n_{h-1} + n_{h-2} + 1</math>. Svi čvorovi imaju balans 1. Brisanje bilo kog čvora smanjuje visinu stabla. Svaki koren će biti Fibonačijev broj.
# 2-3 stabla se uvode da bi se osigurala balansiranost, pa su sve operacije O(log(n)). Glavno svojstvo je postojanje 3-čvorova, koji imaju levo, desno i srednje podstablo, i time se omogućava da svi listovi budu na istom nivou. 3-čvorovi imaju dva ključa, K1 i K2 i u zavisnosti od intervala pripadanja određujemo podstablo.
</div>

[[Категорија:Рокови]]
[[Категорија:АСП2]]

АСП1/К3 2019

2024-09-13T00:09:05Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K3_1819.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
[[{{ns:6}}:ASP1 K3 2019 zadatak 1 graf.png|thumb|Graf iz zadatka 1.]]
Na slici je prikazan netežinski usmereni graf.
<div class="abc-list">
# Prikazati redosled čvorova nakon obilaska grafa sa slike po širini, ukoliko se kao početni čvor zada čvor A. Čvorovi se ubacuju u strukturu prema leksikografskom poretku ukoliko postoji više mogućnosti.
# Prikazati redosled čvorova nakon iterativnog obilaska grafa sa slike po dubini, ukoliko se kao početni čvor zada čvor A. Čvorovi se ubacuju u strukturu prema leksikografskom poretku ukoliko postoji više mogućnosti.
</div>

=== Rešenje ===
<div class="abc-list">
# ABICDMFLK
# AIBCMLKDF
</div>

== 2. zadatak ==
=== Postavka ===
U nekom malom mestu se renovira mreža ulica. Sve ulice u mestu su dvosmerne. Da bi se renoviralo što više ulica, potrebno je obezbediti da između svaka dva važna objekta u mestu (škola, bolnica, opština, itd.) postoji put i da ukupna dužina svih otvorenih puteva za saobraćaj u mestu bude minimalna. Ukoliko je mreža ulica i važnih objekata predstavljena neusmerenim težinskim grafom sa slike, navesti koji algoritam bi se mogao iskoristiti za rešavanje ovog problema i njegovom primenom odrediti ulice koje treba da ostanu otvorene za saobraćaj tokom renoviranja, prema navedenim uslovima. Prikazati postupak.

=== Rešenje ===
Mogao bi se primeniti Primov ili Kruškalov algoritam za dobijanje minimlanog obuhvatnog stabla. U narednom postupku biće korišćen Primov algoritam:
# A-E
# E-F
# E-D
# D-C
# C-H
# H-I
# C-B
# H-G
# G-I
Grafovi se nalaze ispod.
<gallery>
ASP1 K3 2019 zadatak 2 graf.svg | Pojednostavljen graf iz postavke zadatka.
ASP1 K3 2019 zadatak 2 MST.svg | Minimalno obuhvatno stablo.
</gallery>

== 3. zadatak ==
=== Postavka ===
Neka se posmatra sekvencijalni programski kod koji se izvršavana na nekoj 3A mašini. Prvi operand instrukcije je odredišni, a preostala dva su izvorišni operandi. Prilikom prevođenja, prevodilac može da preuredi redosled izvršavanja instrukcija da bi izvršio određene optimizacije. Međutim, preuređivanje redosleda dve instrukcije se može izvršiti samo ukoliko ne postoji zavisnosti po podacima između njih. Zavisnost po podacima između instrukcija postoji ukoliko se odredišni operand (rezultat) ranije operacije koristi kao izvorišni operand kasnije operacije.
<div class="abc-list">
# Opisati model grafa koji se može iskoristiti za modelovanje zavisnosti po podacima između instrukcija.
# Objasniti koji algoritam bi se mogao iskoristiti za pronalaženje svih mogućih redosleda izvršavanja instrukcija na osnovu zadatog grafa zavisnosti po podacima.
# Na primeru zadatog programskog koda, nacrtati graf zavisnosti po podacima i odrediti (napisati) još jedan moguć redosled izvršavanja instrukcija koji zadovoljava prisutne zavisnosti po podacima.
</div>
ADD A, B, C
MUL C, E, D
SUB B, E, C
ADD A, D, E
SUB E, F, G
DIV D, F, H
ADD G, F, H

=== Rešenje ===
<div class="abc-list">
# U pitanju je acikličan netežinski usmeren graf u kom čvorovi predstavljaju instrukcije a grane od jednog ka drugom čvoru predstavljaju zavisnost izvorišnih operanada drugog čvora od odredišnog operanda prvog.
# Može se iskoristiti modifikacija topološkog sortiranja gde se nakon svakog prikupljanja čvorova sa ulaznim stepenom 0 za svaki od njih pokušavaju naći svi putevi koji na tom mestu sadrže taj čvor. Rekurzivna implementacija ovog algoritma je data ispod (gde su putevi predstavljeni ulančanim listama).
# Graf se sastoji od svih čvorova odvojenih i jedne grane između čvorova <code>MUL C, E, D</code> i <code>SUB B, E, C</code>.
#* <code>ADD A, B, C</code>
#* <code>ADD A, D, E</code>
#* <code>MUL C, E, D</code>
#* <code>SUB B, E, C</code>
#* <code>SUB E, F, G</code>
#* <code>DIV D, F, H</code>
#* <code>ADD G, F, H</code>
</div>
{{Милокод|<nowiki>
TOP SORT ALL PATHS R(G)
if V = {} then
return nil
end_if
return_paths = {}
for {n : (n ∈ V) and ((u, n) ∉ E)} do
MARK_REMOVED(G, n)
paths = TOP_SORT_ALL_PATHS_R(G)
for path ∈ paths do
new_path = GETNODE
value(new_path) = n
next(new_path) = path
path = new_path
end_for
UNMARK_REMOVED(G, n)
return_paths = return_paths + paths
end_for
return return_paths
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Posmatra se usmeren netežinski graf. Napisati iterativnu funkciju u pseudokodu koja za prosleđeni graf sa datim brojem čvorova ''n'' pronalazi sve čvorove koji su putevima dužine tačno ''k'' udaljeni od zadatog početnog čvora ''id''.

=== Rešenje ===
Implementacija ispod čvorove vraća u ulančanoj listi.
{{Милокод|<nowiki>
K-DISTANCE(G, n, k, id)
dist[n]
for i = 1 to n do
dist[i] = ∞
end_for
dist[id] = 0
curr_dist = 0
tail = head = GETNODE(id)
next(head) = GETNODE(0)
head = next(head)
curr = 0
temp = nil
while (tail ≠ nil) and (curr_dist ≠ k) do
curr = value(tail)
if curr = 0 then
curr_dist = curr_dist + 1
if head ≠ tail then
next(head) = GETNODE(0)
head = next(head)
end_if
else
for node ∈ {v : (curr, v) ∈ E} do
if dist[node] ≠ curr_dist + 1 then
dist[node] = curr_dist + 1
next(head) = GETNODE(node)
head = next(head)
end_if
end_for
end_if
temp = tail
tail = next(tail)
FREENODE(temp)
end_while

return tail
</nowiki>}}
{{Милокод|<nowiki>
GETNODE(node)
ALLOCATE(node)
next(node) = nil
value(node) = value
return node
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Floyd algoritam
<div class="abc-list">
# Na slici je dat izgled matrica D i T dobijenih kao izlaz Floyd algoritma. Nacrtati mogući izgled ulaznog grafa i obrazložiti odgovor.
# Napisati u pseudokodu funkciju koja na osnovu matrice T dobijene kao izlaz ''Floyd''-ovog algoritma rekonstruiše najkraći put od čvora A do čvora C takav da se na njemu nalazi čvor B.
</div>
{| class="wikitable"
|+ Matrica D
|-
| 0
| 2
| 7
|-
| ∞
| 0
| 5
|-
| ∞
| ∞
| 0
|}
{| class="wikitable"
|+ Matrica T
|-
| 0
| 1
| 2
|-
| 0
| 0
| 2
|-
| 0
| 0
| 0
|}

=== Rešenje ===
[[{{ns:6}}:ASP1 K3 2019 zadatak 5 graf.svg|thumb|Graf iz zadatka 5.]]
<div class="abc-list">
# Pretpostavljajući da nema grana negativne težine vidimo da je najkraći put dužine 2 i zato sigurno mora biti direktna grana između A i B. Pošto vidimo da matrica D nije simetrična pretpostavljamo da se radi o usmerenom težinskom grafu. Na osnovu trenutnog grafa i D matrice vidimo da je grana B-C težine 5, i sve ostalo se slaže.
# U pseudokodu ispod podrazumeva se da je put predstavljen ulančanom listom. Ukoliko je vraćeno nil to znači da nema puta.
</div>
{{Милокод|<nowiki>
PATH(T, A, B, C)
curr = GETNODE(C)
next = nil
while value(curr) ≠ B do
if T[B][value(curr)] = 0 then
return nil
end_if
next = GETNODE(T[B][value(curr)])
next(next) = curr
curr = next
end_while
while value(curr) ≠ A do
if T[A][value(curr)] = 0 then
return nil
end_if
next = GETNODE(T[A][value(curr)])
next(next) = curr
curr = next
end_while

return curr
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
[[{{ns:6}}:ASP1 K3 2019 zadatak 6 graf.png|thumb|Graf iz zadatka 6.]]
Za graf sa slike odrediti topološki poredak, a zatim naći kritični put i dozvoljena kašnjenja za pojedinačne čvorove.

=== Rešenje ===
* Topološki poredak: '''ABDCFEHGIJK'''
* Kritični put: '''ABCEHGJK''' (ili '''ABCEHGIJK''')
* Tabela:
{| class="wikitable"
| Čvor
| EST
| LST
| L
|-
| A
| 0
| 0
| 0
|-
| B
| 1
| 1
| 0
|-
| C
| <strike>3</strike> 10
| 10
| 0
|-
| D
| 3
| 6
| 3
|-
| E
| 15
| 15
| 0
|-
| F
| <strike>6</strike> 11
| 13
| 2
|-
| G
| 19
| 19
| 0
|-
| H
| 16
| 16
| 0
|-
| I
| 21
| 21
| 0
|-
| J
| 22
| 22
| 0
|-
| K
| 24
| 24
| 0
|}

== 7. zadatak ==
=== Postavka ===
Koja su dva karakteristična načina za izbor puta povećanog protoka u protočnom grafu? Na primeru protočnog grafa sa slike u okviru koga postoji već uspostavljen protok po pojedinim granama, nacrtati rezidualni graf i navesti dva karakteristična puta koji ilustruju navedene situacije.

=== Rešenje ===
Dva karakteristična načina za izbor puta povećanog protoka su:
# običan BFS koji će naći najkraći put od S do T, na primer SBT, i
# biranje puta koji najviše povećava protok, na primer SBAT.
Grafovi su dati ispod.
<gallery>
ASP1 K3 2019 zadatak 7 graf.svg | Graf iz postavke zadatka.
ASP1 K3 2019 zadatak 7 rezidualni graf.svg | Rezidualni graf.
</gallery>

== 8. zadatak ==
=== Postavka ===
''Dijkstra''-in algoritam
<div class="abc-list">
# Kolika je složenost ''Dijkstra''-inog algoritma i od kojih operacija u okviru algoritma to zavisi? Objasniti.
# Napisati pseudokod ''Dijkstra''-inog algoritma koji pronalazi najkraće rastojanje između para čvorova ''x'' i ''y'' pod pretpostavkom da se graf ''G'' predstavlja listama susednosti. Specijalizovati apstraktne operacije gde je to moguće.
</div>

=== Rešenje ===
Složenost Dajkstrinog algoritma zavisi od operacija pronalaženja sledećeg čvora do kojeg je put najkraći i ažuriranja matrice D sa dodavanjem novog čvora u skup S. Može biti <math>\mathcal{O(n^2)}</math> u slučaju da se pronalaženje sledećeg čvora do kojeg je put najkraći izvršava u <math>\mathcal{O(n)}</math> i da je graf predstavljen matricom susednosti. Bolja složenost dostiže se onda kada je graf predstavljen listom susednosti i operacija pronalaženja sledećeg čvora sa najkraćim putem ima složenost od <math>\mathcal{O(\log{n})}</math>, kada je složenost <math>\mathcal{O(e + n\log{n})}</math>.
{{Милокод|<nowiki>
DIJKSTRA ADJ LIST(G, x, y)
S = {x}
for i = 1 to n do
d[i] = w[x, i]
if d[i] = ∞ then
t[i] = 0
else
t[i] = x
end_if
end_for
for k = 1 to n-1 do
start_node = -1
for i ∈ (V - S) do
if (start_node = -1) or (d[i] < d[start_node]) then
start_node = i
end_if
end_for
S = S + {start_node}
adj_node = AL[start_node]
while adj_node ≠ nil do
if w[start_node, value(adj_node)] + d[start_node] < d[value(adj_node)] then
d[value(adj_node)] = w[start_node, value(adj_node)] + d[start_node]
t[value(adj_node)] = start_node
end_if
adj_node = next(adj_node)
end_while
end_for

return d[y]
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К3 2018

2024-09-13T00:09:04Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K3_1718.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Diskutovati implementaciju algoritma za topološko sortiranje grafa u '''inverznom poretku''', ukoliko se za memorijsku reprezentaciju grafa usvoje liste susednosti. Da li je za ovu operaciju pogodnije koristiti inverzne liste susednosti? Obrazložiti odgovor uz precizno navođenje razlika u implementaciji.

=== Rešenje ===
Pošto se radi o topološkom sortiranju u inverznom poretku, to znači da se uvek traži naredni čvor koji nema izlaznih grana.

U ovom slučaju je najpovoljnije koristiti inverzne liste susednosti. Na početku se prođe kroz sve grane i formira vektor koji za svaki čvor pamti broj sledbenika (kad god se naiđe na određeni čvor u granama inkrementira mu se broj sledbenika jer nailaskom na njega znamo da je on prethodnik čvora iz tog zaglavlja). U toku izvršavanja <code>TOP_SORT</code> algoritma uvek se traži u vektoru čvor koji nema sledbenike, direktno mu se pristupa u nizu zaglavlja, i onda se samo uklone svi čvorovi iz njegove ulančane liste prethodnika. Nakon ovog postupka se ažurira uvek i vektor tako što se za svaki uklonjeni čvor dekrementira broj njegovih sledbenika. Na ovaj način <code>TOP_SORT</code> algoritam ima složenost <math>O(n+e)</math> jer se postupak ponavlja za svih <math>n</math> čvorova u grafu, a ukupno se prolazi kroz <math>e</math> grana.

Sa druge strane, korišćenje regularnih lista susednosti bi bilo znatno složenije jer uprkos tome što lako nalazimo čvor bez izlaznih grana i ne treba nam dodatan vektor za to, prilikom uklanjanja svih ulaznih grana za taj čvor bismo uvek morali da prođemo sve grane u grafu kako bismo našli kojim čvorovima je on sve sledbenik.

== 2. zadatak ==
=== Postavka ===
Data je matrica puteva dužine tačno 1 (jedan) nekog netežinskog usmerenog grafa. Odrediti matricu puteva dužine d≤3. Postupak prikazati po koracima, uz obrazloženje.

{| class="wikitable"
! -
! A !! B !! C !! D !! E
|-
! A
| 0 || 1 || 1 || 0 || 0
|-
! B
| 0 || 0 || 0 || 0 || 0
|-
! C
| 1 || 1 || 0 || 0 || 0
|-
! D
| 1 || 0 || 0 || 0 || 0
|-
! E
| 0 || 0 || 0 || 1 || 0
|}

=== Rešenje ===
[[{{ns:6}}:ASP1 K3 2018 zadatak 2 graf.svg|thumb|Graf koji se dobija iz matrice susednosti.]]
Naša tabela već sadrži informacije o svim putevima dužine 1, a to su:
* AB
* AC
* CA
* CB
* DA
* ED
Na osnovu toga možemo nacrtati graf s desne strane. Nakon toga sa kraja svakog od prethodnih puteva nastavljamo kroz još jednu granu kako bismo dobili sve moguće puteve dužine 2.
* AB → ne može dalje
* AC → ACA, ACB
* CA → CAC, CAB
* CB → ne može dalje
* DA → DAB, DAC
* ED → EDA
I taj proces ponovimo još jednom kako bismo dobili puteve dužine 3.
* ACA → ACAB, ACAC
* ACB → ne može dalje
* CAC → CACB, CACA
* CAB → ne može dalje
* DAB → ne može dalje
* DAC → DACA, DACB
* EDA → EDAB, EDAC
Na osnovu dobijenih puteva ažuriramo matricu povezanosti tako što za svaki put uzmemo čvor sa početka puta i čvor sa kraja puta, postavimo polje za granu između ta dva čvora na 1 i za sve ostale čvorove postavimo na 0. Tako se dobija konačna tablica ispod.
{| class="wikitable"
! -
! A !! B !! C !! D !! E
|-
! A
| 1 || 1 || 1 || 0 || 0
|-
! B
| 0 || 0 || 0 || 0 || 0
|-
! C
| 1 || 1 || 1 || 0 || 0
|-
! D
| 1 || 1 || 1 || 0 || 0
|-
! E
| 1 || 1 || 1 || 1 || 0
|}

== 3. zadatak ==
=== Postavka ===
Dat je usmereni težinski acikličan graf. Implementirati funkciju FIND_PATHS_NUM koja treba da pronađe ukupan broj putanja od izvornog čvora (''src'') do destinacionog čvora (''dst'') koje su kraće od vrednosti prosleđenog parametra ''k''.

=== Rešenje ===
Pošto se ne kaže da mora iterativno rešenje, ovde nam je najlakše rekurzivno rešenje.
{{Милокод|<nowiki>
FIND PATHS NUM(G, src, dst, k)
if k < 1 then
return 0
end_if
if src = dst then
return 1
end_if
paths = 0
for {j : (src, j) ∈ E} do
paths = paths + FIND_PATHS_NUM(G, j, dst, k - w(src, j))
end_for
return paths
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Posmatra se neka opština predstavljena neusmerenim težinskim grafom. Čvorovi grafa predstavljaju naselja, dok grane povezuju čvorove između kojih je moguće postaviti kabl, pri čemu težina predstavlja rastojanje između gradova. Telekomunikacioni operater treba da poveže naselja opštine, odnosno da postavi kablove između njih. Kablovi koje operater ima na raspolaganju su dužine ''k'' i mogu se skratiti po potrebi, ali se ne mogu nastavljati. Napisati funkciju u pseudokodu koja za prosleđeni graf sa datim brojem čvorova ''n'' i parametrom ''k'' vraća da li je moguće povezati sva naselja u okviru opštine telekomunikacionom mrežom.

=== Rešenje ===
{{Милокод|<nowiki>
TELECOM(G, n, k)
S = {1}
for i = 1 to n-1 do
find min {w(u, v) : (u ∈ S) and (v ∈ (V - S))}
if w(u, v) > k then
return false
end_if
S = S + {v}
end_for
return true
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Neka je dat neusmeren netežinski graf G predstavljen matricom susednosti. Napisati u pseudokodu iterativnu funkciju za određivanje povezanih komponenti u zadatom grafu i komentarisati njenu složenost. Funkcija treba da vrati informaciju o povezanim komponentama u vidu niza pokazivača, gde svaki pokazivač pokazuje na jedan od čvorova iz odgovarajuće povezane komponente.

=== Rešenje ===
Osnovna detekcija povezanih komponenti funkcioniše tako što jedna petlja prolazi kroz svaki čvor i ako nije posećen računa ga kao odvojenu komponentu i radi DFS nad njim kako bi se ostali čvorovi u komponenti označili kao posećeni. Sa listom susednosti spoljašnja petlja prolazi tačno ''n'' puta kroz niz a od svakog čvora prilikom DFS-a se moraju posetiti sve grane, pa to čini ukupnu složenost od <math>\mathcal{O(e + n)}</math>. Pošto, nažalost, koristimo matricu susednosti umesto liste susednosti, pri obilaženju svakog čvora DFS-om moraćemo da prođemo kroz ceo red matrice kako bismo odredili koje su u njoj grane, i to ćemo morati da učinimo za svaki čvor (jer ćemo svaki čvor morati da posetimo), što bez obzira na spoljašnju petlju čini složenost od <math>\mathcal{O(n^2)}</math>.
{{Милокод|<nowiki>
CONN COMP MAT(G)
curr_comp = 0
for i = 1 to n do
comp[i] = 0
end_for
stack = t = nil
for i = 1 to n do
if comp[i] = 0 then
curr_comp = curr_comp + 1
comp[i] = curr_comp
stack = GETNODE
value(stack) = i
while stack ≠ nil do
for j = 1 to n do
if (e[value(stack), j] = 1) and (comp[j] = 0) then
comp[j] = curr_comp
t = next(stack)
next(stack) = GETNODE
value(next(stack)) = j
next(next(stack)) = t
end_if
end_for
t = stack
stack = next(stack)
FREENODE(t)
end_while
end_if
end_for
ALLOCATE(res[curr_comp])
for i = 1 to curr_comp do
res[i] = nil
end_for
for i = 1 to n do
if res[comp[i]] = nil then
res[comp[i]] = v[i]
end_if
end_for
return res
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
Neka se posmatra usmeren graf sa slike. Pod pretpostavkom da se za obilazak grafa koristi BFS algoritam i početni čvor A, definisati i obeležiti grane stabla obilaska, grane unapred, povratne grane i poprečne grane. Smatrati da se susedi obilaze u alfabetskom poretku njihovih oznaka.

=== Rešenje ===
Redosled obilaska je '''ABCDFGEFH'''. Stablo obilaska izgleda ovako:
A
/ | \
B C D
| | / \
F G F2 E
|
H
<gallery class="transparent-svg">
ASP1 K3 2018 zadatak 6 graf.svg | Graf iz postavke zadatka.
ASP1 K3 2018 zadatak 6 rešenje.svg | Rešenje zadatka.
</gallery>

== 7. zadatak ==
=== Postavka ===
[[{{ns:6}}:ASP1 K3 2018 zadatak 7 graf.svg|thumb|Pojednostavljen graf iz postavke zadatka.]]
Za graf sa slike, odrediti najkraća rastojanja od čvora C do svih ostalih čvorova. Kada algoritam završava svoj rad u ovom slučaju?

=== Rešenje ===
Algoritam završava svoj rad kada više ne postoji čvor grafa ''i'' ∉ ''S'' kome ''d''[''i''] ≠ ∞.
{| class="wikitable"
! rowspan="2" | S
! rowspan="2" | T
! colspan="7" | D
|-
! A
! B
! D
! E
! F
! G
! H
|-
| C || - || ∞ || ∞ || '''3''' || ∞ || ∞ || 4 || ∞
|-
| C, D || D || ∞ || ∞ || 3 || 7 || 9 || '''4''' || ∞
|-
| C, D, G || G || ∞ || ∞ || 3 || 7 || '''6''' || 4 || ∞
|-
| C, D, G, F || F || ∞ || ∞ || 3 || '''7''' || 6 || 4 || 9
|-
| C, D, G, F, E || E || ∞ || ∞ || 3 || 7 || 6 || 4 || '''9'''
|-
| C, D, G, F, E, H || H || ∞ || ∞ || 3 || 7 || 6 || 4 || 9
|}

== 8. zadatak ==
=== Postavka ===
Maksimizacija protoka grafa ''G(V, E)''
<div class="abc-list">
# Na formalan (netekstualni) i precizan način definisati rezidualni graf ''G<sub>f</sub>'' za protočni graf ''G''. Koliko maksimalno grana može da ima rezidualni graf?
# Napisati funkciju koja na osnovu protočnog grafa ''G'' formira rezidualni graf ''G<sub>f</sub>''. Graf ''G'' je zadat listom susednosti, gde čvor liste sadrži trenutni protok grane ''f'' i njen kapacitet ''c''.
</div>
=== Rešenje ===
: <math>G_f = (V, E_f)</math>
: <math>E_f = \{(i, j) : i, j \in V, c(i, j) - f(i, j) > 0 \}</math>
Rezidualni graf može maksimalno da ima duplo više grana od protočnog grafa, u slučaju da se nakon zamene grana ne dobiju grane težine 0. Protočni graf ima maksimalan broj grana <math>\frac{n(n-1)}{2}</math> jer između svaka dva čvora može da postoji grana, pa zato rezidualni graf može da ima maksimalno <math>n(n-1)</math> grana.

{{Милокод|<nowiki>
GtoGf(G)
ALLOCATE(E', n)
for i = 1 to n do
e'[i] = nil
end_for
p = nil
for i = 1 to n do
p = e[i]
while p ≠ nil do
BRANCH_INSERT(E', i, value(p), c(p) - f(p))
BRANCH_INSERT(E', value(p), i, f(p))
p = next(p)
end_while
end_for
return (V, E')
</nowiki>}}
{{Милокод|<nowiki>
BRANCH INSERT(E', from, to, w)
if w = 0 then
return
end_if
t = e'[from]
e'[from] = GETNODE
value(e'[from]) = to
next(e'[from]) = t
w(e'[from]) = w
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К3 2017

2024-09-13T00:09:03Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K3_1617.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Na slici je dat težinski neusmereni graf. Formirati minimalno obuhvatno stablo korišćenjem Kruskalovog algoritma. Prikazati postupak izbora grana i finalno stablo.

=== Rešenje ===
Kada uredimo grane po težini dobijamo redosled po kojem možemo da ih biramo za ubacivanje u graf.
# B-D (2)
# C-E (5)
# A-C (8)
# C-D (10)
# <strike>A-B (12)</strike> - A i B su već povezani preko A-C, C-D i B-D
# <strike>D-E (13)</strike> - D i E su već povezani preko C-D i C-E
# B-M (15)
# <strike>A-E (25)</strike> - svi čvorovi su nam već u stablu
# <strike>M-E (30)</strike> - svi čvorovi su nam već u stablu
<gallery class="transparent-svg">
ASP1 K3 2017 zadatak 1 graf.svg | Graf iz postavke zadatka.
ASP1 K3 2017 zadatak 1 MST.svg | Minimalno obuhvatno stablo za graf iz postavke zadatka.
</gallery>

== 2. zadatak ==
=== Postavka ===
Napisati u pseudokodu iterativnu implementaciju funkcije za topološko sortiranje usmerenog netežinskog grafa. Ukoliko u nekom trenutku više čvorova može biti kandidat za istu poziciju u finalnom redosledu, bira se čvor sa najviše neposećenih suseda. Graf se predstavlja pomoću liste susednosti u čijem se zaglavlju za svaki čvor, pored pokazivača na odgovorajuću listu suseda, nalazi i broj suseda. Funkcija treba da vrati niz čvorova u topološkom poretku.

=== Rešenje ===
{{Милокод|<nowiki>
TOPSORT(G, n)
p = nil
for i = 1 to n do
in[i] = 0
end_for
for i = 1 to n do
p = first(e[i])
while p ≠ nil do
in[value(p)] = in[value(p)] + 1
p = next(p)
end_while
end_for
tail = head = nil
for i = 1 to n do
if in[i] = 0 then
if tail = nil then
tail = head = GETNODE
value(tail) = i
else
PRIORITY_QUEUE_INSERT(tail, head, E, i)
end_if
end_if
end_for
i = 1
while tail ≠ nil do
ret[i] = value(tail)
p = first(e[i])
while p ≠ nil do
in[value(p)] = in[value(p)] - 1
if in[value(p)] = 0 then
PRIORITY_QUEUE_INSERT(tail, head, E, value(p))
end_if
p = next(p)
end_while
i = i + 1
p = tail
tail = next(tail)
FREENODE(p)
end_while
return ret
</nowiki>}}
{{Милокод|<nowiki>
PRIORITY QUEUE INSERT(tail, head, E, value)
p = tail
found = false
t = nil
if num(e[value]) > num(e[value(p)]) then
tail = GETNODE
value(tail) = value
next(tail) = p
else
while next(p) ≠ nil do
if num(e[value]) > num(e[value(next(p))]) then
t = next(p)
next(p) = GETNODE
value(next(p)) = value
next(next(p)) = t
found = true
break
end_if
p = next(p)
end_while
if not found then
next(head) = GETNODE
value(next(head)) = value
head = next(head)
end_if
end_if
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Perica je vodoinstalater. Završio je posao za danas i vraća se kući, gde ga žena čeka za ručkom. Na putu do svoje kuće prolazi pored kuća svojih prijatelja i zna da će ga svaki od njih zaustaviti da popriča sa njim (malo mesto, svi se znaju, a i naš Perica je dobar vodoinstalater). Perica je gladan i nije danas mnogo raspoložen za priču, pa želi da stigne kući i pritom popriča sa što manjim brojem ljudi. Put do kuće sadrži određeni broj raskrsnica koje spajaju ulice sa određenim brojem kuća.
<div class="abc-list">
# Objasniti na koji način se izloženi problem može modelovati putem grafa.
# Napisati u pseudokodu funkciju koja navodi Pericu od posla do kuće tako da na putu popriča sa što je moguće manjim brojem ljudi.
</div>

=== Rešenje ===
Ovaj sistem možemo modelovati neusmerenim težinskim grafom u kojem su posao, kuća i raskrsnice čvorovi, ulice između njih su grane a težina tih grana je broj ljudskih bića sa kojima će Perica nažalost morati da se sukobi u njegovoj najneomiljenijoj disciplini: prijateljskom razgovoru.
{{Милокод|<nowiki>
GET PERICA HOME(G, work, home)
S = {home}
p = nil
curr = 0
for i = 1 to n do
d[i] = w(home, i)
if d[i] = ∞ then
t[i] = 0
else
t[i] = home
end_if
end_for
for k = 1 to n-1 do
find min {d[i] : i ∈ (V - S)}
p = e[i]
while p ≠ nil do
if d[i] + w(i, value(p)) < d[value(p)] then
d[value(p)] = d[i] + w(i, value(p))
t[value(p)] = i
end_if
p = next(p)
end_while
S = S + {i}
end_for
curr = t[work]
while curr ≠ home then
GO(curr)
curr = t[curr]
end_while
GO(home)
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
[[{{ns:6}}:ASP1 K3 2017 zadatak 4 graf.svg|thumb|Graf iz postavke zadatka.]]
Za graf sa slike naći kritični put i dozvoljena kašnjenja za pojedinačne čvorove. Kritični put označiti i na samom grafu.

=== Rešenje ===
Kritičan put: '''ACGSRT'''
{| class="wikitable"
! Čvor
! EST
! LST
! L
|-
! A
| 0
| 0
| 0
|-
! C
| 11
| 11
| 0
|-
! E
| 13
| 25
| 12
|-
! F
| 26
| 31
| 5
|-
! G
| 18
| 18
| 0
|-
! H
| 10
| 13
| 3
|-
! K
| 32
| 36
| 4
|-
! N
| 35
| 39
| 4
|-
! R
| 40
| 40
| 0
|-
! S
| 38
| 38
| 0
|-
! T
| 43
| 43
| 0
|}

== 5. zadatak ==
=== Postavka ===
Neka se posmatra jedan fudbalski tim sa 25 članova koji konkurišu za 11 pozicija u timu. Svaki igrač ima definisan skup pozicija na kojima može da igra, a za svaku poziciju mu se dodeljuje odgovarajuća ocena. Dati predlog na koji način se dati problem može modelovati grafom i izvršiti selekcija prve postave, tako da se izabere postava od 11 igrača koji imaju najbolje ocene. Smatrati da je svaka pozicija u timu pokrivena najmanje jednim igračem.

=== Rešenje ===
Ovaj problem se može modelovati bipartitnim grafom gde čvorovi jednog dela označavaju fudbalere, čvorovi drugog pozicije na kojima oni mogu igrati, grane između fudbalera i pozicije označavaju da taj fudbaler može igrati na toj poziciji a težina te grane njegova ocena. Uparivanje se vrši brute-force metodom, tako što se isprobaju sva moguća uparivanja fudbalera i pozicija gde su sve pozicije zauzete i izabere ono gde je zbir težina grana najveći.

== 6. zadatak ==
{{delimično rešeno}}
=== Postavka ===
Neka se posmatra netežinski usmereni graf ''G'' sa ''n'' čvorova. Za posmatrani graf su korišćenjem DFS algoritma određena početna i završna vremena svih čvorova i smeštena u nizovima F i L dužine ''n''. Napisati u pseudokodu funkciju koja pronalazi najveću jako povezanu komponentu po broju čvorova. Smatrati da je graf predstavljen pomoću matrice susednosti.

=== Rešenje ===
{{Милокод|<nowiki>
MAX STRONG CC(G, n)
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Neka je dato neko stanje protočnog grafa preko matrice trenutnih protoka ''F'' kao i odgovarajuće stanje rezidualnog grafa preko matrice ''R''.
<div class="abc-list">
# Napisati funkciju koja određuje matricu kapaciteta i izračunava broj grana polaznog protočnog grafa.
# U odnosu na broj grana početnog protočnog grafa, odrediti koliko najmanje i koliko najviše grana može imati rezidulani graf.
</div>

=== Rešenje ===
Rezidualni graf najmanje može imati <math>n-1</math> grana u slučaju da su svi protoci puni ili prazni i ima tačno onoliko grana koliko je potrebno da bi graf bio povezan, ili <math>n(n-1)</math> grana u slučaju da nijedan protok nije pun ili prazan i svaki čvor je povezan sa svakim.
{{Милокод|<nowiki>
FLOW CAP(F, R)
num_total = 0
for x = 1 to n do
for y = 1 to n do
if (F[x, y] > 0) or ((F[x, y] = 0) and (F[y, x] = 0) and (R[x, y] > 0)) then
num_total = num_total + 1
end_if
if F[x, y] = 0 then
if R[x, y] ≠ 0 then
C[x, y] = R[x, y]
end_if
else
C[x, y] = F[x, y] + R[x, y]
end_if
end_for
end_for
return num_total
</nowiki>}}

== 8. zadatak ==
{{delimično rešeno}}
=== Postavka ===
Potrebno je utvrditi da li je dati povezani neusmereni graf cikličan na što efikasniji način.
<div class="abc-list">
# Objasniti postupak i dati vremensku složenost.
# Na osnovu predloženog postupka napisati pseudokod.
</div>

=== Rešenje ===
{{Милокод|<nowiki>
IS CYCLIC(G)
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К2 2019

2024-09-13T00:09:03Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K2_1819.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Neka je skoro kompletno ili kompletno binarno stablo predstavljeno sekvencijalnom memorijskom reprezentacijom (nizom). Na osnovu prosleđenog niza u kome su smeštene celobrojne vrednosti koje predstavljaju informacioni sadržaj čvorova, formirati ekvivalentno binarno stablo ulančane reprezentacije.

=== Rešenje ===
{{Милокод|<nowiki>
FORM TREE(arr, n)
ALLOCATE(nodes[n])
if n = 0 then
return nil
end_if
j = 1
nodes[1] = GETNODE(arr[1])
for i = 1 to n do
if j < n then
j = j + 1
nodes[j] = GETNODE(arr[j])
left(nodes[i]) = nodes[j]
end_if
if j < n then
j = j + 1
nodes[j] = GETNODE(arr[j])
right(nodes[i]) = nodes[j]
end_if
end_for
return nodes[1]
</nowiki>}}
{{Милокод|<nowiki>
GETNODE(value)
ALLOCATE(node)
left(node) = nil
right(node) = nil
value(node) = value
return node
</nowiki>}}

== 2. zadatak ==
=== Postavka ===
Primenom LZW algoritma prikazati postupak kodiranja znakovnog niza KUKURIKU, ako je data početna tabela sa kodovima simbola. Napisati kodiranu poruku i izgled tabele simbola nakon postupka kodiranja.

=== Rešenje ===
Kodovano: '''014234'''
{| class="wikitable"
! Simbol
! Kôd
|-
| K
| 0
|-
| U
| 1
|-
| R
| 2
|-
| I
| 3
|-
| KU
| 4
|-
| UK
| 5
|-
| KUR
| 6
|-
| RI
| 7
|-
| IK
| 8
|}

== 3. zadatak ==
=== Postavka ===
Za neko binarno stablo ''preorder'' obilazak daje poredak HBIKCFDAEJG, a ''inorder'' obilazak HBIADJEGFCK. Odrediti poredak koji se dobija ''level-order'' obilaskom i objasniti postupak.

=== Rešenje ===
H
\
B
\
I
\
K
/
C
/
F
/
D
/ \
A E
/ \
J G
''Level-order'' obilazak: '''HBIKCFDAEJG.''' Postupak se svodi na to da idemo po svakom nivou binarnog stabla i čitamo sadržaj tog nivoa sleva na desno.

== 4. pitanje ==
=== Postavka ===
Dato je stablo formirano primenom statičkog ''Huffman''-ovog algoritma. Implementirati funkciju FIND_CODES koja za takvo stablo na čiji koren pokazuje pokazivač ''root'' vraća simbole čiji su kodovi dužine tačno ''k''.

=== Rešenje ===
{{Милокод|<nowiki>
FIND CODES(root, k)
if (root = nil) or (k ≤ 0) then
return nil
end_if
symbols = nil
node = nil
depth = 0
symb_node = nil
p = symbols
QUEUE_INIT(Q1)
QUEUE_INIT(Q2)
QUEUE_INSERT(Q1, root)
QUEUE_INSERT(Q2, 0)
while not QUEUE_EMPTY(Q1) do
node = QUEUE_DELETE(Q1)
depth = QUEUE_DELETE(Q2)
if depth = k then
if symbol(node) ≠ nil then
symb_node = GETNODE
value(symb_node) = symbol(node)
if symbols = nil then
symbols = p = symb_node
else
next(p) = symb_node
p = next(p)
end_if
end_if
else
if left(node) ≠ nil then
QUEUE_INSERT(Q1, left(node))
QUEUE_INSERT(Q2, depth + 1)
end_if
if right(node) ≠ nil then
QUEUE_INSERT(Q1, right(node))
QUEUE_INSERT(Q2, depth + 1)
end_if
end_if
end_while
return symbols
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Primenom algoritma dinamički ''Huffman'' kodirati poruku ABRAKADABRA, ukoliko su početni fiksni kodovi za slova A, B, R, K, D redom 000, 001, 010, 011 i 100. Proces kodiranja prikazati po koracima.

=== Rešenje ===
* Krajnje transmitovano: '''A 0B 00R 0 100K 0 1100D 0 110 110 0'''
* Krajnje kodirano: '''000 0001 00010 0 100011 0 1100100 0 110 110 0'''
* Krajnje stablo:
11
/ \
A 6
5 / \
2 4
/ \ / \
1 K R B
/ \ 1 2 2
NYT D
0 1

== 6. zadatak ==
=== Postavka ===
Precizno objasniti kako se iterativni algoritam za obilazak po ''inorder''-u može modifikovati tako da se zadato stablo transformiše u povezano (''threaded'') stablo po istom obilasku.

=== Rešenje ===
Može se modifikovati tako što čuvamo pokazivač na prethodno obrađeni čvor (<code>prev</code>) i pre obrađivanja trenutnog čvora (<code>P(''next'')</code>, gde je <code>next</code> trenutno obrađivani čvor) radimo sledeće:
{{Милокод|<nowiki>
if prev ≠ nil then
if left(next) = nil then
left(next) = prev
lf(next) = 0
end_if
if right(prev) = nil then
right(prev) = next
rf(prev) = 0
end_if
end_if
prev = next
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
U kakvom binarnom stablu interna dužina puta postiže maksimum za dati broj čvorova? Izvesti i objasniti izraz za izračunavanje maksimalne interne dužine puta u binarnom stablu sa ''n'' čvorova. Nacrtati primer takvog stabla sa 4 čvora i izračunati internu dužinu puta.

=== Rešenje ===
Interna dužina puta postiže maksimum u degenerisanom binarnom stablu u kojem ima jedan čvor po nivou, na primer (za <code>n = 4</code>):
A
/
B
/
C
/
D
Interna dužina puta je zbir dužina puteva od korena stabla do svakog internog čvora, što je u ovom slučaju <math>PI = 1 + 2 + 3 = 6</math>. Možemo primetiti da je do svakog internog čvora putanja za jedan kraća od nivoa na kojem se nalazi i da ima za jedan manje puteva od broja čvorova iz čega dobijamo da je interna dužina puta za binarno stablo sa <math>n</math> čvorova jednaka <math>PI_n = 1 + 2 + 3 + ... + (n - 1) = \frac{(n-1) n}{2}</math>.

== 8. zadatak ==
=== Postavka ===
Na jednoj društvenoj mreži postoji simetrična relacija prijateljstva između korisnika i asimetrična relacija praćenja kod koje jedan korisnik prati aktivnosti drugog. Potrebno je posmatranu društvenu mrežu modelirati grafom.
<div class="abc-list">
# Predložiti odgovarajući tip grafa i detaljno opisati njegove osobine.
# Predložiti i obrazložiti odgovarajaću memorijsku reprezentaciju grafa, tako da se optimizuje određivanje ukupnog broja pratilaca nekog korisnika. Korisnikove aktivnosti mogu da prate i prijatelji i pratioci.
# Napisati pseudkod<sup>[sic]</sup> funkcije koja za zadatog korisnika vraća ukupan broj pratilaca.
</div>

=== Rešenje ===
: ''U rešenju se pretpostavlja da se u postavci zadatka implicira da su prijatelji ujedno i pratioci.''
Ovu mrežu je moguće modelirati usmerenim netežinskim grafom gde čvorovi označavaju korisnike a grane označavaju relacije praćenja, gde grana od čvora A do čvora B označava da korisnik A prati korisnika B. Optimalna reprezentacija grafa u ovom slučaju jeste preko inverzne liste susednosti, jer na taj način mora proći kroz tačno onoliko pratilaca koliki će broj biti vraćen na kraju, a ako se čuva dužina inverzne liste susednosti u zaglavlju onda je složenost algoritma konstantna.
{{Милокод|<nowiki>
FOLLOWERS(G, i)
followers = 0
p = IAL[i]
while' p ≠ nil do
followers = followers + 1
p = next(p)
end_while
return followers
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К2 2018

2024-09-13T00:09:02Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K2_1718.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Napisati u pseudokodu iterativnu funkciju koja vrši generalizovani ''preorder'' obilazak ''m''-arnog stabla na koje pokazuje pokazivač ''root''. Svaki čvor stabla sadrži oznaku čvora i ''m'' pokazivača na potomke. Funkcija treba da vrati niz koji za svaki čvor stabla sadrži njegovu oznaku i nivo u stablu na kome se čvor nalazi. Komentarisati rešenje. Dozvoljeno je koristiti gotove linearne strukture podataka.

=== Rešenje ===
{{Милокод|<nowiki>
PREORDER M I(root, m)
if root = nil then
return nil
end_if
INIT_STACK(S1)
INIT_STACK(S2)
STACK_PUSH(S1, root)
STACK_PUSH(S2, 1)
node = nil
depth = 0
list = nil
p = nil
while not STACK_EMPTY(S1) do
node = STACK_POP(S1)
depth = STACK_POP(S2)
if list = nil then
list = p = GETNODE
else
next(p) = GETNODE
p = next(p)
end_if
symbol(p) = symbol(node)
depth(p) = depth
for i = m to 1 do
if children(node)[i] ≠ nil then
STACK_PUSH(S1, children(node)[i])
STACK_PUSH(S2, depth + 1)
end_if
end_for
end_while
return list
</nowiki>}}

Ovo rešenje se zasniva na čuvanju čvora i nivoa čvora u dva odvojena steka i korišćenju povezane liste (pošto ne znamo unapred količinu čvorova u stablu kako bismo alocirali niz). Za svaki čvor u steku dodajemo njegovu decu na jedan stek, s tim što ih dodajemo s desna na levo kako bi prvi posećeni čvor bio najlevlje (odnosno prvo) dete čvora (kao što je to i slučaj kod ''preorder'' obilaska), a njegov nivo uvećan za jedan na drugi stek.

== 2. zadatak ==
=== Postavka ===
Izvesti i objasniti izraz za određivanje minimalne visine ''h<sub>min</sub>'' za binarno stablo sa n čvorova. Kakve osobine ima binarno stablo sa minimalnom visinom?

=== Rešenje ===
Binarno stablo sa minimalnom visinom teži da ima svaki nivo popunjen, tj. teži da bude kompletno stablo. Pošto znamo da kompletno stablo na nivou <math>i</math> ima <math>2^i</math> čvorova (svaki čvor osim listova ima maksimalni izlazni stepen, što je 2), i da je stoga ukupan broj čvorova u stablu jednak <math>n = 2^0 + 2^1 + ... + 2^h = 2^{h + 1} - 1</math>. To znači da je <math>\log_2(n + 1)</math> jednako <math>h + 1</math> i time dobijamo da je <math>h_{min} = \left\lceil{\log_2(n + 1)}\right\rceil - 1</math>.

== 3. zadatak ==
=== Postavka ===
Za neko binarno stablo ''preorder'' obilazak daje poredak ABDCEFGHI, a ''postorder'' obilazak DBFIHGECA.
<div class="abc-list">
# Navesti sve čvorove koji predstavljaju listove ovog stabla.
# Odrediti sve pretke čvora E.
# Navesti sve čvorove koji se nalaze u podstablu čiji je koren čvor E.
</div>

=== Rešenje ===
A
/ \
B C
/ /
D E
/ \
F G
/
H
/
I
<div class="abc-list">
# D, F, I
# C, A
# F, G, H, I
</div>

== 4. zadatak ==
=== Postavka ===
Primenom LZW algoritma prikazati postupak kodiranja znakovnog niza LESQUELLES, ako je data početna tabela sa kodovima simbola. Napisati kodiranu poruku i izgled tabele simbola nakon postupka kodiranja.

=== Rešenje ===
Kodirana poruka: '''012341052'''
{| class="wikitable"
! Simbol
! Kôd
|-
| L
| 0
|-
| E
| 1
|-
| S
| 2
|-
| Q
| 3
|-
| U
| 4
|-
| LE
| 5
|-
| ES
| 6
|-
| SQ
| 7
|-
| QU
| 8
|-
| UE
| 9
|-
| EL
| 10
|-
| LL
| 11
|-
| LES
| 12
|}

== 5. zadatak ==
=== Postavka ===
Dato je stablo formirano primenom algoritma statički ''Huffman''. Implementirati funkciju FIND_LONGEST_CODES koja vraća broj simbola koji se kodiraju najvećim brojem bita prema formiranom stablu. Funkciji je prosleđen pokazivač na koren stabla ''root''. Napisati u pseudokodu i metodu IS EXTERNAL NODE koja proverava da li je čvor na koji pokazuje prosleđeni pokazivač eksterni.

=== Rešenje ===
{{Милокод|<nowiki>
FIND LONGEST CODES(root)
tail = head = GETNODE(root)
next(head) = GETNODE(nil)
head = next(head)
num_max = 0
t = nil
while tail ≠ nil do
if value(tail) = nil then
if tail ≠ head then
next(head) = GETNODE(nil)
head = next(head)
num_max = 0
end_if
else
if IS_EXTERNAL_NODE(value(tail)) then
num_max = num_max + 1
else
if left(value(tail)) ≠ nil then
next(head) = GETNODE(left(value(tail)))
head = next(head)
end_if
if right(value(tail)) ≠ nil then
next(head) = GETNODE(right(value(tail)))
head = next(head)
end_if
end_if
end_if
t = next(tail)
FREENODE(tail)
tail = t
end_while
return num_max
</nowiki>}}
{{Милокод|<nowiki>
IS EXTERNAL NODE(node)
if left(node) = nil and right(node) = nil then
return true
else
return false
end_if
</nowiki>}}
{{Милокод|<nowiki>
GETNODE(value)
ALLOCATE(node)
next(node) = nil
value(node) = value
return node
</nowiki>}}
{{Милокод|<nowiki>
FREENODE(node)
DEALLOCATE(node)
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
Posmatra se stablo sa slike. Povezati ga po ''inorder''-u i ilustrovati slikom na kojoj su obeležene sve potrebne dodatne informacije. Precizno objasniti na koji način se može izvršiti ispisivanje stabla po inverznom ''inorder'' poretku.
A
/ \
B C
/ \ \
F G Y
/ /
E M
\
X

=== Rešenje ===
[[File:ASP1 K2 2018 zadatak 6 stablo.svg|thumb|Rešenje prvog dela zadatka.]]
Algoritam za obilazak povezanog stabla obrnutim ''inorder'' poretkom dat je ispod.
{{Милокод|<nowiki>
REVERSE INORDER T(root)
node = root
while right(node) ≠ nil do
node = right(node)
end_while
while node ≠ nil do
P(node)
if lf(node) = 0 then
node = left(node)
else
node = left(node)
while node ≠ nil and rf(node) = 1 do
node = right(node)
end_while
end_if
end_while
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Primenog algoritma dinamički ''Huffman'' dekodovati poruku 0000100101011011111101101101 ukoliko se sastoji od karaktera A, B i C koji imaju početne fiksne kodove 00, 01 i 10. Proces dekodovanja prikazati po koracima.

=== Rešenje ===
* Dekodovana poruka: '''ABCCAACBBB'''
* Krajnje ''Huffman''-ovo stablo:
10
/ \
B 6
4 / \
3 C
/ \ 3
NYT A
0 3

== 8. zadatak ==
=== Postavka ===
U jednom programu treba modelirati odnose dugovanja i potraživanja između n firmi.
<div class="abc-list">
# Predložiti odgovarajuću logičku strukturu i detaljno opisati njene osobine.
# Predložiti i obrazložiti odgovarajaću memorijsku reprezentaciju ove strukture ako je potrebno optimizovati operaciju izračunavanja ukupnog iznosa dugovanja prema nekoj firmi, kao i određivanje njenog najvećeg dužnika.
# Napisati pseudokod funkcije koja za zadatu firmu vraća ukupna iznos dugovanja koja ona potražuje.
</div>

=== Rešenje ===
<div class="abc-list">
# Graf koji nam je u ovom slučaju potreban jeste težinski usmeren graf u kom čvorovi predstavljaju firme a grane predstavljaju dugovanja, gde grana težine w od čvora A do čvora B označava da firma A duguje firmi B iznos od w jedinica valute. Operacije koje nad njim moraju biti realizovane jesu dodavanje novog čvora i povezivanje dva čvora.
# Optimalna memorijska reprezentacija jeste preko inverzne liste susednosti, tj. niza dužine n koji sadrži pokazivače ka ulančanim listama u kojima se nalaze svi čvorovi koji su povezani sa trenutnim čvorom. Težine grana se mogu čuvati ili u samim čvorovima ulančane liste ili u odvojenoj matrici w gde w[i, j] označava težinu grane od i ka j i može biti postavljena na ∞ ukoliko ta grana ne postoji.
#: Operacija izračunavanja ukupnog iznosa dugovanja može se realizovati prolaskom kroz listu susednosti i sabiranjem svih težina grana koje ti čvorovi čine s zadatim čvorom, a može se i izmeniti struktura tako da se u zaglavlju lista susednosti čuva ukupno dugovanje bez da se poveća složenost neke druge operacije.
#: Operacija određivanja najvećeg dužnika može se isto realizovati linearnim prolaskom kroz listu koji čuva najvećeg dužnika i najveći dug. Dodatna optimizacija može se postići time što se povezane liste pretvore u prioritetne redove što operaciji povezivanja dva čvora povećava složenost sa konstantne na logaritamsku ali operaciji pronalaženja najvećeg dužnika smanjuje složenost sa linearne na konstantnu, za šta smo i optimizovali.
# U implementaciji ispod smatra se da optimizacije pomenute iznad nisu primenjene (jer bi to malo obesmislilo algoritam). Takođe se smatra da su težine grana čuvane u matrici težina w.
</div>
{{Милокод|<nowiki>
DEBT(G, i)
total_debt = 0
p = first(e[i])
while p ≠ nil do
total_debt = total_debt + w[i, value(p)]
p = next(p)
end_while
return total_debt
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К2 2017

2024-09-13T00:09:01Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K2_1617.pdf Zadaci na sajtu predmeta]

== 1. zadatak ==
=== Postavka ===
Napisati u pseudokodu iterativnu funkciju koja određuje širinu binarnog stabla na čiji koren pokazuje pokazivač ''root''. Širina stabla se definiše kao najveća širina svih njegovih nivoa. Funkcija treba da ispiše sve čvorove na nivou najveće širine i vrati određenu širinu. Dozvoljena je upotreba gotovih linearnih struktura podataka

=== Rešenje ===
{{Милокод|<nowiki>
BIN TREE WIDTH(root)
curr_width = max_width = 0
tail = head = GETNODE(root)
next(head) = GETNODE(nil)
head = next(head)
max_level = curr_level = tail
t = nil
while tail ≠ nil do
if value(tail) = nil then
if curr_width > max_width then
while max_level ≠ curr_level do
t = max_level
max_level = next(max_level)
FREENODE(t)
end_while
max_width = curr_width
end_if
curr_width = 0
if tail ≠ head then
curr_level = next(tail)
next(head) = GETNODE(nil)
head = next(head)
end_if
else
curr_width = curr_width + 1
if left(value(tail)) ≠ nil then
next(head) = GETNODE(left(value(tail)))
head = next(head)
end_if
if right(value(tail)) ≠ nil then
next(head) = GETNODE(right(value(tail)))
head = next(head)
end_if
end_if
end_while
while value(max_level) ≠ nil do
OUTPUT(symbol(value(max_level)))
t = max_level
max_level = next(max_level)
FREENODE(t)
end_while
while max_level ≠ nil do
t = max_level
max_level = next(max_level)
FREENODE(t)
end_while
return max_width
</nowiki>}}
{{Милокод|<nowiki>
GETNODE(value)
ALLOCATE(node)
next(node) = nil
value(node) = value
return node
</nowiki>}}
{{Милокод|<nowiki>
FREENODE(node)
DEALLOCATE(node)
</nowiki>}}

== 2. zadatak ==
=== Postavka ===
Posmatra se jedno binarno stablo.
<div class="abc-list">
# Objasniti šta su eksterni čvorovi stabla i za zadato binarno stablo odrediti broj eksternih čvorova. Eksterne čvorove docrtati na zadatom stablu.
# Izvesti i objasniti vezu između broja eksternih čvorova binarnog stabla <math>e</math> i čvorova stabla <math>n</math>.
</div>

=== Rešenje ===
A
/ \
C D
/ \ / \
B ☐ E ☐
/ \ / \
☐ ☐ ☐ F
/ \
☐ ☐
<div class="abc-list">
# Eksterni čvorovi su imaginarni čvorovi na koje pokazuju nezauzeti pokazivači internih čvorova stabla. U ovom stablu gde je <math>n = 6</math> ima ih 7.
# Po gornjoj definiciji, broj eksternih čvorova jednak je broju nezauzetih pokazivača internih čvorova. Broj svih pokazivača <math>p</math> je duplo veći od broja čvorova, jer svaki čvor ima dva pokazivača u binarnom stablu (<math>m = 2</math>). Broj zauzetih pokazivača <math>z</math> jednak je broju grana jer jedna grana zauzima jedan pokazivač, a za broj grana znamo da je za jedan manji od broja čvorova. Odatle dobijamo:
#: <math>p = e + z = 2n</math>
#: <math>z = n - 1</math>
#: <math>e = p - z = 2n - n + 1 = n + 1</math>
</div>

== 3. zadatak ==
=== Postavka ===
Primenom LZW algoritma, prikazati postupak kodiranja poruke ANTANANARIVE, za dati početni sadržaj tabele simbola. Napisati kodiranu poruku i izgled tabele simbola nakon postupka kodiranja

=== Rešenje ===
* Kodirana sekvenca: '''0 1 2 7 10 3 4 5 6'''
* Tabela kodova:
{| class="wikitable"
! Simbol
! Kôd
|-
| A
| 0
|-
| N
| 1
|-
| T
| 2
|-
| R
| 3
|-
| I
| 4
|-
| V
| 5
|-
| E
| 6
|-
| AN
| 7
|-
| NT
| 8
|-
| TA
| 9
|-
| ANA
| 10
|-
| ANAR
| 11
|-
| RI
| 12
|-
| IV
| 13
|-
| VE
| 14
|}

== 4. zadatak ==
=== Postavka ===
Korišćenjem dinamičkog ''Huffman'' algoritma dekodirati sledeću poruku 00001010010001101101 ako je poznato da su simbolima A, B i C dodeljeni kodovi fiksne dužine 00, 01 i 10 respektivno. Za dobijenu sekvencu karaktera predložiti njihov drugačiji raspored takav da se pri kodiranju izmenjene sekvence dobije što veća ušteda u memoriji (kraći kod). Izbor obrazložiti.

=== Rešenje ===
* Dekodovana poruka: '''ABBCCAA'''
* Dinamičko ''Huffman'' stablo:
7
/ \
A 4
3 / \
2 C
/ \ 2
NYT B
0 2
* Predložena sekvenca: '''AAABBCC''' (kodirano sa '''00 1 1 001 01 0010 001''', odnosno četiri koda manje)
* Obrazloženje: Očigledno je da slova A ima najviše u sekvenci i da se ono treba kodirati sa najmanje bitova. Umesto da redom ubacujemo kodove i očekujemo da se "bore" za zauzimanje mesta koje se kodira sa najmanje bitova najlogičnije je da ih postavimo u poziciju u kojoj će biti kodirani sa najlogičnijim brojem bitova. U ovom slučaju to je 1 bit za A, 2 bita za B i 3 bita za C.

== 5. zadatak ==
=== Postavka ===
Ako za neko binarno stablo preorder obilazak daje poredak NMCOLAGFBDPRSHQ, a inorder obilazak COALGMBFNPHSRQD, rekonstruisati zadatog stabla.

=== Rešenje ===
N
/ \
M D
/ \ /
C F P
\ / \
O B R
\ / \
L S Q
/ \ /
A G H

== 6. zadatak ==
=== Postavka ===
Dato je binarno stablo na čiji koren pokazuje pokazivač ''root''. Treba pronaći čvor koji je ''k''-ti po ''preorder'' poretku, ali tako da se zapravo obiđe što manje čvorova.
<div class="abc-list">
# Dozvoljeno je uvođenje jednog dodatnog polja u čvor stabla, pored postojećih polja ''left'' i ''right'', radi što efikasnijeg iterativnog algoritma. Ukratko objasniti svrhu tog polja i algoritam za nalaženje ''k''-tog čvora.
# Napisati u pseudokodu funkciju koja vraća pokazivač na ''k''-ti čvor po ''preorder'' poretku na što je moguće efikasniji način.
</div>

=== Rešenje ===
Uvodimo polje kojem nam govori koliko se u levom podstablu tog čvora nalazi čvorova. Na taj način možemo da, kad dođemo do nekog čvora, odlučimo da li dalje idemo u njegovo levo ili desno podstablo u zavisnosti od toga da li je broj čvorova u levom podstablu veći ili manji od trenutnog broja traženih čvorova. Na početku procesiranja svakog čvora smanjujemo trenutno traženi broj čvorova i vraćamo trenutni čvor ukoliko je jednak 1.
{{Милокод|<nowiki>
PREORDER K NODE(root, k)
next = root
n = k
loop
n = n - 1
if n = 0 then
return next
end_if
if n ≤ left_size(next) then
next = left(next)
else
next = right(next)
n = n - left_size(next)
end_if
end_loop
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Dato je odgovarajuće binarno stablo dobijeno konverzijom stabla višeg reda:
<div class="abc-list">
# Predložiti kako u stablo ugraditi informaciju koja omogućava kretanje uz stablo od listova ka korenu.
# Na osnovu gornjeg predloga napisati funkciju koja za čvor sa zadatom adresom ''adr'' vraća njegov nivo u stablu.
</div>

=== Rešenje ===
Možemo da, nalik povezanim stablima, uvedemo ''rf'' bit koji će biti postavljen na 1 ukoliko desni pokazivač pokazuje na brata trenutnog čvora ili postavljen na 0 ukoliko pokazuje na prvog brata svog roditelja, i zatim sve neiskorišćene desne pokazivače (osim korena) povežemo na prvu braću svojih roditelja. Na taj način svi čvorovi jednog nivoa imaće pristup svim čvorovima narednog nivoa.
{{Милокод|<nowiki>
NODE LEVEL(adr)
level = 1
next = adr
while right(next) ≠ nil do
if rf(next) = 0 then
level = level + 1
end_if
next = right(next)
end_while
return level
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Na kraju svake knjige postoji lista referenci na druge knjige.
<div class="abc-list">
# Predložiti memorijsku predstavu grafa koji predstavlja referenciranje knjiga tako da je olakšano nalaženje broja referenci na neku knjigu.
# Na osnovu gornjeg predloga napisati funkciju koja za zadatu knjigu nalazi broj referenci na nju.
</div>

=== Rešenje ===
Graf koji nam je potreban je netežinski usmeren graf u kojem čvorovi predstavljaju knjige a grane reference na knjige, gde grana od A ka B označava da knjiga A sadrži referencu na knjigu B. Optimalna memorijska predstava bi bila preko inverzne liste susednosti, gde je dodatna optimizacija čuvanje dužine te liste u njenom zaglavlju. Pseudokod ispod ne računa tu optimizaciju:
{{Милокод|<nowiki>
REF COUNT(k)
ref_number = 0
p = IAL[k]
while p ≠ nil do
ref_number = ref_number + 1
p = next(p)
end_while
return ref_number
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К2 2016

2024-09-13T00:08:46Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/SI1AS1_K2_1516.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Na slici je dato jedno nekompletno prikazano binarno stablo (desno. Ukoliko ''preorder'' obilazak takvog stabla daje poredak čvorova ACBDFE, nacrtati sve moguće izglede ovog stabla.
A
/ \
C ...
\
B
=== Rešenje ===
Pogledajmo najpre obilazak
'''A''' ''CB'' ''DFE''

Levi deo je kompletan i D mora biti koren desnog podstabla. Odatle dolaze kombinacije:
A A A A A
/ \ / \ / \ / \ / \
C D C D C D C D C D
\ / \ \ / \ / \ \ \ \
B F E B F B F B F B F
/ \ \ /
E E E E

== 2. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju koja u binarnom stablu na čiji koren pokazuje pokazivač ''root'' utvrđuje da li postoji čvor čija pozicija u stablu (u odnosu na koren) je simetrična u odnosu na poziciju čvora na koji pokazuje pokazivač ''node''. Smatrati da svaki čvor binarnog stabla pored informacionog sadržaja sadrži pokazivače na levo i desno podstablo i pokazivač na roditeljski čvor.

=== Rešenje ===
Rešenje se sastoji od toga da se vratimo unazad, pamteći put, i onda silazimo opet ali obrnutim putem. Ukoliko se isprazni ulančana lista (koja glumi stek), to znači da postoji simetrični član.
{{Милокод|<nowiki>
CHECK_SYMMETRIC(root, node)
path = nil
step = nil
parent = nil
p = node
while p ≠ root do
step = GETNODE
parent = parent(p)
if left(parent) = p then
info(step) = 0
else
info(step) = 1
end_if
p = parent
next(step) = path
path = step
end_while
while p ≠ nil do
if path = nil then
return true
end_if
if info(path) = 0 then
p = right(p)
else
p = left(p)
end_if
step = path
path = next(path)
FREENODE(step)
end_while
return false
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Dekodovati poruku 0 1 3 3 4 5 4 9 primenom LZW algoritma, za dati početni sadržaj tabele simbola.

=== Rešenje ===
* Dekodovana poruka: ABABABBAABABABAB
* Tablica kodova:
{| class="wikitable"
! Simbol
! Kôd
|-
| A
| 0
|-
| B
| 1
|-
| C
| 2
|-
| AB
| 3
|-
| BA
| 4
|-
| ABA
| 5
|-
| ABB
| 6
|-
| BAA
| 7
|-
| ABAB
| 8
|-
| BAB
| 9
|-

|}

== 4. zadatak ==
=== Postavka ===
Ukoliko je usmereni graf sa ''n'' čvorova predstavljen listom susednosti, napisati u pseudokodu funkcije za izračunavanje ulaznog i izlaznog stepena zadatog čvora ''i''.

=== Rešenje ===
Rešenje zadatka je teorijski opisano na 159. strani knjige. Polazi se od pretpostavke da G predstavlja niz ulančanih lista, pa se sa G[i] uzima lista susednosti čvora i.
{{Милокод|<nowiki>
VERTEX IN DEG(G, n, i)
in_deg = 0
for k = 1 to n do
curr = next(G[k])
while (curr ≠ nil) do
if (info(curr) = i) then
in_deg = in_deg + 1
end_if
curr = next(curr)
end_while
end_for
return in_deg
</nowiki>}}
{{Милокод|<nowiki>
VERTEX OUT DEG(G, n, i)
out_deg = 0
curr = next(G[i])
while (curr ≠ nil) do
out_deg = out_deg + 1
curr = next(curr)
end_while
return out_deg
</nowiki>}}

== 5. zadatak ==
=== Postavka ===
Korišćenjem dinamičkih Huffman-ovih kodova, kodirati sekvencu simbola CBCBDAAABABA, ako se simboli A, B, C i D kodovima fiksne dužine kodiraju sa po dva bita 00, 01, 10, 11, respektivno

=== Rešenje ===
[[{{ns:6}}:ASP1 K2 2016 zadatak 5 postupak.jpg|thumb|right|Postupak rešavanja petog zadatka.]]
Kodirana poruka glasi: 10 001 1 01 0011 10000 1001 01 01 11 10 0.

Ilustracija postupka se može videti na slici desno.

== 6. zadatak ==
=== Postavka ===
Dato je binarno stablo ''B'', na čiji koren pokazuje pokazivač ''root''. Stablo ''B'' dobijeno je konverzijom m-arnog stabla ''T'' u odgovarajuće binarno. Napisati u pseudokodu '''iterativnu''' funkciju koja određuje red stabla T.

=== Rešenje ===
Funkcija koristi red za čekanje kao dodatnu strukturu pri implementaciji. U red se ređaju najlevlji sinovi, a next ide desno, po braći, i broji koliko se čvorova nalazi povezano desno za dati čvor (to su mu upravo njegova braća). Izlaz funkcije biće maksimalni broj braće pri nekom od prolazaka, što i jeste red stabla.
{{Милокод|<nowiki>
TREE ORDER BIN(root)
INIT_QUEUE(Q)
m = 0
next = root
INSERT(Q, next)
while (not QUEUE_EMPTY(Q)) do
m_curr = 0
next = DELETE(Q)
while (next ≠ nil) do
m_curr = m_curr + 1
if (left(next) ≠ nil) then
INSERT(Q, left(next))
end_if
next = right(next)
end_while
if (m_curr > m) then
m = m_curr
end_if
end_while
return m
</nowiki>}}

== 7. zadatak ==
=== Postavka ===
Pitanja:
<div class="abc-list">
# Komentarisati strategiju obrade istih prioriteta u prioritetnom redu primenjenom u statičkom ''Huffman''-ovom algoritmu.
# Kolika je minimalna, a kolika maksimalna dubina steka korišćenog u iterativnoj realizaciji ''preorder'' obilaska binarnog stabla sa n čvorova. Nacrtati takva stabla.
</div>

=== Rešenje ===
<div class="abc-list">
# Bolje rezultate ćemo dobiti ako dajemo veći prioritet "starijim" članovima reda, tj. stablima manje visine. Biranjem nižih stabala dobijamo kraće kodove te je algoritam efikasniji.
# Dubina steka direktno zavisi od broja desnih podstabala u stablu. U prvom slučaju razmatramo stablo najveće dubine - degenerisano stablo. Kada su svi čvorovi redom sa leve strane u ovakvom stablu, na stek se stavlja samo koren i ništa drugo, te je za ovakvo stablo dovoljan stek veličine '''1''', nezavisno od broja čvorova u stablu. Nasuprot tome, ako u stablo degenerisano na levo dodamo desne čvorove na svaki čvor, na stek će pri svakom posećivanju levog deteta biti dodato desno dete pa će na kraju posećivanja sve leve dece na steku biti sva desna deca, što je ukupno <math>\left\lfloor\frac{n}{2}\right\rfloor</math> čvorova.
</div>

== 8. zadatak ==
=== Postavka ===
Dato je binarno stablo <u>povezano</u> po ''inorder''-u. Napisati i objasniti pseudokod algoritma obilaska po '''inverznom''' ''inorder'' poretku.

=== Rešenje ===
Videti [[АСП1/К2 2018#6. zadatak|rešenje šestog zadatka sa drugog kolokvijuma 2018. godine]].

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К1 2020

2024-09-13T00:08:44Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_K1_1920.pdf Zadaci na sajtu predmeta.]

== 1. zadatak ==
=== Postavka ===
Neka je data funkcija ''random()'' koja vraća broj 0 ili 1 sa podjednakom verovatnoćom. Objasniti i ilustrovati primerom kako bi se korišćenjem zadate funkcije implementirala funkcija koja vraća vrednost 0 sa verovatnoćom 25%, a sa 1 verovatnoćom od 75%.

=== Rešenje ===
U okviru naše nove funkcije pozivamo funkciju random dva puta, i samo u jednom od četiri slučaja, na primer kada oba puta funkcija vrati nulu (00), naša nova funkcija vraća nulu, a za sve ostale slučajeve (01, 10, 11) vraća jedan. Na taj način je obezbeđeno da funkcija vraća 0 sa verovatnoćom 25%, a 1 sa verovatnoćom 75%.
{{Милокод|<nowiki>
NEW RANDOM()
if (random() = 0) and (random() = 0) then
return 0
else
return 1
end_if
</nowiki>}}

== 2. zadatak ==
=== Postavka ===
Neka je dat stek ''s1'' na kome se nalaze celi brojevi. Korišćenjem dodatnog steka ''s2'', transformisati sadržaj steka ''s1'' tako da on postane neopadajuće uređen niz. Smatrati da su operacije za rad sa stekom već implementirane.

=== Rešenje ===
Ideja jeste da na steku ''s1'' imamo sortirani i nesortirani deo. Na početku svi elementi su u nesortiranom delu i određujemo dubinu steka i trenutni maksimum na njemu. Svakom narednom iteracijom sve elemente koji su manji od maksimuma prebacujemo na stek ''s2'', dok sve maksimume izbacujemo sa steka, a zatim naknadno ubacujemo onoliko puta koliko su se pojavili. Na kraju, vraćamo sve ne-maksimalne elemente sa steka ''s2'' nazad u nesortirani deo steka ''s1'', pritom ponovo određujući maksimalni element u nesortiranom delu. Proces se ponavlja dok ima elemenata u maksimalnom delu.
{{Милокод|<nowiki>
SORT STACK(s1)
max = TOP(s1)
cnt = 0
while (not STACK_IS_EMPTY(s1)) do
x = POP(s1)
if (x > max) then
max = x
end_if
PUSH(s2, x)
cnt = cnt + 1
end_while
while (not STACK_IS_EMPTY(s2)) do
x = POP(s2)
PUSH(s1, x)
end_while
while (cnt > 0) do
num = cnt
tmp = 0
while (num > 0) do
x = POP(s1)
if (x < max) then
PUSH(s2, x)
else
cnt = cnt - 1
tmp = tmp + 1
end_if
num = num - 1
end_while
for i = 1 to tmp do
PUSH(s1, max)
i = i + 1
end_for
if (cnt > 0) then
max = TOP(s2)
while (not STACK_IS_EMPTY(s2)) do
x = POP(s2)
if (x > max) then
max = x
end_if
PUSH(s1, x)
end_while
end_if
end_while
</nowiki>}}

== 3. zadatak ==
=== Postavka ===
Posmatra se retka matrica A veličine NxM. Matrica je data u vidu kružnih ulančanih listi sa zaglavljima R<sub>A</sub> i C<sub>A</sub>. Napisati efikasnu iterativnu funkciju u pseudokodu koja datu matricu pretvara u vektorski format sa tri posebna vektora R, C i V. Funkcija takođe treba da vrati broj nenultih elemenata u matrici. Smatrati da je za sve vektore inicijalno rezervisano dovoljno prostora.

=== Rešenje ===
{{Милокод|<nowiki>
REFORMAT SPARSE MAT(A, N, M, Ra, Ca, R, C, V)
cnt = 1
for i = 1 to N do
curr = next(Ra[i])
R[i] = cnt
while (curr ≠ Ra[i]) do
C[cnt] = col(curr)
V[cnt] = val(curr)
cnt = cnt + 1
curr = next(curr)
end_while
end_for
R[N + 1] = cnt + 1
return cnt
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Transformisati izraz u infiksnom obliku
: A+C^(D-E!)!^F*B-C+G*H
u ekvivalentni izraz u postfiksnoj formi. Tabelu prioriteta operatora dopuniti odgovarajućim vrednostima, pri čemu je operacija faktorijel ! unarna operacija koja se grupiše sleva na desno i ima najveći prioritet od svih aritmetičkih operacija, a operacija ^ je operacija stepenovanja i grupiše se sdesna na levo. Transformaciju izraza prikazati po koracima.

=== Rešenje ===
{| class="wikitable"
! operator
! ul. pr !! stek pr. !! R
|-
! +, -
| 2 || 2 || -1
|-
! *, /
| 3 || 3 || -1
|-
! ^
| 5 || 4 || -1
|-
! !
| 6 || 6 || 0
|-
! (
| 7 || 0 || -
|-
! )
| 1 || - || -
|}
Postfiksna forma datog infiksnog izraza koji se dobije primenom algoritma za konverziju iz infiksa u postfiks je:
: ACDE!-!F^^B*+C-GH*+

== 5. zadatak ==
=== Postavka ===
Data je retko popunjena kvadratna matrica 2N x 2N. Nepodrazumevani elementi matrice smeštaju se u memoriji po vrstama. Indeksiranje kreće od 1, a svaki element matrice zauzima po 2 reči.
<div class="abc-list">
# Izvesti adresnu funkciju za pristup proizvoljnom elementu matrice.
# Implementirati funkciju GET koja vraća vrednost traženog elementa koji odgovara indeksima ''i'' i ''j'' matrice ''A''.
</div>

=== Rešenje ===
<div class="abc-list">
# <math>A_{ij} = \left\{
\begin{array}{ll}
A_{11} + ((i-1) \cdot 2+\left\lfloor{(j-1)/N)}\right\rfloor) \cdot 2 & i=j \lor i+j=2N+1 \\
0 & i \neq j \land i+j \neq 2N+1
\end{array}\right.</math>
# {{Милокод|<nowiki>
GET(A, i, j, N)
if (i = j or i + j = 2 * N + 1) then
return A[i, j]
else
return 0
end_if
</nowiki>}}
</div>

== 6. zadatak ==
=== Postavka ===
U nekom azilu za životinje su zbrinuti psi, mačke i kanarinci. Kada neko želi da usvoji životinju, on se može izjasniti da li želi psa, mačku, kanarinca ili mu je svejedno. Nije moguće uputiti zahtev za određenom (pojedinačnom) životinjom već u skladu sa odabirom vrste, biće dodeljena ili životinja tražene vrste koja je najduže u azilu, ako takva postoji, ili životinja koja je tu duže od svih drugih. Takođe, azil prihvata nove životinje dok se ne popuni kapacitet.
<div class="abc-list">
# Ukratko objasniti koja struktura se koristi za modelovanje azila i kako se ona održava sa dolaskom i usvajanjem životinja.
# Prikazati kako će struktura usvojena pod a) izgledati nakon usvajanja jednog psa, ako je prikazano trenutno stanje životinja u azilu po boksovima u kojima su smešteni. Pored vrste životinje, radi ilustracije, u zagradi se nalazi i trenutno vreme boravka životinje u azilu.
#: M(2) K(1) P(6) P(3) M(6) M(7) K(5) P(3)
</div>

=== Rešenje ===
{{delimično rešeno}}

== 7. zadatak ==
=== Postavka ===
U nekom programu je potrebno prestaviti skup celih brojeva u opsegu od 0 do 999. Neka su u programskom jeziku koji se koristi na raspolaganju celobrojni tipovi na 4 bajta širine, a pokazivači zauzimaju 4 bajta. Objasniti na koje načine se ovakav skup može predstaviti sekvencijalnom i ulančanom reprezantacijom, a zatim odrediti prosečno zauzeće prostora u oba slučaja pod pretpostavkom da se u skupu u proseku nalazi 10 elemenata.

=== Rešenje ===
{{delimično rešeno}}

== 8. zadatak ==
=== Postavka ===
Napisati u pseudokodu implementaciju funkcije koja u dvostruko ulančanu listu celih brojeva na koju ukazuje pokazivač ''list'' ubacuje vrednost ''x'' ispred elementa na koji ukazuje pokazivač ''node''. Voditi računa da lista ostane u potpuno konzistentnom stanju.

=== Rešenje ===
Pretpostavljamo da je ''node'' validan pokazivač na element koji se nalazi u listi ''list''.
{{Милокод|<nowiki>
INSERT BEFORE D(list, node, x)
new_node = Node(x)
new_node.prev = node.prev
new_node.next = node
if node.prev == null
list = new_node
else
node.prev.next = new_node
node.prev = new_node
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/Август 2021

2024-09-13T00:08:42Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
Ovaj članak je rekreacija avgustovskog roka koji nije objavljen.

== 1. zadatak ==
{{delimično rešeno}}
=== Postavka ===
Data je retka matrica koja je prikazana na slici. (Data je matrica npr. 5*6 sa 5 ili 6 random nenultih elemenata).
<div class="abc-list">
# Nacrtati izgled delova memorije u kojima se čuva ova retka matrica, ako se primenjuje ''Compressed Sparse Row'' način čuvanja.
# Napisati funkciju u pseudokodu koja na osnovu sačuvane ''Compressed Sparse Row'' reprezentacije matrice M i unetog broja ''i'' štampa sve nenulte elemente ''i''-te vrste.
</div>
=== Rešenje ===
== 2. zadatak ==
=== Postavka ===
Navedite načine reprezentacije grafova i njihove prednosti i mane.
=== Rešenje ===
Potrebno je samo napisati i prokomentarisati tabelu 7.1 sa strane 161 iz udžbenika.
== 3. zadatak ==
=== Postavka ===
Zadato je binarno stablo S i date su adrese dva čvora ''x'' i ''y''. Napisati funkciju u pseudokodu koja pronalazi najnižeg zajedničkog pretka zadata dva čvora.
=== Rešenje ===
{{Милокод|<nowiki>
LOWEST_COMMON_ANCESTOR(S,x,y)
return FIND(S,x,y)
</nowiki>}}
{{Милокод|<nowiki>
FIND(S,x,y)
if S == null
return null
end_if
if S == x || S == y
return S
end_if
left = FIND(S.left,x,y)
right = FIND(S.right,x,y)
if left ≠ null && right ≠ null
return S
else if left ≠ null
return left
else if right ≠ null
return right
else
return null
end_if
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Potpuno formalno izvesti međusobnu zavisnost interne i eksterne dužine puta u binarnom stablu i kratko obrazložiti.
=== Rešenje ===
<math> PE = PI + 2n </math>, gde je <math>n</math> broj čvorova u stablu
izvođenje indukcijom, kao u knjizi/na predavanju.
== 5. zadatak ==
=== Postavka ===
Potrebno je realizovati aplikaciju za obradu slika. Korisniku je potrebno da za uneti set slika i unet set operacija omogućiti da se sve operacije izvrše nad svim unetim slikama. Navesti koje strukture je pogodno koristiti za čuvanje seta slika i seta operacija i objasniti zašto. Napisati funkciju u pseudokodu koja obrađuje uneti set slika unetim setom operacija, u skladu sa odabranim strukturama podataka.
=== Rešenje ===
''Rešenje je krajnje trivijalno i ovde je navedeno jedno koje je bodovano maksimalnim brojem poena.''
Za oba se može koristiti jednostruko ulančana lista (jer nije bitan redosled kojim će se operacije izvršavati jer će se svakako sve izvršiti na svim slikama), a ulančane liste su pogodno za lako dodavanje i brisanje elemenata.
{{Милокод|<nowiki>
PROCESS_IMAGES(images, operations)
S = head(images)
O = head(operations)
while s ≠ NIL do
while o ≠ NIL do
data(S) = (operation(O))(data(S))
end_while
end_while
</nowiki>}}
== 6. zadatak ==
=== Postavka ===
'''Huffman-ov algoritam''': Dat јe tekst sa 6 slova dužine 21 slovo. Odrediti izgled stabla dobijenog statičkim Huffman-om za ovaj tekst i uporediti prosečan broj bitova za čuvanje ovog teksta, kao i jednog slova u slučaju da se čuva podrazumevano i na osnovu ovog Huffman stabla. Frekvenciju slova zaključiti iz teksta.
=== Rešenje ===
Najobičniji statički Huffman za zadatim frekvencijama.

== 7. zadatak ==
=== Postavka ===
Dat je grad koji je modelovan usmerenim grafom, tako što su čvorovi lokacije u gradu (pekara, apoteka, biblioteka itd), a težine grana između čvorova vreme u minutima koje je potrebno da se peške dođe od izvorišne do odredišne lokacije. Dete želi da stigne od škole (čvor ''X'') do kuće (čvor ''Y'') najbrže moguće. Međutim, postoji opasan deo grada (čvor Z), koji nije bezbedan za decu i koji ona treba da izbegavaju. Napisati funkciju u pseudokodu koja na osnovu zadatog grafa ''G'' (nije data reprezentacija, rešenje treba da bude konceptualno), zadatih lokacija kuće i škole, ''Y'' i ''X'', i opasnog dela grada ''Z'', pronalazi najkraće vreme koje je detetu potrebno od škole do kuće.
=== Rešenje ===
Zadatak se rešava implementacijom Dijkstrinog algortima, tako što kada se u uzimanju čvorova redom po težinskoj udaljenosti od početnog dođe do "opasnog" čvora ''Z'', za njega se upiše težina beskonačno i ta petlja preskoči sa '''continue'''. Na kraju se samo proveri dostižnost ciljnog čvora.
== 8. zadatak ==
=== Postavka ===
Dat je graf na slici (ima nekih 7-8 čvorova). Za dati graf uraditi topološko sortiranje i prikazati graf dobijen tako.
=== Rešenje ===
{{delimično rešeno}}
== 9. zadatak==
=== Postavka ===
<div class="abc-list">
# Detaljno opisati postupak za pronalaženje jako povezanih komponenti u grafu.
# Za graf sa slike (nekih 7-8 čvorova) po koracima primeniti algoritam za pronalaženje jako povezanih komponenti i rezultujući graf.
</div>
=== Rešenje ===
Videti zadatak iz [[АСП1/Јул 2020#2. zadatak 3|julskog roka 2020.]]

== 10. zadatak ==
=== Postavka ===
Potrebno je čuvati neki skup brojeva koji će biti u opsegu između 1 i 100.
<div class="abc-list">
# Uporediti sekvencijalnu i ulančanu reprezentaciju skupa i uporediti složenost operacija dodavanja elementa, brisanja elementa i provere pripadnosti elementa skupu za ove dve reprezentacije.
# Neka je dat skup (npr. 5, 14, 44, 45, 78, 98) prikazati jednu i drugu reprezenatciju nakon operacija (npr. dodavanje 7, dodavanje 46, dodavanje 97, brisanje 78).
</div>
=== Rešenje ===
Kod sekvencijalne se alocira vektor S[1:100] i ukoliko je element ''X'' u skupu, u polje ''S''[''X''] se upisuje 1, inače 0. Kod ulančane reprezentacije je najefikasnije čuvati ulančanu listu u rastućem ili opadajućem poretku. Dodavanje/brisanje u sekvencijalnoj se radi u O(1) tako što se samo proveri ili izmeni indeks u nizu. Kod ulančane reprezentacije je potrebno proći kroz listu do lokacije na koju treba umetnuti/obrisati element (po rastućem ili opadajućem poretku).

[[Категорија:АСП1]]
[[Категорија:Рокови]]

АСП1/Јун 2020

2024-09-13T00:08:38Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_jun_2020.pdf Zadaci]

== Prvi kolokvijum ==
=== 1. zadatak ===
==== Postavka ====
Data je ulančana lista kod koje svaki element ima određeni informacioni sadržaj, pokazivač na sledeći element u listi, kao i pokazivač na neki proizvoljan element liste. Napisati u pseudokodu funkciju DEEP_COPY koja prihvata pokazivač na prvi element liste i pravi kopiju liste sa istim načinom i poretkom povezivanja kao u polaznoj listi (duboka kopija).

==== Rešenje ====
{{Милокод|<nowiki>
DEEP COPY(head)
p = head
q = r = new_node = nil
new_head = new_tail = nil
while p ≠ nil do
new_node = GETNODE
value(new_node) = value(p)
other_p(new_node) = other_p(p)
if new_head = nil then
new_head = new_node
else
next(new_tail) = new_node
end_if
new_tail = new_node
p = next(p)
end_while
p = head
q = new_head
while p ≠ nil do
r = new_head
while r ≠ nil do
if other_p(r) = p then
other_p(r) = q
end_if
r = next(r)
end_while
p = next(p)
q = next(q)
end_while
return new_head
</nowiki>}}

=== 2. zadatak ===
==== Postavka ====
Neka je datoj funkciji POST_TO_INF prosleđen neki aritmetički izraz u postfiksnom obliku (''expression''). Operandi su velika slova engleskog alfabeta. Napisati iterativnu implementaciju ove funkcije koja kao rezultat vraća dati aritmetički izraz transformisan u infiksnu formu. Rezultujući izraz formirati korišćenjem potpunih zagrada.

==== Rešenje ====
{{Милокод|<nowiki>
POST TO INF(expression)
stack = nil
expr1 = expr2 = nil
for c in expression do
if IS_BINARY_OPERATOR(c) then
expr1 = POP(stack)
expr2 = POP(stack)
PUSH(stack, "(" + expr1 + c + expr2 + ")")
else if IS_UNARY_OPERATOR(c) then
expr1 = POP(stack)
PUSH(stack, "(" + c + expr1 + ")")
else
PUSH(stack, c)
end_if
end_for
return POP(stack)
</nowiki>}}
{{Милокод|<nowiki>
PUSH(stack, value)
node = GETNODE
value(node) = value
next(node) = stack
stack = node
</nowiki>}}
{{Милокод|<nowiki>
POP(stack, value)
if stack = nil then
ERROR(Underflow)
else
node = stack
value = value(node)
stack = next(stack)
FREENODE(node)
return value
end_if
</nowiki>}}

=== 3. zadatak ===
==== Postavka ====
Vektorska implementacija prioritetnog reda

U prioritetni red se prvo redom ubacuju sledeći elementi 2, 18, 19, 1, 9, 6. Nakon toga se iz reda uklanjaju dva elementa i potom dodaju elementi 15, 17 i 11, redom. Kapacitet vektora u koji se smeštaju elementi je 7. Manji broj označava veći prioritet. Za svaki od datih načina implementacije prikazati izgled reda nakon inicijalnog umetanja, nakon svakog brisanja i svakog umetanja poslednja tri elementa (15, 17 i 11). Ukoliko implementacija koristi neke dodatne pokazivače, naznačiti ih ispod odgovarajućeg indeksa u vektoru.
<div class="abc-list">
# Implementacija održavanjem uređenosti reda
# Implementacija markiranjem elemenata, bez umetanja preko markiranog elementa
# Implementacija markiranjem elemenata, sa umetanjem preko markiranog elementa
</div>

==== Rešenje ====
<div style="display: flex; justify-content: space-between;">
{| class="wikitable"
|+ Implementacija održavanjem uređenosti reda
| 1 || 2 || 6 || 9 || 18 || 19 ||
|-
| colspan="7" |
|-
| 2 || 6 || 9 || 18 || 19 || ||
|-
| colspan="7" |
|-
| 6 || 9 || 18 || 19 || || ||
|-
| colspan="7" |
|-
| 6 || 9 || 15 || 18 || 19 || ||
|-
| colspan="7" |
|-
| 6 || 9 || 15 || 17 || 18 || 19 ||
|-
| colspan="7" |
|-
| 6 || 9 || 11 || 15 || 17 || 18 || 19
|}
{| class="wikitable"
|+ Implementacija markiranjem elemenata, bez umetanja preko markiranog elementa
| 2 || 18 || 19 || 1 || 9 || 6 ||
|-
| colspan="7" |
|-
| 2 || 18 || 19 || X || 9 || 6 ||
|-
| colspan="7" |
|-
| X || 18 || 19 || X || 9 || 6 ||
|-
| colspan="7" |
|-
| X || 18 || 19 || X || 9 || 6 || 15
|-
| colspan="7" |
|-
| 18 || 19 || 9 || 6 || 15 || 17 ||
|-
| colspan="7" |
|-
| 18 || 19 || 9 || 6 || 15 || 17 || 11
|}
{| class="wikitable"
|+ Implementacija markiranjem elemenata, sa umetanjem preko markiranog elementa
| 2 || 18 || 19 || 1 || 9 || 6 ||
|-
| colspan="7" |
|-
| 2 || 18 || 19 || X || 9 || 6 ||
|-
| colspan="7" |
|-
| X || 18 || 19 || X || 9 || 6 ||
|-
| colspan="7" |
|-
| 15 || 18 || 19 || X || 9 || 6 ||
|-
| colspan="7" |
|-
| 15 || 18 || 19 || 17 || 9 || 6 ||
|-
| colspan="7" |
|-
| 15 || 18 || 19 || 17 || 9 || 6 || 11
|}
</div>

=== 4. zadatak ===
==== Postavka ====
Neka se blok-dijagonalna matrica definiše kao kvadratna matrica ''A'' dimenzija ''n x n'' čiji su nenulti elementi smešteni samo u okviru blokova dimenzije ''k x k'' koji se nalaze na glavnoj dijagonali matrice, kao na slici i važi uslov ''n mod k = 0''. Ukratko objasniti postupak smeštanja i izvesti adresnu funkciju pri pristupu proizvoljnom elementu matrice ''A[1:n, 1:n]'' smeštene '''po vrstama'''. Smatrati da se jedan element matrice smešta u tačno jednu memorijsku reč.
{| class="wikitable"
|+ Primer matrice za <math>n = 6, k = 2</math>
! -
! 1 !! 2 !! 3 !! 4 !! 5 !! 6
|-
! 1
| X || X || || || ||
|-
! 2
| X || X || || || ||
|-
! 3
| || || X || X || ||
|-
! 4
| || || X || X || ||
|-
! 5
| || || || || X || X
|-
! 6
| || || || || X || X
|}

==== Rešenje ====
# Prvo gledamo u kojem se "bloku" na dijagonali nalazi element koji biramo. Taj blok možemo naći kao <math>i_b = \left\lfloor\frac{j-1}{k}\right\rfloor</math>.
# Nakon toga, možemo na osnovu indeksa bloka (koji kreće od 0) možemo naći <math>i</math> i <math>j</math> indekse za gornji levi ćošak tog bloka kao <math>i_{blok} = j_{blok} = i_b \cdot k + 1</math>.
# Sada računamo indeks trenutnog elementa na osnovu tri podatka: koliko se elemenata nalazi u prethodnim blokovima, koliko se elemenata nalazi iznad trenutnog elementa u trenutnom bloku i koliko se elemenata nalazi levo od trenutnog elementa u trenutnom bloku.
## '''Prethodni blokovi:''' <math>A_{pret} = i_b \cdot k^2</math> (u svakom bloku se nalazi po <math>k^2</math> elemenata)
## '''Iznad:''' <math>A_{izn} = (i - i_{blok}) k</math> (u svakom redu nalazi se <math>k</math> elemenata)
## '''Levo:''' <math>A_{lev} = j - j_{blok}</math>
# '''Konačna adresna funkcija:''' <math>A = A_{11} + (A_{pret} + A_{izn} + A_{lev}) S = A_{11} + (i_b \cdot k^2 + (i - i_{blok}) k + j - j_{blok}) S =</math>
#: <math>= A_{11} + \left(\left\lfloor\frac{j-1}{k}\right\rfloor \cdot k^2 + \left(i - \left\lfloor\frac{j-1}{k}\right\rfloor \cdot k - 1\right) k + j - \left\lfloor\frac{j-1}{k}\right\rfloor \cdot k - 1\right) S</math>
# '''Uslov:''' <math>|i - j| < k</math>

== Drugi kolokvijum ==
=== 1. zadatak ===
==== Postavka ====
''Postorder'' i ''preorder'' obilazak
<div class="abc-list">
# Da li je, pomoću datog ''preorder'' i ''postorder'' obilaska binarnog stabla moguće rekonstruisati jedinstveno binarno stablo? Detaljno obrazložiti odgovor.
# Ukoliko je ''preorder'' obilazak stabla '''VALDENJOM''', a ''postorder'' obilazak stabla '''DLEAOMJNV''', rekonstruisati stablo. Ukoliko postoji više mogućih stabala, dati izgled svakog od njih.
</div>

==== Rešenje ====
<div class="abc-list">
# Ne može, jer ako neki čvor ima samo jedno dete ne može se odrediti da li je to levo ili desno dete samo iz ''preorder'' i ''postorder'' obilaska tog stabla.
# Moguće su četiri rekonstrukcije, jer se ne zna da li je čvor D levo ili desno dete čvora L i takođe da li je čvor J levo ili desno dete čvora N.
</div>
V V V V
/ \ / \ / \ / \
A N A N A N A N
/ \ / / \ / / \ \ / \ \
L E J L E J L E J L E J
/ / \ \ / \ / / \ \ / \
D O M D O M D O M D O M

=== 2. zadatak ===
==== Postavka ====
Slova Morzeove azbuke kodiraju se kao kombinacija crtica (-) i tačaka (.) (A = .- , B= -… , itd.). Neka je poznat način kodiranja svih slova azbuke i poznato je da su kodovi prefiksni, odnosno da kraći kod '''može''' biti prefiks dužeg koda.
<div class="abc-list">
# Predložiti i opisati strukturu stabla pogodnu za operaciju dekodovanja pojedinačnih simbola poruke.
# Implementirati funkciju DECODE_MORSE koja na osnovu strukture predložene pod a) dekodira neku zadatu poruku. Poruka je prosleđena kao argument funkcije (''msg'') i predstavlja nisku crtica i tacaka. Smatrati da su kodirana slova odvojena blanko znakovima.
</div>

==== Rešenje ====
Struktura pogodna za dekodiranje Morzeovih kodova jeste binarno stablo gde grane ulevo označavaju da kod na tom mestu sadrži tačku a grane udesno da kod na tom mestu sadrži crtu i u svakom čvoru se čuva u koje slovo se dekodira kod čije su grane praćene da bi se stiglo do tog čvora, ili 0 ako se taj kod ne dekodira ni u jedno slovo.
{{Милокод|<nowiki>
DECODE MORSE(msg)
i = 0
new_msg = ""
while msg[i] ≠ 0 do
p = root
while (msg[i] ≠ ' ') and (p ≠ nil) do
if msg[i] = '.' then
p = left(p)
else if msg[i] = '-' then
p = right(p)
else
ERROR(Invalid code)
end_if
i = i + 1
end_while
i = i + 1
if (p = nil) or (sign(p) = 0) then
ERROR(Invalid code)
end_while
new_msg = new_msg + sign(p)
end_while
return new_msg
</nowiki>}}

=== 3. zadatak ===
==== Postavka ====
Primenom LZW algoritma '''prikazati postupak''' kodiranja znakovnog niza BIBBIDIBOBBIDIBOO, ako je data početna tabela sa kodovima simbola. Napisati kodiranu poruku i izgled tabele simbola nakon postupka kodiranja.

==== Rešenje ====
Krajnje kodirano: '''0204153628033'''
<div style="display: flex; justify-content: space-between;">
{| class="wikitable"
|+ Tablica LZW kodova (prva četiri data u postavci)
! Slovo
! Kod
|-
| B || 0
|-
| D || 1
|-
| I || 2
|-
| O || 3
|-
| BI || 4
|-
| IB || 5
|-
| BB || 6
|-
| BID || 7
|-
| DI || 8
|-
| IBO || 9
|-
| OB || 10
|-
| BBI || 11
|-
| ID || 12
|-
| DIB || 13
|-
| BO || 14
|-
| OO || 15
|}
{| class="wikitable"
|+ Postupak dekodovanja
! Unos
! String
! Ispis
! Dodaje se u tabelu
|-
| B || B || ||
|-
| I || BI || 0 (B) || BI
|-
| B || IB || 2 (I) || IB
|-
| B || BB || 0 (B) || BB
|-
| I || BI || ||
|-
| D || BID || 4 (BI) || BID
|-
| I || DI || 1 (D) || DI
|-
| B || IB || ||
|-
| O || IBO || 5 (IB) || IBO
|-
| B || OB || 3 (O) || OB
|-
| B || BB || ||
|-
| I || BBI || 6 (BB) || BBI
|-
| D || ID || 2 (I) || ID
|-
| I || DI || ||
|-
| B || DIB || 8 (DI) || DIB
|-
| O || BO || 0 (B) || BO
|-
| O || OO || 3 (O) || OO
|-
| || O || 3 (O) ||
|}
</div>

=== 4. zadatak ===
==== Postavka ====
Dužine puteva u stablu
<div class="abc-list">
# Formalno definisati i objasniti internu, eksternu i težinsku eksternu dužinu puta u binarnom stablu.
# Napisati u pseudokodu implementaciju funkcije koja izračunava težinsku eksternu dužinu puta binarnog stabla na čiji koren ukazuje pokazivač root. Smatrati da listovi stabla poseduju informaciju o težini čvora. Dozvoljeno koristiti gotove linearne strukture podataka.
</div>

==== Rešenje ====
* Interna dužina puta je zbir dužina puteva od korena do svakog internog čvora.
* Eksterna dužina puta je zbir dužina puteva od korena do svakog eksternog čvora.
* Eksterna težinska dužina puta je zbir proizvoda dužina puteva od korena do svakog eksternog čvora i težine tih eksternih čvorova.
Za potrebe ovog algoritma smatra se da su eksterni čvorovi izjednačeni sa listovima.
{{Милокод|<nowiki>
CALC EXT WPL(root)
QUEUE_INIT(Q_nodes)
QUEUE_INIT(Q_levels)
INSERT(Q_nodes, root)
INSERT(Q_levels, 0)
node = nil
level = 0
pwe = 0
while not QUEUE_EMPTY(Q_nodes) do
node = DELETE(Q_nodes)
level = DELETE(Q_levels)
if (left(node) = nil) and (right(node) = nil) then
pwe = pwe + level * weight(node)
end_if
if left(node) ≠ nil then
INSERT(Q_nodes, left(node))
INSERT(Q_levels, level + 1)
end_if
if right(node) ≠ nil then
INSERT(Q_nodes, right(node))
INSERT(Q_levels, level + 1)
end_if
end_while
return pwe
</nowiki>}}

== Treći kolokvijum ==
=== 1. zadatak ===
==== Postavka ====
Dat je usmeren, aciklični graf predstavljen pomoću matrice susednosti kod koga su čvorovi numerisani od 1 do ''n''. Objasniti kako se korišćenjem odgovarajućeg grafovskog algoritma mogu prenumerisati čvorovi tako da matrica susednosti postane gornja trougaona i napisati u pseudokodu funkciju RELABEL koja prenumerisanje.

==== Rešenje ====
{{Милокод|<nowiki>
RELABEL(G, n)
topsort_length = 0
for i = 1 to n do
in_deg[i] = 0
for j = 1 to n do
if M[j, i] then
in_deg[i] = in_deg[i] + 1
end_if
end_for
if in_deg[i] = 0 then
topsort_length = topsort_length + 1
topsort[topsort_length] = i
end_if
end_for
for i = 1 to n do
node = topsort[i]
for j = 1 to n do
if M[node, j] then
in_deg[j] = in_deg[j] - 1
if in_deg[j] = 0 then
topsort_length = topsort_length + 1
topsort[topsort_length] = j
end_if
end_if
end_for
end_for
return topsort
</nowiki>}}

=== 2. zadatak ===
==== Postavka ====
[[{{ns:6}}:ASP1 jun 2020 zadatak 3.2 graf.svg|thumb|Graf iz postavke drugog zadatka.]]
''Floyd''-ov algoritam. Na slici je dat usmereni težinski graf.
<div class="abc-list">
# Predstaviti dati graf odgovarajućom matričnom reprezentacijom.
# Pronaći najkraća rastojanja među čvorovima upotrebom ''Floyd''-ovog algoritma. Postupak prikazati po koracima.
# Na osnovu rezultat pod b) rekonstruisati najkraću putanju između čvorova ''b'' i ''d''.
</div>

==== Rešenje ====
Rešenje stavke pod c je '''bfaced'''.
{| class="wikitable"
|+ Matrična reprezentacija grafa
! - !! a !! b !! c !! d !! e !! f
|-
! a
| ∞ || 7 || 3 || 10 || 8 || ∞
|-
! b
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
! c
| ∞ || ∞ || ∞ || 5 || 2 || ∞
|-
! d
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
! e
| ∞ || ∞ || ∞ || 1 || ∞ || ∞
|-
! f
| 6 || ∞ || ∞ || ∞ || ∞ || ∞
|}
<div style="display: flex; flex-wrap: wrap; justify-content: space-between;">
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 1</math>
|-
| ∞ || 7 || 3 || 10 || 8 || ∞
|-
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
| ∞ || ∞ || ∞ || 5 || 2 || ∞
|-
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
| ∞ || ∞ || ∞ || 1 || ∞ || ∞
|-
| 6 || 13 || 9 || 16 || 14 || ∞
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 1</math>
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 1 || 1 || 1 || 1 || 0
|}
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 2</math>
|-
| ∞ || 7 || 3 || 10 || 8 || 8
|-
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
| ∞ || ∞ || ∞ || 5 || 2 || ∞
|-
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
| ∞ || ∞ || ∞ || 1 || ∞ || ∞
|-
| 6 || 13 || 9 || 16 || 14 || 14
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 2</math>
|-
| 0 || 0 || 0 || 0 || 0 || 2
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 1 || 1 || 1 || 1 || 2
|}
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 3</math>
|-
| ∞ || 7 || 3 || 8 || 5 || 8
|-
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
| ∞ || ∞ || ∞ || 5 || 2 || ∞
|-
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
| ∞ || ∞ || ∞ || 1 || ∞ || ∞
|-
| 6 || 13 || 9 || 14 || 11 || 14
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 3</math>
|-
| 0 || 0 || 0 || 3 || 3 || 2
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 1 || 1 || 3 || 3 || 2
|}
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 4</math>
|-
| ∞ || 7 || 3 || 8 || 5 || 8
|-
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
| ∞ || ∞ || ∞ || 5 || 2 || 17
|-
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
| ∞ || ∞ || ∞ || 1 || ∞ || 13
|-
| 6 || 13 || 9 || 14 || 11 || 14
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 4</math>
|-
| 0 || 0 || 0 || 3 || 3 || 2
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 4
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 4
|-
| 0 || 1 || 1 || 3 || 3 || 2
|}
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 5</math>
|-
| ∞ || 7 || 3 || 6 || 5 || 8
|-
| ∞ || ∞ || ∞ || 22 || ∞ || 1
|-
| ∞ || ∞ || ∞ || 3 || 2 || 15
|-
| ∞ || ∞ || ∞ || ∞ || ∞ || 12
|-
| ∞ || ∞ || ∞ || 1 || ∞ || 13
|-
| 6 || 13 || 9 || 12 || 11 || 14
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 5</math>
|-
| 0 || 0 || 0 || 5 || 3 || 2
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 5 || 0 || 5
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 4
|-
| 0 || 1 || 1 || 5 || 3 || 2
|}
{| class="wikitable"
|+ ''Floyd''-ov algoritam za <math>k = 6</math>
|-
| 14 || 7 || 3 || 6 || 5 || 8
|-
| 7 || 14 || 10 || 13 || 12 || 1
|-
| 21 || 28 || 24 || 3 || 2 || 15
|-
| 18 || 25 || 21 || 24 || 23 || 12
|-
| 19 || 26 || 22 || 1 || 24 || 13
|-
| 6 || 13 || 9 || 12 || 11 || 14
|}
{| class="wikitable"
|+ Matrica prethodnika za <math>k = 6</math>
|-
| 6 || 0 || 0 || 5 || 3 || 2
|-
| 6 || 6 || 6 || 6 || 6 || 0
|-
| 6 || 6 || 6 || 5 || 0 || 5
|-
| 6 || 6 || 6 || 6 || 6 || 0
|-
| 6 || 6 || 6 || 0 || 6 || 4
|-
| 0 || 1 || 1 || 5 || 3 || 2
|}
</div>

=== 3. zadatak ===
==== Postavka ====
[[{{ns:6}}:ASP1 jun 2020 zadatak 3.3 graf.svg|thumb|Graf iz postavke trećeg zadatka.]]
Na slici je dat protočni graf u okviru koga postoji već uspostavljen protok po pojedinim granama. Nacrtati rezidualni graf i navesti sve moguće puteve povećanog protoka u sledećoj iteraciji, uz navođenje kapaciteta za te puteve.

==== Rešenje ====
[[{{ns:6}}:ASP1 jun 2020 zadatak 3.3 rezidualni graf.svg|thumb|Rezidualni graf za treći zadatak.]]
Mogući putevi povećanog protoka:
* SCBT (2)
* SACBT (2)
* SDECBT (2)
* SADECBT (2)

=== 4. zadatak ===
==== Postavka ====
Neka se posmatra se neusmeren netežinski graf.
<div class="abc-list">
# Na koji način se u ovakvom grafu može ostvariti provera cikličnosti grafa korišćenjem algoritama za obilazak po širini i po dubini? Objasniti i nacrtati primer.
# Napisati u pseudokodu implementaciju funkcije koja korišćenjem obilaska po širini određuje da li je prosleđeni graf cikličan. Smatrati da je graf predstavljen matricom susednosti. Dozvoljeno je koristiti gotove linearne strukture podataka.
</div>

==== Rešenje ====
Obilaskom po širini ili dubini se u neusmerenom grafu može detektovati ciklus tako što prilikom obilaska detektujemo da posećujemo čvor koji smo već posetili, a da to nije otac trenutnog čvora u stablu obilaska.
{{Милокод|<nowiki>
IS CYCLIC(G)
for i = 1 to n do
visited[i] = 0
end_for
QUEUE_INIT(Q_nodes)
QUEUE_INIT(Q_parents)
INSERT(Q_nodes, 1)
INSERT(Q_parents, 0)
node = parent = 0
while not QUEUE_EMPTY(Q_nodes) do
node = DELETE(Q_nodes)
parent = DELETE(Q_parents)
for (node, i) ∈ E do
if i = parent then
continue
end_if
if visited[i] then
return true
end_if
INSERT(Q_nodes, i)
INSERT(Q_parents, node)
visited[i] = true
end_for
end_while
return false
</nowiki>}}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/Јул 2020

2024-09-13T00:08:28Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_jul_2020.pdf Zadaci]

== Prvi kolokvijum ==
=== 1. zadatak ===
{{delimično rešeno}}
==== Postavka ====
Potrebno je retku matricu sa slike predstaviti korišćenjem ulančanih lista na dva načina. Ukratko objasniti kako se to može postići i namenu svakog polja u zapisu kojim je predstavljen jedan element liste, a zatim prikazati i njihov sadržaj ako je podrazumevana vrednost 0 za oba načina.
{| class="wikitable"
|+ Retka matrica sa slike
|-
| 0 || 3 || 12 || 0 || 0
|-
| 0 || 1 || 0 || 74 || 0
|-
| 0 || 7 || 0 || 32 || 0
|-
| 8 || 0 || 2 || 15 || 0
|-
| 0 || 0 || 0 || 98 || 0
|}

==== Rešenje ====

=== 2. zadatak ===
==== Postavka ====
Posmatra se stek implementiran dvostruko ulančanom listom sa zaglavljem, koje sadrži pokazivač na prvi element liste. Pored standardnih operacija, neophodno je podržati i efikasnu operaciju dohvatanja maksimalnog elementa na steku (u ''O(1)'').
<div class="abc-list">
# Ako se u zaglavlju nalazi još jedan pokazivač na dodatnu listu, objasniti kako se ta dodatna lista može koristiti za implementaciju dodatne tražene operacije, bez gubitka efikasnosti standardnih operacija.
# Koristeći ideju opisanu pod a), napisati tražene operacije.
</div>

==== Rešenje ====
Dohvatanje maksimalnog elementa u O(1) postižemo dodatnom listom koja čuva dotadašnji maksimalni element. Lista koja drži elemente se zove ''stack'', a lista koja drži maksimalne elmente se zove ''max''.
{{Милокод|<nowiki>
PUSH(header, x)
if header = nil then
return
end_if
t = GETNODE()
info(t) = x
next(t) = stack(header)
stack(header) = t
t = GETNODE()
if max(header) ≠ NIL and x < max(header) then
info(t) = info(max(header))
else
info(t) = x
end_if
next(t) = max(header)
max(header) = t
</nowiki>}}
{{Милокод|<nowiki>
POP(header)
if header ≠ NIL and stack(header) ≠ NIL then
t = stack(header)
stack(header) = next(stack(header))
value = info(t)
FREENODE(t)
t = max(header)
max(header) = next(max(header))
FREENODE(t)
return value
end_if
return NIL
</nowiki>}}
{{Милокод|<nowiki>
MAX(header)
return info(max(header))
</nowiki>}}

=== 3. zadatak ===
==== Postavka ====
Transformisati izraz u infiksnom obliku A*(B+C)*(A-D!!)+F/G+K u ekvivalentni izraz u postfiksnoj formi. Tabelu prioriteta operatora dopuniti odgovarajućim vrednostima, pri čemu treba usvojiti standardne prioritete i grupisanje za operacije +,-,* i /. Operacija faktorijel ! unarna operacija koja se grupiše sleva na desno i ima najveći prioritet od svih aritmetičkih operacija. Transformaciju izraza prikazati po koracima.

==== Rešenje ====
{| class="wikitable"
! Operator
! Ulazni prioritet
! Stek prioritet
! Rang
|-
| +, - || 2 || 2 || -1
|-
| *, / || 3 || 3 || -1
|-
| ! || 5 || 4 || 0
|-
| ( || 6 || 1 || 0
|-
| ) || 0 || - || 0
|}
{| class="wikitable"
! Simbol
! Stek
! Postfiksni izraz
! Rang
|-
| A || || A || 1
|-
| * || * || A || 1
|-
| ( || *( || A || 1
|-
| B || *( || AB || 2
|-
| + || *(+ || AB || 2
|-
| C || *(+ || ABC || 3
|-
| ) || * || ABC+ || 2
|-
| * || * || ABC+* || 1
|-
| ( || *( || ABC+* || 1
|-
| A || *( || ABC+*A || 2
|-
| - || *(- || ABC+*A || 2
|-
| D || *(- || ABC+*AD || 3
|-
| ! || *(-! || ABC+*AD || 3
|-
| ! || *(-!! || ABC+*AD || 3
|-
| ) || * || ABC+*AD!!- || 2
|-
| + || + || ABC+*AD!!-* || 1
|-
| F || + || ABC+*AD!!-*F || 2
|-
| / || +/ || ABC+*AD!!-*F || 2
|-
| G || +/ || ABC+*AD!!-*FG || 3
|-
| + || + || ABC+*AD!!-*FG/+ || 1
|-
| K || + || ABC+*AD!!-*FG/+K || 2
|-
| EOF || || '''ABC+*AD!!-*FG/+K+''' || 1
|}

=== 4. zadatak ===
==== Postavka ====
Neka se dvostrani red u pseudojeziku opisuje sledećim zapisom:
deque = RECORD
array, front, rear, size
END
gde ''array'' predstavlja niz ograničenog kapaciteta ''size'', a ''front'' i ''rear'' pokazivače početka i kraja reda. Indeksi u nizu počinju od 0.
<div class="abc-list">
# Objasniti kako se dvostrani red može implementirati korišćenjem tehnike kružnog bafera. Navesti uslove punog i praznog reda.
# Napisati u pseudokodu implementaciju funkcija za umetanje na početak i na kraj dvostranog reda definisanog na prethodni način.
</div>

==== Rešenje ====
Uslov punog reda: (rear + 1) % size = front

Uslov praznog reda: front = rear
{{Милокод|<nowiki>
INSERT FRONT(deque, x)
if deque = NIL or (rear(deque) + 1) % size(deque) = front(deque) then
return
front(deque) = (front(deque) - 1) % size(deque)
array(deque)[front(deque)] = x
</nowiki>}}
{{Милокод|<nowiki>
INSERT REAR(deque, x)
if deque = NIL or (rear(deque) + 1) % size(deque) = front(deque) then
return
rear(deque) = (rear(deque) + 1) % size(deque)
array(deque)[rear(deque)] = x
</nowiki>}}

== Drugi kolokvijum ==
=== 1. zadatak ===
==== Postavka ====
Povezana binarna stabla
<div class="abc-list">
# Precizno definisati šta je povezano stablo i dati strukturu čvora takvog stabla, sa preciznim opisima svakog polja.
# Napisati u pseudokodu funkciju za uklanjanje čvora ''x'' iz povezanog binarnog stabla po ''inorder'' načinu obilaska, ako je poznato da čvor x nema levog sina.
</div>

==== Rešenje ====
Povezano binarno stablo je stablo u kojem su neiskorišćeni pokazivači na levu i desnu decu iskorišćeni u svrhu lakšeg obilaska stabla nekim načinom obilaska. Struktura čvora takvog stabla ima sledeća polja:
* <code>value</code> — vrednost u čvoru stabla
* <code>left</code> — pokazivač na levo dete ili prethodnika po redosledu obilaska
* <code>right</code> — pokazivač na desno dete ili sledbenika po redosledu obilaska
* <code>lf</code> — bit postavljen na 1 ukoliko <code>left</code> pokazuje na levo dete i 0 ukoliko pokazuje na prethodnika po redosledu obilaska
* <code>rf</code> — bit postavljen na 1 ukoliko <code>right</code> pokazuje na desno dete i 0 ukoliko pokazuje na sledbenika po redosledu obilaska
U pseudokodu za tačku pod b, kako bi povezano stablo ostalo povezano, potrebno je da pronađemo prethodnika čvora ''x'' po ''inorder''-u i prvog sledbenika čvora ''x'' po ''inorder''-u koji se ne nalazi u njegovom podstablu, povežemo ih a sve ostale čvorove između oslobodimo.
{{Милокод|<nowiki>
DELETE-T(x)
prethodnik = left(x)
sledbenik = right(x)
next_sledbenik = nil
while sledbenik ≠ nil do
if lf(sledbenik) = 1 then
if left(sledbenik) = x then
break
else
next_sledbenik = left(sledbenik)
while (next_sledbenik ≠ nil) and ((lf(next_sledbenik) = 1) or (left(next_sledbenik) = nil)) do
if left(next_sledbenik) = x then
break
end_if
next_sledbenik = left(next_sledbenik)
end_while
if (next_sledbenik ≠ nil) and (left(next_sledbenik) = x) then
FREENODE(sledbenik)
sledbenik = next_sledbenik
break
end_if
end_if
else
next_sledbenik = right(sledbenik)
end_if
FREENODE(sledbenik)
sledbenik = next_sledbenik
end_while
if (prethodnik ≠ nil) and (rf(prethodnik) = 0) then
right(prethodnik) = sledbenik
end_if
if sledbenik ≠ nil then
left(sledbenik) = prethodnik
lf(sledbenik) = 0
end_if
</nowiki>}}

=== 2. zadatak ===
==== Postavka ====
Neka se posmatra binarno stablo čiji čvorovi sadrže cele brojeve. Napisati u pseudokodu iterativnu implementaciju funkcije CHECK_SUM koja proverava da li sadržaj svakog čvora-oca u stablu na čiji koren ukazuje pokazivač ''root'' predstavlja zbir sadržaja svih njegovih potomaka.

==== Rešenje ====
{{Милокод|<nowiki>
CHECK SUM(root)
p = root
STACK_INIT(S)
while p ≠ nil do
PUSH(S, p)
p = left(p)
end_while
while not STACK_EMPTY(S) do
p = POP(S)
if p > 0 then
while left(p) ≠ nil do
PUSH(S, -p)
p = left(p)
end_while
if right(p) ≠ nil then
PUSH(S, right(p))
end_if
else
sum = 0
if (left(p) ≠ nil) or (right(p) ≠ nil) then
if left(p) ≠ nil then
sum = sum + value(left(p))
end_if
if right(p) ≠ nil then
sum = sum + value(right(p))
end_if
if sum * 2 ≠ value(p) then
return false
end_if
end_if
end_if
end_while
return true
</nowiki>}}

=== 3. zadatak ===
==== Postavka ====
Primenom dinamičkog Huffman algoritma kodirati poruku ABCDBBCAAABC i '''prikazati postupak''' kodiranja ukoliko su početni kodovi simbola A, B, C i D 00, 01, 10 i 11 respektivno. Uporediti prosečnu dužinu simbola primenom ovog algoritma sa inicijalno dodeljenim kodovima.

==== Rešenje ====
* Krajnje transmitovano: '''00 001 0010 10011 11 11 111 111 111 10 10 101'''
* Krajnje stablo:
12
/ \
A 8
4 / \
4 4
/ \
1 C
/ \ 3
NYT D
0 1
<div class="mw-collapsible mw-collapsed" data-expandtext="Prikaži postupak">
NYT
0
00
1
/ \
NYT A
0 1
001
2
/ \
1 A
/ \ 1
NYT B
0 1
0010
3
/ \
A 2
1 / \
1 B
/ \ 1
NYT C
0 1
10011
4
/ \
2 2
/ \ / \
1 C A B
/ \ 1 1 1
NYT D
0 1
11
5
/ \
2 3
/ \ / \
1 C A B
/ \ 1 1 2
NYT D
0 1
11
6
/ \
B 3
3 / \
A 2
1 / \
1 C
/ \ 1
NYT D
0 1
111
7
/ \
B 4
3 / \
C 2
2 / \
1 A
/ \ 1
NYT D
0 1
111
8
/ \
B 5
3 / \
C 3
2 / \
1 A
/ \ 2
NYT D
0 1
111
9
/ \
B 6
3 / \
A 3
3 / \
1 C
/ \ 2
NYT D
0 1
10
10
/ \
A 6
4 / \
B 3
3 / \
1 C
/ \ 2
NYT D
0 1
10
11
/ \
A 7
4 / \
3 B
/ \ 4
1 C
/ \ 2
NYT D
0 1
101

Kraj.
</div>

=== 4. zadatak ===
==== Postavka ====
Konverzija ''m''-arnog u binarno stablo
<div class="abc-list">
# Objasniti na koji način se vrši konverzija stabala višeg reda u odgovarajuće binarno stablo iste semantike. Koje dodatne informacije su potrebne?
# Za stablo reda 4 sa slike, prikazati postupak konverzije u odgovarajuće binarno stablo iste semantike i nacrtati finalno binarno stablo.
</div>
X
/ / \ \
Y A F C
/ | \ / / \
B G E J K M
/
D

==== Rešenje ====
''m''-arno stablo se konvertuje u binarno tako što se svaki čvor stabla pretvori tako da njegovo levo dete pokazuje na njegovo prvo dete a desno dete na sledećeg brata. Ovo se može realizovati tako što se ''postorder'' obilaskom ''m''-arnog stabla svi čvorovi konvertuju tako da im se kao levo dete nalazi prvo dete, kao desno dete levog deteta drugo dete, kao desno dete desnog deteta levog deteta treće dete itd.

<div class="mw-collapsible mw-collapsed" data-expandtext="Prikaži postupak">
''Postorder'' poredak čvorova: '''BGDEYAJFKMCX'''
* B, G, D — Nemaju decu
* E — Već je konvertovan u čvor binarnog stabla
* Y —
X
/ / \ \
Y A F C
/ / / \
B J K M
\
G
\
E
/
D
* A, J — Nemaju decu
* F — Već je konvertovan u čvor binarnog stabla
* K, M — Nemaju decu
* C —
X
/ / \ \
Y A F C
/ / /
B J K
\ \
G M
\
E
/
D
* X — Vidi konačno stablo
</div>

Konačno stablo:
X
/
Y
/ \
B A
\ \
G F
\ / \
E J C
/ /
D K
\
M

== Treći kolokvijum ==
=== 1. zadatak ===
==== Postavka ====
Potrebno je implementirati jednostavan algoritam za pomoć pri brisanju nedostižnih objekata u memoriji kao podrška nekom programskom jeziku (''garbage collection''). Neka se alocirani objekti u memoriji i njihove veze modeluju usmerenim netežinskim grafom matrične reprezentacije ''G'' sa ''n'' čvorova. Čvorovi grafa predstavljuju objekte, a grane grafa predstavljaju veze između njih, tako da grana ''(x,y)'' modelira postojanje reference u okviru objekta ''x'' na objekat ''y''.

Neka je dat niz promenljivih ''vars'' dužine ''n_vars'' koji pokazuju na objekte i počev od kojih je potrebno proveriti da li se do svih alociranih objekata u nekom programu može doći. Implementirati funkciju GC koja treba da vrati skup svih onih objekata koji su nedostižni iz perspektive početnog skupa promenljivih (''vars'').

==== Rešenje ====
Dato je generalno rešenje radi čitljivosti, rešenje u matričnoj reprezentaciji je vežba za čitaoca. Neophodna je implementacija BFS (ili bilo kog algoritma pretrage grafa preko grana) koji vraća skup posećenih čvorova. ''R'' (reachable) je skup čvorova koji su dostižni. Vraćaju se oni čvorovi koji nakon ovih pretraga nisu bili dostižni.
{{Милокод|<nowiki>
GC(G, n, vars, n_vars)
R = ∅
for each v in vars do
R = R ∪ BFS(G, v)
end_for
return G \ R
</nowiki>}}

=== 2. zadatak ===
==== Postavka ====
[[{{ns:6}}:ASP1 jul 2020 zadatak 3.2 graf.svg|thumb|Graf iz postavke drugog zadatka.]]
Jako povezane komponente
<div class="abc-list">
# Definisati jako povezane komponente i objasniti način kako se one mogu pronaći u usmerenom grafu.
# Za graf sa slike, prikazati po koracima postupak pronalaženja jako povezanih komponenti i nacrtati redukovani graf.
</div>

==== Rešenje ====
[[{{ns:6}}:ASP1 jul 2020 zadatak 3.2 rešenje.png|thumb|Transponovani graf. Jako povezane komponente su označene različitim bojama]]
[[{{ns:6}}:ASP1 jul 2020 zadatak 3.2 redukovani.png|thumb|Redukovani graf.]]
Jako povezanom komponentom nazivamo podgraf u kome je svaki čvor dostižan svim ostalim čvorovima. Algoritam za nalaženje jako povezanih komponenti možemo podeliti na 4 dela:
# Na datom grafu G radimo DFS i pamtimo završna vremena svakog čvora.
# Formiramo transponovani graf G<sup>T</sup> grafa G. Transponovani graf je graf u kome je smer svih grana obrnut.
# Na grafu G<sup>T</sup> radimo DFS počevši od čvora sa najvećim završnim vremenom. Skup posećenih čvorova koji vraća DFS čini jako povezanu komponentu tojest jedan čvor u redukovanom grafu.
# Sve čvorove koje smo posetili u 3. koraku uklanjamo iz G<sup>T</sup>, te ponavljamo 3. korak dok graf ne postane prazan.
DFS koji kreće od C:
{| class="wikitable"
|-
! Čvor !! Početno vreme !! Završno vreme
|-
| C || 1 || 20
|-
| A || 2 || 19
|-
| B || 3 || 12
|-
| F || 4 || 11
|-
| H || 5 || 10
|-
| J || 6 || 9
|-
| I || 7 || 8
|-
| E || 13 || 18
|-
| G || 14 || 17
|-
| D || 15 || 16
|}
Jako povezane komponente:
{| class="wikitable"
|-
! Čvor !! Završno vreme
|-
| C || 20
|-
! Čvor !! Završno vreme
|-
| A || 19
|-
! Čvor !! Završno vreme
|-
| E || 18
|-
| D || 16
|-
| G || 17
|-
! Čvor !! Završno vreme
|-
| B || 12
|-
| I || 8
|-
| J || 9
|-
| H || 10
|-
| F || 11
|}

=== 3. zadatak ===
==== Postavka ====
[[{{ns:6}}:ASP1 jul 2020 zadatak 3.3 graf.svg|thumb|Graf iz postavke trećeg zadatka.]]
Na slici je dat težinski neusmeren graf.
<div class="abc-list">
# Naći minimalno obuhvatno stablo primenom Primovog algoritma, ako se za početni čvor uzima čvor S. Prikazati redom koje grane se dodaju u obuhvatno stablo.
# Naći minimalno obuhvatno stablo primenom Primovog algoritma, ako se za početni čvor uzima čvor B. Prikazati redom koje grane se dodaju u obuhvatno stablo.
# Ukratko i precizno objasniti da li je prilikom traženja minimalnog obuhvatnog stabla u prethodnim tačkama moglo da se dobije i drugačije minimalno obuhvatno stablo? Ako da, napisati od čega to zavisi i navesti odovarajući korak u kome se to desilo.
</div>

==== Rešenje ====
{| class="wikitable"
|-
! Od S !! Od B
|-
| S-M 3 || B-A 3
|-
| M-K 2 || A-T 2
|-
| K-B 4 || B-K 4
|-
| B-A 3 || K-M 2
|-
| A-T 2 || M-S 3
|-
| T-F 6 || S-F 5
|}
Moguće je dobiti drugačije stablo ukoliko se desi da imamo dve grane koje su minimalne ali iste težine. Ako ne postoje dodatni kriterijumi gde bi jedna grana bila bolja od druge i pri biranju jedne grane neće doći do toga da i druga bude dodata u krajnje stablo, onda postoje dve opcije. U ovom zadatku to se dešava u 3. koraku kada krećemo od S, gde možemo birati ili K-B 4 ili M-B 4.

=== 4. zadatak ===
==== Postavka ====
Ekscentričnost čvora i središte grafa
<div class="abc-list">
# Formalno definisati i objasniti pojmove ekscentričnosti čvora i središta grafa i na koji način se oni određuju.
# Napisati u pseudokodu iterativnu implementaciju funkcije koja u grafu sa ''n'' čvorova i poznatom matricom najkraćih rastojanja ''D'' određuje ekcentričnost svih čvorova grafa. Funkcija vraća vektor koji sadrži izračunate ekscentričnosti čvorova.
# Napisati u pseudokodu iterativnu implementaciju funkcije koja u grafu sa ''n'' čvorova i poznatim ekscentričnostima čvorova u vektoru ''ecc'' određuje središte grafa.
</div>

==== Rešenje ====
''Ekscentričnost čvora'' se definiše kao maksimum od najkraćih rastojanja od svih čvorova grafa do tog čvora tj. <math> ecc(v) = max \{ d[i,v] : i \in V \} </math>.

''Središte grafa'' je čvor sa najmanjom ekscentičnošću.

{| class="wikitable"
|-
| Određivanje ekscentričnosti čvora:
{{Милокод|<nowiki>
G_ECC(D,n)
ecc = ALLOC(n)
for i = 1 to n do
ecc[1] = D[i][1]
for j = 2 to n do
if D[i][j] > ecc[i] then
ecc[i] = D[i][j]
end_if
end_for
end_for
return ecc
</nowiki>}}
|| Određivanje središta grafa:
{{Милокод|<nowiki>
G_CENTER(ecc,n)
c = 1
for i = 2 to n do
if ecc[c] > ecc[i] then
c = i
end_if
end_for
return c
</nowiki>}}
|}

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/Јул 2018

2024-09-13T00:08:24Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S111ASP1_jul_2018.pdf Zadaci]

== 1. zadatak ==
=== Postavka ===
Odrediti binarno stablo čijim eksternim čvorovima su pridružene težine: 3, 6, 3, 1, za koje je težinska eksterna dužina puta najmanja i izračunati tu dužinu.

=== Rešenje ===
13
/ \
6 7
/ \
3 4
/ \
3 1
Eksterna dužina puta: <math>1 \cdot 6 + 2 \cdot 3 + 3 \cdot 1 + 3 \cdot 3 = 6 + 6 + 3 + 9 = 24</math>

== 2. zadatak ==
=== Postavka ===
Dat je aritmetički izraz u infiksnoj notaciji: 3+7+4*(2+1). Pretvoriti dati izraz u postfiksni izraz, a zatim prikazati stanje steka po koracima tokom izračunavanja vrednosti dobijenog postfiksnog izraza. Smatrati da pokazivač vrha steka pokazuje na poslednju zauzetu lokaciju i obeležiti ga na slici.

=== Rešenje ===
Postfiksni izraz: '''3 7 + 4 2 1 + * +'''
{| class="wikitable"
! colspan="2" | 3
! colspan="2" | 7
! colspan="2" | +
! colspan="2" | 4
! colspan="2" | 2
! colspan="2" | 1
! colspan="2" | +
! colspan="2" | *
! colspan="2" | +
|-
| || -- || || -- || || -- || || -- || || -- || || -- || || -- || || -- || || --
|-
| || -- || || -- || || -- || || -- || || -- || || -- || || -- || || -- || || --
|-
| || -- || || -- || || -- || || -- || || -- || || -- || || -- || || -- || || --
|-
| || -- || || -- || || -- || || -- || || -- || → || 1 || || -- || || -- || || --
|-
| || -- || || -- || || -- || || -- || → || 2 || || 2 || → || 3 || || -- || || --
|-
| || -- || → || 7 || || -- || → || 4 || || 4 || || 4 || || 4 || → || 12 || || --
|-
| → || 3 || || 3 || → || 10 || || 10 || || 10 || || 10 || || 10 || || 10 || → || 22
|}

== 3. zadatak ==
=== Postavka ===
Posmatra se vektorska implementacija kompletnog ili skoro kompletnog stabla reda 3 u vidu vektora ''V[1:n]''.
<div class="abc-list">
# Prikazati stablo čija je vektorska reprezentacija data na slici.
# Napisati u pseudokodu funkciju koja nalazi put od čvora sa indeksom ''k'' ka korenu i funkciju koja nalazi sve sinove čvora sa indeksom ''k''.
</div>
{| class="wikitable"
|+ Slika uz deo pod a.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10 || 11 || 12 || 13
|}

=== Rešenje ===
1
/ | \
2 3 4
/ | \ / | \ / | \
5 6 7 8 9 10 11 12 13

U pseudokodu ispod pretpostavlja se da nam put od čvora ka korenu kao i deca trenutnog čvora trebaju vraćeni kao ulančane liste.
{{Милокод|<nowiki>
NODE TO ROOT(V, n, k)
t = 0
path = nil
p = k
while p ≠ 0 do
LIST_INSERT(path, v[p])
t = p mod 3
if t = 0 then
p = p / 3
else if t = 1 then
p = (p - 1) / 3
else
p = (p + 1) / 3
end_if
end_while
return path
</nowiki>}}
{{Милокод|<nowiki>
CHILD NODES(V, n, k)
children = nil
if 3 * k - 1 ≤ n then
LIST_INSERT(children, v[3 * k - 1])
end_if
if 3 * k ≤ n then
LIST_INSERT(children, v[3 * k])
end_if
if 3 * k + 1 ≤ n then
LIST_INSERT(children, v[3 * k + 1])
end_if
return children
</nowiki>}}

== 4. zadatak ==
=== Postavka ===
Neka je data opšta kvadratna matrica A[''l:u'', ''l:u''] koja sadrži elemente samo ispod glavne dijagonale, uključujući i tu dijagonalu. Formalno definisati i kratko objasniti adresnu funkciju za pristup proizvoljnom elementu A[''i'', ''j''], ukoliko se matrica linearizuje po vrstama.

=== Rešenje ===
<math>A_{ij} = A_{ll} + \left(\frac{(i-l)(i-l+1)}{2} + j - l\right) \cdot S</math>
* <math>A_{ll}</math> je adresa početnog elementa matrice.
* <math>\frac{(i-l)(i-l+1)}{2}</math> je broj elemenata u redovima iznad elementa kojeg tražimo. <math>i-l</math> je broj redova iznad trenutnog reda i stoga broj elemenata u redu iznad našeg, a pošto broj elemenata opada sa brojem reda ovaj zbir dobijamo kao Gausov zbir.
* <math>j-l</math> je broj elemenata levo od našeg trenutnog elementa.

== 5. zadatak ==
=== Postavka ===
Neka se posmatra jedan skup veb stranica u okviru lokalnog intraneta jedne kompanije. Svaka stranica sadrži određeni broj hiperlinkova koji vode ka drugim stranicama u okviru intraneta.
<div class="abc-list">
# Opisati na koji način se ovaj skup stranica može modelovati grafom. Komentarisati tip i usmerenost grafa.
# Napisati u pseudokodu iterativnu funkciju koja određuje prosečan broj klikova potreban da se sa neke veb stranice stigne do neke druge veb stranice u okviru kompanijskog intraneta. Prosek računati na nivou svih mogućih parova stranica.
</div>

=== Rešenje ===
Ovaj skup stranica se može modelovati netežinskim usmerenim grafom gde čvorovi predstavljaju stranice a grana od strane A do strane B znači da postoji veza na strani A do strane B.
{{Милокод|<nowiki>
AVG CLICKS NUM(G)
for i = 1 to n do
for i = 1 to n do
if (i, j) ∈ E then
d[i, j] = 1
else
d[i, j] = ∞
end_if
end_for
end_for
for k = 1 to n do
for i = 1 to n do
for j = 1 to n do
if d[i, k] + d[k, j] < d[i, j] then
d[i, j] = d[i, k] + d[k, j]
end_if
end_for
end_for
end_for
for i = 1 to n do
for j = 1 to n do
if i ≠ j then
sum = sum + d[i, j]
end_if
end_for
end_for
return sum / (n * (n - 1))
</nowiki>}}

== 6. zadatak ==
=== Postavka ===
[[{{ns:6}}:ASP1 jul 2018 zadatak 6 graf.svg|thumb|Graf iz postavke zadatka.]]
Primenom algoritma za određivanje kritičnih puteva u grafu odrediti kritične puteve u grafu sa slike kao i dozvoljena kašnjenja svih aktivnosti u grafu.

=== Rešenje ===
Kritični putevi: '''AEDCM''' i '''AEDVM'''.
{| class="wikitable"
! Čvor
! EST
|-
| A
| 0
|-
| B
| 6
|-
| C
| 10
|-
| D
| 5
|-
| E
| 2
|-
| K
| 6
|-
| M
| 13
|-
| V
| 11
|}
{| class="wikitable"
! Aktivnost
! I
|-
| A-B
| 3
|-
| A-E
| 0
|-
| E-D
| 0
|-
| D-B
| 1
|-
| D-C
| 0
|-
| B-C
| 1
|-
| C-M
| 0
|-
| D-V
| 0
|-
| V-M
| 0
|-
| E-V
| 2
|-
| E-K
| 2
|-
| K-V
| 2
|}

== 7. zadatak ==
=== Postavka ===
Data je dvostruko ulančana lista. Implementirati funkciju REARRANGE_LIST koja prosleđenu listu preuređuje tako da se svi elementi sa neparnih pozicija u originalnom poretku nađu pre svih elemenata sa parnih pozicija u originalnom poretku.

=== Rešenje ===
{{Милокод|<nowiki>
LIST REMOVE(node)
next(prev(node)) = next(node)
prev(next(node)) = prev(node)
return node
</nowiki>}}
{{Милокод|<nowiki>
LIST INSERT(before, node)
t = prev(before)
prev(before) = node
next(t) = node
prev(node) = t
next(node) = before
return node
</nowiki>}}
{{Милокод|<nowiki>
REARRANGE LIST(head)
if head = nil then
return
end_if
p = head
n = nil
loop
for k = 1 to i + 1 do
p = next(p)
if p = nil then
return
end_if
end_for
n = LIST_REMOVE(p)
for k = 1 to i do
p = prev(p)
end_for
LIST_INSERT(p, n)
p = n
i = i + 1
end_loop
</nowiki>}}

== 8. zadatak ==
=== Postavka ===
Prikazati postupak kodiranja poruke ADBECDAADBE primenom dinamičkog ''Huffman'' algoritma.

=== Rešenje ===
Krajnje ''Huffman''-ovo stablo:
11
/ \
5 6
/ \ / \
B 3 D A
2 / \ 3 3
1 E
/ \ 2
NYT C
0 1
Krajnja poruka: '''A 0D 00B 100E 000C 00 00 01 10 00 011'''

== 9. zadatak ==
=== Postavka ===
Posmatra se neusmeren težinski graf predstavljen matricom susednosti, čiji čvorovi predstavljaju gradove u kojima se nalaze benzinske pumpe na kojima se može dopuniti rezervoar, a težine grana predstavljaju koliko litara goriva se potroši u putu između povezanih gradova. Perica kreće iz grada src i želi da stigne u grad dst. Na efikasan način odrediti minimalni kapacitet rezervoara Peričinog automobila da bi on mogao da uspešno da završi svoj put.

=== Rešenje ===
{{Милокод|<nowiki>
GETNODE(i, j)
ALLOCATE(node)
from(node) = i
to(node) = j
next(node) = nil
return node
</nowiki>}}
{{Милокод|<nowiki>
GASOLINE TRAVEL(G, src, dst)
branches = nil
t = nil
for i = 1 to n do
for j = 1 to n do
if e[i, j] = 1 then
if branches = nil then
branches = GETNODE(i, j)
else
t = next(branches)
next(branches) = GETNODE(i, j)
next(next(branches)) = t
end_if
end_if
end_for
end_for
S = {src}
loop
t = branches
min_branch = nil
while t ≠ nil do
if (from(t) ∈ S) and (to(t) ∈ (V - S) then
if (min_branch = nil) or (w(from(t), to(t)) < w(from(min_branch), to(min_branch))) then
min_branch = t
end_if
end_if
t = next(t)
end_while
if to(min_branch) = dst then
return last_min
end_if
S = S + {to(min_branch)}
end_loop
</nowiki>}}

== 10. zadatak ==
=== Postavka ===
Prilikom obilaska nekog grafa može se dobiti '''stablo obilaska'''.
<div class="abc-list">
# Definisati ovo stablo.
# Prilikom obilaska usmerenog grafa po dubini dobijena su početna (''t1'') i završna vremena (''t2'') čvorova kao u priloženoj tabeli. Rekonstruisati stablo obilaska i precizno objasniti postupak rekonstrukcije.
</div>
{| class="wikitable"
!
! ''t1''
! ''t2''
|-
| A || 3 || 4
|-
| B || 5 || 10
|-
| C || 11 || 12
|-
| D || 14 || 15
|-
| E || 8 || 9
|-
| F || 2 || 13
|-
| G || 1 || 16
|-
| H || 6 || 7
|}

=== Rešenje ===
<div class="abc-list">
# Stablo obilaska je aciklični neusmereni netežinski graf čije grane označavaju iz kog je čvora posećen koji čvor prilikom obilaska grafa, a čvorovi su isti kao u grafu koji se obilazi.
# Postupak ide tako što udemo predom kroz brojeve <math>t = 1 ... 2n</math> i čuvamo jedan imaginarni pokazivač koji je u <math>t = 1</math> postavljam na koren. Ako <math>t</math> označava početno vreme nekog čvora, na trenutni pokazivač dodajemo dete sa vrednošću tog čvora i prebacujemo pokazivač na to dete. Ako <math>t</math> označava krajnje vreme nekog čvora, prebacujemo pokazivač na njegovog roditelja (ako je pokazivač na korenu, završavamo).
</div>
G
/ \
F D
/ | \
A B C
/ \
H E

[[Категорија:Рокови]]
[[Категорија:АСП1]]

АСП1/К3 Јул 2021

2024-09-13T00:00:05Z

KockaBot: Замена начина истицања милокода.

{{tocright}}
{{nerešeno}}
'''Jul 2021. godine''' nema postavku dostupnu sa stranice predmeta.

== 1. zadatak ==
=== Postavka ===
Posmatra se plan za realizaciju jednog softverskog projekta dat tabelom. Faza S je početna.
{| class="wikitable"
|+ Plan za realizaciju projekta
| A || S – 7 dana
|-
| B || G – 6 dana, R – 2 dana
|-
| F || L – 11 dana
|-
| L || S – 7 dana
|-
| G || L – 3 dana, A – 4 dana
|-
| M || F – 5 dana, B – 3 dana
|-
| R || A – 5 dana
|-
| T || B – 7 dana, M – 2 dana
|}

<div class="abc-list">
# '''(5p)''' Predstaviti projekat grafom.
# '''(10p)''' Ako faza B predstavlja beta fazu projekta i želimo da znamo da ni ona neće kasniti naći kritični put (ili puteve) i kritične aktivnosti za beta fazu.
# '''(10p)''' Naći kritični put (ili puteve) za uspešnu realizaciju ovog projekta kao i kritične aktivnosti.
</div>

=== Rešenje ===

== 2. zadatak ==
=== Postavka ===
Data je mreža puteva između gradova predstavljena matričnom reprezentacijom grafa. Putarina između bilo koja dva povezana grada iznosi 1. Međutim pri ulasku u svaki grad, postoji određena taksa koju je potrebno platiti. Cena takse se definiše na nivou grada.
<div class="abc-list">
# Mika voli da putuje i nalazi se u gradu X. Izračunati za svaki grad koliko je novca Miki potrebno da ga obiđe ukoliko uvek kreće iz mesta X. Implementirati funkciju koja efikasno računa minimalnu potrebnu količinu novca za posetu svakom gradu. Funkciji su prosleđeni broj gradova, graf, cene taksi za svaki grad (niz prirodnih brojeva) i indeks početnog grada.{{Милокод|<nowiki>CALC EXPENSES(N, G, taxes, X)</nowiki>}}
# Jedan od gradova je zbog nedostatka turista uveo da turisti pri ulasku ne plaćaju taksu, već da dobiju beneficiju u vidu novca. Ukratko prokomentarisati kako ova modifikacija utiče na predloženi algoritam pod a). Da li bi se u tom slučaju koristio isti algoritam ili bi bio pogodniji neki drugi (ako da, koji)?
</div>

=== Rešenje ===

== 3. zadatak ==
=== Postavka ===
[[Датотека:ASP1 jul 2021 zadatak 3.svg|1000px|frame|center|Slika iz trećeg zadatka.]]
Uparivanje neusmerenog netežinskog grafa.
<div class="abc-list">
# Predložiti i ukratko opisati način na koji se vrši pronalaženje maksimalnog uparenog skupa grafa.
# Za graf sa slike prikazati pronalaženje maksimalnog uparenog skupa po koracima.
</div>

=== Rešenje ===

== 4. zadatak ==
=== Postavka ===
Obilazak po dubini
<div class="abc-list">
# Definisati stablo obilaska.
# Definisati početno i završno vreme prilikom obilaska grafa po dubini. Koja je njegova uloga?
# Napisati u pseudokodu implementaciju funkcije koja na osnovu zapisanih početnih i završnih vremena obilaska svakog čvora obilaskom po dubini određuje da li se čvor X nalazi u podstablu čvora Y u stablu obilaska.
<syntaxhighlight lang="milo">
IS SUCCESSOR(start_time, finish_time, x, y)
</syntaxhighlight>

</div>

=== Rešenje ===

[[Категорија:Рокови]]
[[Категорија:АСП1]]

Датотека:ZP jun 2023 zadatak 9.svg

2023-09-30T23:31:04Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = PGP дијаграм из [[Заштита података/Јун 2023#9. zadatak 3|деветог задатка са јунског рока 2023. године за РТИ]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20jun%202023%20zadatak%209.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:ZP jun 2022 zadatak 9 digitalni imuni sistem.svg

2023-09-30T23:31:03Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = ''IBM''-ов дигитални имуни систем из [[Заштита података/Јун 2022#9. zadatak|деветог задатка са јунског рока 2022. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20jun%202022%20zadatak%209.drawio Изворна ''draw.io'' датотека]
}}

Датотека:ZP jul 2021 zadatak 10.svg

2023-09-30T23:31:02Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = PGP дијаграм из [[Заштита података/Јул 2021#10. zadatak|10. задатка са јулског испитног рока 2021. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20jul%202021%20zadatak%2010.drawio Изворни draw.io дијаграм]
}}

Датотека:ZP K2 2023 grupa 2 zadatak 1.svg

2023-09-30T23:31:01Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Шема из [[Заштита података/К2 2023#1. zadatak 2|првог задатка за другу групу на другом колоквијуму 2023. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20K2%202023%20grupa%202%20zadatak%201.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:ZP K 2022 zadatak 4 šema C.svg

2023-09-30T23:30:59Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Шема Ц из [[Заштита података/К 2022#4. zadatak|четвртог задатка са колоквијума за РТИ 2022. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20K%202022%20zadatak%204.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:ZP K 2022 zadatak 4 šema B.svg

2023-09-30T23:30:58Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Шема Б из [[Заштита података/К 2022#4. zadatak|четвртог задатка са колоквијума за РТИ 2022. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20K%202022%20zadatak%204.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:ZP K 2022 zadatak 4 šema A.svg

2023-09-30T23:30:57Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Шема А из [[Заштита података/К 2022#4. zadatak|четвртог задатка са колоквијума за РТИ 2022. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/ZP/ZP%20K%202022%20zadatak%204.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:VIS K1 2023 zadatak 4 grafik.svg

2023-09-30T23:30:56Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = График функције расподеле у [[Вероватноћа и статистика/К1 2023#4. задатак|шестом задатку са првог колоквијума 2023. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/VIS/jan-2023.py Скрипта за генерисање дијаграма]
}}

Датотека:URV jun 2018 zadatak 3 dijagram.svg

2023-09-30T23:30:55Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = GRAFCET дијаграм из [[Управљање у реалном времену/Питања#Jun 2018 3|трећег задатка из јунског рока 2018. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/URV/URV%20jun%202018%20zadatak%203%20dijagram.drawio Изворни ''draw.io'' дијаграм]
}}

Датотека:RM2 pitanja VPN 2.svg

2023-09-30T23:30:54Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Мрежа из [[Рачунарске мреже 2/Питања#Pitanje 28 2|питања 28. из VPN дела базе питања]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/RM2/RM2%20pitanja%20VPN.drawio Изворни draw.io дијаграм]
}}

Датотека:RM2 pitanja VPN 1.svg

2023-09-30T23:30:53Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Мрежа из [[Рачунарске мреже 2/Питања#Pitanje 26 2|питања 26. из VPN дела базе питања]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/RM2/RM2%20pitanja%20VPN.drawio Изворни draw.io дијаграм]
}}

Датотека:RM1 jun 2021 zadatak 4A.svg

2023-09-30T23:30:52Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Реконструкција [[Рачунарске мреже 1/Јун 2021#Grupa 4A|слике задатка 4А из јунског испитног рока 2021. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/RM1/RM1%20jun%202021%20zadatak%204A.drawio Изворна draw.io датотека]
}}

Датотека:PSI jun 2022 zadatak 2 dopunjeno.svg

2023-09-30T23:30:50Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Дијаграм из решења другог задатка у [[ПСИ/Јун 2022|јунском року 2022. године]].
| license = permission
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2022/rafting.mdj Изворни ''StarUML'' дијаграм]
}}

Датотека:PSI jun 2022 dijagram.svg

2023-09-30T23:30:49Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Дијаграм секвенце из решења трећег задатка на [[ПСИ/Јун 2022|јунском року 2022. године]], последња ставка.
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2022/rafting.mdj Изворни ''StarUML'' дијаграм]
}}

Датотека:PSI jun 2022 zadatak 2.svg

2023-09-30T23:30:48Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Дијаграм из поставке другог задатка у [[ПСИ/Јун 2022|јунском року 2022. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2022/rafting.mdj Изворни ''StarUML'' дијаграм]
}}

Датотека:PSI jun 2022 Django.zip

2023-09-30T23:30:47Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Целокупан практични део [[ПСИ/Јун 2022|јунског испита 2022. године]] писан у ''Django'' радном оквиру са ''Selenium IDE'' тестовима и ''StarUML'' моделом.
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2022 Репозиторијум кода]
}}

Датотека:PSI jun 2020 dijagram slučajeva korišćenja.svg

2023-09-30T23:30:46Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Дијаграм случајева коришћења из решења [[ПСИ/Јун 2020#3. задатак|прве ставке трећег задатка у јунском року 2020. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2020/model.mdj Изворни ''StarUML'' дијаграм]
}}

Датотека:PSI jun 2020 dijagram sekvence.svg

2023-09-30T23:30:45Z

KockaBot: Замена линкова до etf.kocka.tech са GitHub линковима

{{file
| description = Дијаграм секвенце из решења [[ПСИ/Јун 2020#3. задатак|прве ставке трећег задатка у јунском року 2020. године]].
| license = self
| author = [[Корисник:KockaAdmiralac|Лука Симић]]
| source = [https://github.com/KockaAdmiralac/ETF/blob/master/PSI/jun2020/model.mdj Изворни ''StarUML'' дијаграм]
}}