Racket: Heap-uri de împerechere

• Data publicării: 28.02.2025
• Data ultimei modificări: 28.02.2025 (changelog)
• Tema (o arhivă .zip cu toate fișierele .rkt folosite în etapa curentă) se va încărca pe vmchecker

Tema constă în definirea și utilizarea heap-urilor de împerechere și este împărțită în 4 etape:

• una pe care o veți rezolva după laboratorul 2 (cu deadline în ziua laboratorului 3, la ora 23:59)
• una pe care o veți rezolva după laboratorul 3 (cu deadline în ziua laboratorului 4, la ora 23:59)
• una pe care o veți rezolva după laboratorul 4 (cu deadline în ziua laboratorului 5, la ora 23:59)
• una pe care o veți rezolva după laboratorul 5 (cu deadline în ziua laboratorului 6, la ora 23:59)

Așa cum se poate observa, ziua deadline-ului variază în funcție de semigrupa în care sunteți repartizați. Restanțierii care refac tema și nu refac laboratorul beneficiază de ultimul deadline (deci vor avea deadline-uri în zilele de 14.03, 21.03, 28.03, 04.04).

Rezolvările tuturor etapelor pot fi trimise până în ziua laboratorului 6, dar orice exercițiu trimis după deadline (și până în ziua laboratorului 6) se punctează cu jumătate din punctaj. Orice exercițiu trimis după ziua laboratorului 6 nu se mai punctează deloc. Nota finală pe etapă se calculează conform formulei: n = (n1 + n2) / 2 (n1 = nota obținută înainte de deadline; n2 = nota obținută după deadline). Când toate submisiile sunt înainte de deadline, nota pe ultima submisie este și nota finală (întrucât n1 = n2).

În fiecare etapă, veți folosi ce ați învățat în săptămâna anterioară pentru a dezvolta aplicația.

Pentru fiecare etapă veți primi un schelet de cod (dar rezolvarea se bazează în mare măsură pe rezolvările anterioare). Enunțul din această pagină este menit să descrie heap-urile de împerechere (pe care le vom numi PH, conform prescurtării termenului englez “pairing heap”) și să vină cu exemple de rulare a funcțiilor mai complexe din schelet. Dacă preferați, puteți rezolva tema utilizând doar indicațiile din schelet.

În prima etapă vă veți familiariza cu structura și reprezentarea heap-urilor de împerechere (PH) în Racket, și veți implementa un max-heap de împerechere împreună cu operațiile sale uzuale.

Un PH este un heap n-ar eficient și simplu de implementat. În Racket, vom reprezenta un PH vid ca pe o listă vidă, iar un PH nevid ca pe o listă de n elemente, primul element fiind valoarea din rădăcină, iar următoarele n-1 elemente fiind PH-uri - fiii nodului rădăcină. Veți implementa următorii constructori și operatori ai acestui tip:

• empty-ph: creează un PH vid
• (val->ph val): creează un PH care este un singur nod cu valoarea val
• (ph-empty? ph): verifică dacă un PH este vid
• (ph-root ph): întoarce valoarea din rădăcină, sau false dacă nu există o asemenea valoare întrucât argumentul este un PH vid
• (ph-subtrees ph): întoarce lista fiilor rădăcinii (o listă de PH-uri), sau false dacă argumentul este un PH vid
• (merge ph1 ph2): reunește PH-urile ph1 și ph2 - în cazul unui max-PH, aceasta înseamnă că PH-ul cu rădăcina mai mică devine cel mai din stânga fiu al celui cu rădăcina mai mare, ca în figura de mai jos:
  • Un posibil apel Racket corespunzător imaginii este

    (merge '(8 (2) (5) (7 (3)))
           '(12 (6) (11 (8) (10 (4) (1) (2)))))

    • Cum 12 > 8, primul arbore devine cel mai din stânga fiu al celui de-al doilea, producând rezultatul '(12 (8 (2) (5) (7 (3))) (6) (11 (8) (10 (4) (1) (2))))
• (ph-insert val ph): inserează valoarea val în PH-ul ph - inserția este de fapt un merge între ph și un PH care conține doar valoarea val, ca în figura de mai jos:
• (list->ph lst): inserează toate valorile din lista lst, de la dreapta la stânga, într-un PH vid
  • ex: (list->ph '(2 5 8 7 3))
    • se inserează 3 în vid ⇒ '(3)
    • se inserează 7 în rezultat ⇒ '(7 (3))
    • se inserează 8 în rezultat ⇒ '(8 (7 (3)))
    • se inserează 5 în rezultat ⇒ '(8 (5) (7 (3)))
    • se inserează 2 în rezultat ⇒ '(8 (2) (5) (7 (3)))
• (two-pass-merge-LR phs): reunește toate PH-urile din lista phs, conform unui protocol în 2 pași, ca în figura de mai jos:
  • ex:

    (two-pass-merge-LR '((8 (2))   
                         (12)
                         (14 (11 (8)))   
                         (5 (4))   
                         (11 (10 (9)))))

    • se reunesc PH-urile două câte două, de la stânga la dreapta ⇒
      '(12 (8 (2)))
'(14 (5 (4)) (11 (8)))
'(11 (10 (9))) (ultima valoare rămâne ca atare, întrucât nu are cu cine să se unească)
    • se reunesc rezultatele, de la stânga la dreapta ⇒ '(14 (12 (8 (2))) (5 (4)) (11 (8))) ⇒ '(14 (11 (10 (9))) (12 (8 (2))) (5 (4)) (11 (8)))
• (two-pass-merge-RL phs): la fel, însă ambii pași se realizează de la dreapta la stânga
  • ex: (two-pass-merge-RL '((8 (2)) (12) (14 (11 (8))) (5 (4)) (11 (10 (9)))))
    • se reunesc PH-urile două câte două, de la dreapta la stânga ⇒ '(8 (2)), '(14 (12) (11 (8))), '(11 (5 (4)) (10 (9))) (prima valoare rămâne ca atare, întrucât nu are cu cine să se unească)
    • se reunesc rezultatele, de la dreapta la stânga ⇒ '(14 (11 (5 (4)) (10 (9))) (12) (11 (8))) ⇒ '(14 (8 (2)) (11 (5 (4)) (10 (9))) (12) (11 (8)))
• (tournament-merge phs): reprezintă un alt protocol de reuniune a PH-urilor din lista phs - se realizează primul pas de la two-pass-merge-LR asupra listei phs, apoi din nou asupra listei rezultate anterior, și tot așa până rămâne un singur PH
  • ex: (tournament-merge '((8 (2)) (12) (14 (11 (8))) (5 (4)) (11 (10 (9)))))
    • se reunesc PH-urile două câte două, de la stânga la dreapta ⇒ '(12 (8 (2))), '(14 (5 (4)) (11 (8))), '(11 (10 (9))) (ca la two-pass-merge-LR)
    • se reunesc rezultatele două câte două, de la stânga la dreapta ⇒ '(14 (12 (8 (2))) (5 (4)) (11 (8))), '(11 (10 (9)))
    • se reunesc rezultatele două câte două, de la stânga la dreapta ⇒ '(14 (11 (10 (9))) (12 (8 (2))) (5 (4)) (11 (8)))
• (ph-del-root ph): întoarce PH-ul obținut în urma ștergerii rădăcinii lui ph - fiii nodului șters sunt reuniți prin two-pass-merge-LR (vezi figura anterioară)

În rezolvare, veți exersa lucrul cu:

• liste și operatorii acestora (întrucât fiecare PH este reprezentat ca listă)
• funcții recursive pe stivă, respectiv pe coadă (observați tipul de recursivitate al fiecărei funcții implementate, și atenție la cazurile în care vi se solicită un anumit tip de implementare - chiar dacă obțineți punctaj pe checker, punctajul va fi anulat în cazul în care funcțiile nu sunt implementate conform cerințelor)
• operatori condiționali, operatori logici și valori boolene

Unele exerciții vă cer să folosiți un anumit tip de recursivitate. Fiecare restricție încălcată atrage după sine o depunctare de 10p.

• Scheletul fiecărei etape va conține unul sau mai multe fișiere .rkt în care trebuie să lucrați, plus fișierul checker.rkt pe care îl veți folosi doar pentru testare (rulând codul fără să îl modificați).
• Fiecare etapă (o arhivă .zip cu fișierele în care ați lucrat, plus eventualele fișiere care sunt solicitate de acestea cu “require”) se va încărca pe vmchecker. Testele de vmchecker sunt aceleași cu cele din checker.rkt.
• În fiecare etapă veți avea de implementat o serie de funcții, în sprijinul cărora vă puteți defini oricând funcții ajutătoare (dacă nu se interzice asta în mod explicit). Atunci când există restricții asupra implementării funcției din cerință, aceleași restricții trebuie respectate și de eventualele funcții ajutătoare definite de voi.
• Dacă doriți să rezolvați exerciții din etapa curentă care depind de exerciții din etapele anterioare pe care nu le-ați rezolvat, puteți semnala acest lucru responsabilului de temă, care vă va pune la dispoziție o rezolvare pentru acele exerciții astfel încât să puteți continua tema. Odată ce alegeți această variantă, renunțați la dreptul de a mai trimite cu întârziere etapa pentru care ați solicitat parțial sau integral rezolvarea. Puteți solicita rezolvări doar pentru exercițiile din etapele anterioare, nu și pentru cele din etapa curentă. Dacă implementați un exercițiu din etapa curentă pe baza unui alt exercițiu din etapa curentă pe care nu l-ați rezolvat, se va lua în calcul punctajul dat de checker, chiar dacă implementarea ar funcționa în caz că exercițiul nerezolvat ar funcționa.
• Tema este o temă de programare funcțională - pentru care folosim Racket. Racket este un limbaj multiparadigmă, care conține și elemente “ne-funcționale” (de exemplu proceduri cu efecte laterale), pe care nu este permis să le folosiți în rezolvare.
• Pentru fiecare etapă, checker-ul vă oferă un punctaj între 0 și 120 de puncte. Nota 100 corespunde punctajului maxim pe etapă, iar orice surplus se transformă într-un bonus proporțional.
• Veți prezenta tema asistentului, care poate modifica punctajul dat de checker dacă observă nereguli precum răspunsuri hardcodate, proceduri cu efecte laterale, implementări neconforme cu restricțiile din enunț.

• 28.02 (ora 20:45) - Am publicat etapa 1.

• The Pairing Heap: A New Form of Self-Adjusting Heap