Algopedia - User contributions [en]

PCP/Arbori de intervale

2025-10-26T16:07:02Z

Cata:

Arborii de intervale sînt prima structură de date pe care o vom studia dintr-o clasă mai amplă: structuri de date pe vectori care pot procesa anumite operații în timp mai bun decît $\mathcal{O}(N)$. Ocazional aceste structuri se aplică și matricilor.

Subiectele de ONI / baraj ONI / lot din anii trecuți abundă în probleme rezolvabile cu astfel de structuri:

PCP/Arbori de intervale

2025-10-26T16:02:05Z

Cata: Created page with "ABC"

ABC

Programare cu premeditare

2025-10-26T16:01:54Z

Cata:

Acesta este un curs de algoritmi și structuri de date extins cu noțiuni de inginerie software.

Publicul-țintă sînt elevii de liceu pe care îi pasionează participarea la Olimpiada de Informatică. Dacă ați ajuns în anii anteriori la etapa națională și dacă aveți ambiția să urcați un nivel și să încercați să intrați în lotul lărgit, atunci acest curs este pentru voi.

Materia pe care o acoperă acest curs se suprapune cu [https://cdn.sepi.ro/oni2024/Programa%20pentru%20olimpiada%20de%20informatica_gimnaziu%20si%20liceu.pdf Programa pentru Olimpiada națională de informatică] pentru liceu. Dar cursul este mai mult decît un talmeș-balmeș de algoritmi și structuri de date. Pentru acelea puteți găsi nenumărate alte resurse. Cursul acoperă toate noțiunile, dar insistă și pe latura practică a programării, pe scrierea de cod curat, lizibil și rezistent la buguri. Aceasta este o componentă extrem de subapreciată în supa culturală olimpică din România și -- cred eu -- principala sursă a scorurilor cu o singură cifră la concursuri.

Acest curs de programare s-a născut din [https://education.nerdvana.ro/courses/cursul-de-programare-pentru-pregatire-lot-seniori-anul-2025-2026/ cercul de programare pentru performanță] pe care îl țin la [https://nerdvana.ro/ Nerdvana] începînd cu anul 2022.

[[PCP/Arbori de intervale|Arbori de intervale]]

Programare cu premeditare

2025-10-26T16:00:44Z

Cata:

Programare cu premeditare

2025-10-26T15:42:37Z

Cata: Created page with "Acesta este un curs de algoritmi și structuri de date extins cu noțiuni de inginerie software. Publicul-țintă sînt elevii de liceu pe care îi pasionează participarea la Olimpiada de Informatică. Dacă ați ajuns în anii anteriori la etapa națională și dacă aveți ambiția să urcați un nivel și să încercați să intrați în lotul lărgit, atunci acest curs este pentru voi. Materia pe care o acoperă acest curs se suprapune cu [https://cdn.sepi.ro/oni2..."

Acesta este un curs de algoritmi și structuri de date extins cu noțiuni de inginerie software.

Publicul-țintă sînt elevii de liceu pe care îi pasionează participarea la Olimpiada de Informatică. Dacă ați ajuns în anii anteriori la etapa națională și dacă aveți ambiția să urcați un nivel și să încercați să intrați în lotul lărgit, atunci acest curs este pentru voi.

Materia pe care o acoperă acest curs se suprapune cu [https://cdn.sepi.ro/oni2024/Programa%20pentru%20olimpiada%20de%20informatica_gimnaziu%20si%20liceu.pdf Programa pentru Olimpiada națională de informatică] pentru liceu. Dar cursul este mai mult decît un talmeș-balmeș de algoritmi și structuri de date. Pentru acelea puteți găsi nenumărate alte resurse. Cursul acoperă toate noțiunile, dar insistă și pe latura practică a programării, pe scrierea de cod curat, lizibil și rezistent la buguri. Aceasta este o componentă extrem de subapreciată în supa culturală olimpică din România și -- cred eu -- principala sursă a scorurilor cu două cifre la concursuri (sau cu una singură).

Acest curs de programare s-a născut din [https://education.nerdvana.ro/courses/cursul-de-programare-pentru-pregatire-lot-seniori-anul-2025-2026/ cercul de programare pentru performanță] pe care îl țin la [https://nerdvana.ro/ Nerdvana] începînd cu anul 2022.

Clasele 9-12 lecția 8 - 5 nov 2014

2025-10-26T12:35:35Z

Cata: /* Recursivitate inutilă */

Lecția de astăzi este mai ușoară, ca să ne dea timp să ne pregătim pentru barajele pentru Șumen ([http://varena.ro/runda/barajshumenjuniori2 juniori], [http://varena.ro/runda/barajshumenseniori1 seniori]). Aceasta nu înseamnă că este mai puțin importantă! Aștept de la voi să începeți să aplicați toate lucrurile discutate aici.

= Obiceiuri de programare =

== Preliminarii ==

Sunteți cu toții pasionați de informatică și sunteți buni la algoritmică. Este fantastic, dar nu va fi suficient pe termen lung. Ușor-ușor, trebuie să începeți să vă cizelați și felul în care codați. Trebuie să vă dezvoltați capacitatea de a vă judeca o sursă după alte criterii decât strict punctajul luat la concurs. Vorbim despre criterii ca: ușurința de înțelegere a codului sau ușurința de modificare și extindere.

Noi, profesorii, avem partea noastră de vină în felul dezlânat în care programați voi. Ne batem singuri pe spate că elevii știu algoritmi, dar nu ne pasă cum îi codează. Adevărul este că cele două merg mână în mână, mai ales apropo de ceea ce am mai spus: voi nu vedeți destul cod scris de alții. Deci o lecție pe an dedicată programării este doar un început.

== Programarea aproximativă ==

Banc: cică japonezii aud de Dacia -- mașină bună, fiabilă, piese ieftine. Cumpără planurile de la Dacia și încep și ei să o producă. Doar că, surpriză, de pe linia de asamblare le iese un tractor! Trimit un om la Pitești, să studieze uzina. Se uită el, se întoarce acasă, mai repară japonezii mici probleme la linia lor. Degeaba: de pe linia de asamblare ieșeau tractoare. Disperați, dau telefon în România și cer lămuriri. Românii îi liniștesc: „păi și nouă ne iese tot tractor, dar îl luăm la pilă!”

Toate subproblemele pe care le tratăm aici sunt doar vârfuri ale icebergului. Ele reflectă o problemă mai gravă: programarea aproximativă. Prin programare aproximativă înțelegem o serie de iterații de adăugare de cod care converge către o soluție. Programul capătă formă pe măsură ce îl scriem, ca și ideea de rezolvare:

* Mai am nevoie de un element în vector? Adaug 1 la lungimea lui.
* M-ar ajuta să am datele sortate? Ce idee bună, apelez un sort().
* Trebuie să ies prematur dintr-o buclă? Deja am scris-o folosind '''for''', deci inserez un '''break'''.

Nu ciocăniți ici și colo, nu programați reactiv, în funcție de erorile din iterația anterioară. Programați activ, gândindu-vă bine la algoritm și la detaliile lui și încercați să-l implementați bine din prima. Nu fiți lăutari, fiți virtuozi.

Veți vrea să mergeți la companii faimoase. Acolo oamenii se uită, încă de la interviu, la stilul vostru de codare. Iar, dacă veți fi acceptați, vă veți poticni la fiecare code review de aceleași observații. Dacă așteptați zece ani până să încercați să vă corectați, s-ar putea să fie prea târziu. Lenevirea creierului duce la o gândire încâlcită.

== Constante ==

Folosim în general constante pentru a face codul mai solid și mai ușor de modificat.

=== Constantele sunt sublime, dar lipsesc cu desăvârșire ===

Cel mai grav este să nu folosiți deloc constante. Orice repetiție, chiar și a unui singur număr, chiar și doar o dată, este o practică riscantă. Un programator bun își ordonează codul astfel încât o modificare undeva în program să nu necesite modificări în alte părți fără legătură. Acest principiu se numește [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself (DRY)].

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
int v[100000], w[100000];

...

int max = -2000000000;

...

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define INFINITY 2000000000

int v[MAX_N], w[MAX_N];

...

int max = -INFINITY;

...
</syntaxhighlight>
|}

Scenariu catastrofic: declarați 5 vectori de mărime 1.000. Testați programul, care trece toate testele mici. Înlocuiți 1.000 cu 100.000, dar omiteți una dintre aparițiile constantei. Trimiteți problema, care ia 0 puncte.

=== #define N "vreo 100000 și 17, să fie" ===

Aproape fără excepție am observat constante declarate cu „câteva” unități mai mari decât este necesar. Dacă problema specifică N ≤ 100.000, voi declarați 100.002, 100.005, 100.007. Unii mai creativi ajung la 111.111 (ce-i drept, estetica acestui număr este incontestabilă).

De ce faceți asta? Următoarele răspunsuri nu sunt acceptate:

* Îmi este teamă că programul are o viață proprie și că decide, de capul lui, să se reverse cu câteva elemente;
* Mă gândesc că biții nu sunt bine separați și că se pot păta unii de la alții;
* Cred că pointerul care iterează prin vector frânează greu și nu se va opri la timp;
* Am de gând să folosesc vectorul de la 1, deci un element deja s-a pierdut.

Următorul răspuns este acceptat:

* Nu am încredere în aptitudinile mele de programator și în robustețea codului pe care îl produc; vectorul este accesat și modificat în câteva locuri diferite și eu nu pot să demonstrez că mă încadrez în N elemente.

Nu programați în dorul lelii. Fiți stăpâni pe program. Nimeni nu jelește 10 octeți irosiți, dar este vorba de un principiu.

În plus, la matricele multidimensionale risipa se cumulează. 1.010 octeți în loc de 1.000? 1% risipă. 1.0103 octeți în loc de 1.0003? 3% risipă.

Dacă vă plac algoritmii, veți ajunge să învățați unii tot mai complicați. Dacă nu sunteți pe deplin stăpâni nici pe aceste cărămizi de la bază, vă va fi greu să construiți peste ele.

=== Patul lui Procust pentru constante ===

Adesea aveți nevoie de vectori de lungimi ușor diferite. Poate un vector se termină cu o santinelă, sau poate altul are santinele la ambele capete. Poate altul are N ≤ 100.000 elemente și va mai câștiga alte K ≤ 1.000 elemente în viitor. De cele mai multe ori, voi definiți constanta în program pentru a acoperi toate aceste cazuri.

Nu este bine, tot din principiu. Declarați o constantă egală cu cea specificată de datele problemei, apoi ajustați fiecare vector în funcție de necesități.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
#define MAX_N 101000
int v[MAX_N], w[MAX_N], x[MAX_N], y[MAX_N];

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define MAX_K 1000

int v[MAX_N];
int w[MAX_N + 1]; // bordat cu santinelă la sfârșit
int x[MAX_N + 2]; // bordat cu santinelă la ambele capete
int y[MAX_N + MAX_K]; // Va căpăta un element la fiecare iterație
</syntaxhighlight>
|}

Codul vostru va câștiga mult în eleganță și în claritate, căci scopul fiecărei variabile va deveni mai clar. Reiese și că 1 și 2 sunt constante (numărul de santinele nu depinde de mărimea intrării), dar K poate și el să varieze dacă datele problemei se schimbă.

== Break, continue și return prematur ==

Evităm, cu rare excepții, break, continue și return prematur pentru că fac codul mai greu de citit. Se aplică și la concurs, chiar dacă voi sunteți singurii cititori.

=== „Să oprească proștii la stop” ===

La semnele de stop (octogonul roșu), legea spune că trebuie să oprești complet mașina (să stea roata). În practică, mai devreme sau mai târziu toți șoferii ne dăm seama că putem să trecem pe lângă semn fără să oprim complet. Nu cunosc pe nimeni care să respecte la sânge această lege. „Rostogolirea” prin semnul de stop reduce uzura frânelor, deci are un avantaj palpabil. Dar suntem conștienți că facem o prostioară și că nu putem face asta oricând, oriunde -- în special când de pe strada cu prioritate vin mașini. Cine încalcă această lege fără discernământ se expune la accidente, potențial catastrofice.

La fel este și cu programarea nestructurată. Scopul nu este să urmăm orbește niște legi, ci să facem codul mai ușor de înțeles și de întreținut. Prin această prismă, situațiile legitime de folosire a programării nestructurate sunt rarisime.

=== Dar programez mai ușor așa ===

Viața nu e ușoară. Cu toții ne străduim azi ca să ne fie bine mai încolo, pe termen lung.

=== Dar scriu cod mai clar așa ===

Claritatea este în ochii cititorului. Dacă vă obișnuiți să programați aproximativ, orice program neaproximativ vi se va părea straniu.

Iată un exemplu tipic: căutarea lui ''x'' în vectorul ''v''.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
for (int i = 0; i < n; i++) {
if (v[i] == x) {
break;
}
}
</syntaxhighlight>
| <syntaxhighlight>
int i = 0;
while ((i < n) && (v[i] != x)) {
i++;
}

</syntaxhighlight>
|}

Codul este mai scurt și mai citibil. Versiunea cu break promite o condiție de ieșire (i >= n), apoi ne păcălește ieșind pe o cu totul altă condiție (v[i] == x). În versiunea structurată, ambele condiții sunt listate clar în instrucțiunea ''while''.

Un alt exemplu: un test dacă șirul ''s'' este palindrom.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
bool palindrom(char *s){
for (int i = 0; 2 * i < n; i++) {
if (s[i] != s[n - 1 - i]) {
return false;
}
return true;
}
</syntaxhighlight>
| <syntaxhighlight>
bool palindrom(char *s){
int i = 0;
while ((2 * i < n) && (s[i] == s[n - 1 - i])) {
i++;
}
return (s[i] == s[n - 1 - i]);
}
</syntaxhighlight>
|}

=== Dar cum pot să scriu un switch fără break? ===

Limbajul C a apărut prin 1972, când informaticienii abia începeau să înțeleagă diferențele între programarea structurată și cea nestructurată. Demonstrația că orice program se poate scrie [http://en.wikipedia.org/wiki/Structured_program_theorem numai cu blocuri structurate] datează din 1966. În anii următori, polemica programării structurate versus cea nestructurată a polarizat lumea informaticii. [http://en.wikipedia.org/wiki/Go_To_Statement_Considered_Harmful#Criticism_and_decline Dijkstra] era pro-structurare, pe când [http://www.scribd.com/doc/38873257/Knuth-1974-Structured-Programming-With-Go-to-Statements Knuth] a dat exemple când instrucțiunea GOTO produce cod mai citibil.

Nu este, deci, de mirare, că limbajul C încorporează un atavism ca ''break''. Îl vom folosi, dar doar fiindcă nu putem altfel. Nu abuzăm de el; în special, nu permitem „curgerea” dintr-o ramură într-alta. Fiecare ramură trebuie să aibă ''break''-ul propriu.

=== Când este acceptabil să programăm nestructurat? ===

Iată câteva exemple:

* Când o funcție are de testat 2-3-4 precondiții, este mai firesc să apelăm ''return'' prematur decât să scriem corpul principal al funcției sub 2-3-4 niveluri de indentare.
* Cazul de bază în funcțiile recursive poate fi pus la început și terminat cu ''return''.
* Pentru ''switch'' folosim ''break'' căci nu putem evita asta.

În toate situațiile folosim ''return'' sau ''break'' dintr-un ''if'', niciodată dintr-o buclă.

== Un program de 10 linii poate fi [http://en.wikipedia.org/wiki/Wikipedia:Too_long;_didn't_read TLDR] ==

Ați încercat vreodată să citiți o carte tipărită la o editură de bloc? Cu margini de 1 mm, font de 8 și spațiere minusculă? Nu-i așa că e enervant?

Și programele pot fi ilizibile. Nu veți lucra toată viața de unii singuri, iar într-o echipă lizibilitatea este la fel de importantă ca eficiența. Uneori mi se pare că scopul vostru este un program cât mai scurt. De unde și până unde?

Încercați să deprindeți următoarele aspecte:

* '''O instrucțiune pe linie.''' Liniile scurte fac codul mai citibil.
* '''Spațierea.''' O linie goală este ca o virgulă. Folosiți-o acolo unde programul face trecerea între două bucăți separate logic: două funcții, două blocuri logic distincte în aceeași funcție. Nu exagerați cu spațierea. Este important ca fiecare funcție să încapă pe un singur ecran.
* '''Lungimea numelor de variabile.''' O literă este acceptabilă numai pentru scopuri încetățenite: ''i, j, k'' pentru variabilele de ciclu, ''m, n'' pentru dimensiunile matricei. Pentru orice altceva, alegeți nume mai clare (dar nici 3 cuvinte, căci ajungem la linii prea lungi).
* '''Goana stupidă după scurtimea codului.''' Două lucruri rele nu fac un lucru bun. Voi scrieți cod lung pentru că acolo converge procesul iterativ, iar pe parcurs îl scurtați mâncând acolade, spațiere și scurtând numele de variabile.
* '''Virgula în loc de acolade.''' Un caz particular al punctului anterior. Sunteți tentați să folosiți virgula ca să înghesuiți două instrucțiuni în același if, fără să adăugați acolade. Vă puteți păcăli singuri.
* '''Folosim for numai pentru număr cunoscut de iterații.''' Rezistați tentației de a deveni hackeri. Nu este o regulă unanim acceptată, dar este o idee bună. Și [http://en.wikipedia.org/wiki/For_loop Wikipedia] o menționează.
* '''Variabile cât mai locale.''' Dacă tot folosiți toate prostiile din C++, măcar folosiți și lucrurile bune. Declarați variabilele cât mai local (fără însă a împăna tot programul cu declarații). În special evitați variabilele globale pentru programe netriviale. Este ușor să pierdeți socoteala cine le modifică și când.
* '''Evitați freopen().''' Este o idee proastă să închideți '''stdin''' și în special '''stdout'''. În '''stdout''' puteți tipări mesaje de depanare pe care, dacă cumva le uitați în program, nu se întâmplă nimic rău. Dar dacă '''stdout''' și fișierul de ieșire al problemei sunt unul și același, riscați să tipăriți gunoaie în fișierul de ieșire. În plus, '''freopen()''' este o metodă foarte lipsită de considerație. Într-un program mai mare, cine știe ce bibliotecă vrea să tipărească mesaje pe ecran. Voi îi răpiți această posibilitate.

== Recursivitate inutilă ==

Nu vă fie frică să eliminați recursivitatea acolo unde ea nu este necesară. Cel mai comun exemplu este la problemele de programare dinamică, acolo unde, pe lângă valoarea soluției, se cere și soluția explicită.

Exemplu: cel mai lung subșir comun între două șiruri. Presupunând că avem două șiruri, ''a'' de lungime ''m'', și ''b'' de lungime ''n'', și că am calculat matricea ''d'' pentru toate perechile de prefixe, soluția se calculează recursiv astfel:

<syntaxhighlight lang="c" line>
char s[MAX_SOL];

void solutie(int i, int j) {
if (d[i][j]) {
if (a[i] == b[j]) {
solutie(i - 1, j - 1);
s[d[i][j] - 1] = a[i];
} else if (d[i][j - 1] > d[i - 1][j] {
solutie(d[i][j - 1]);
} else {
solutie(d[i - 1][j]);
}
}
}
...
solutie(m - 1, n - 1);
</syntaxhighlight>

Nu este rău, dar nu uitați că recursivitatea cere timp și memorie! Stiva de apeluri poate avea O(n) niveluri. Dacă spațiul sau timpul sunt o problemă, eliminați recursivitatea:

<syntaxhighlight>
char solutie[MAX_SOL];

int i = m - 1, j = n - 1;
solutie[d[i][j]] = '\0';

while (d[i][j]) {
if (a[i] == b[j]) {
solutie[d[i][j] - 1] = a[i];
i--;
j--;
} else if (d[i][j - 1] > d[i - 1][j] {
j--;
} else {
i--;
}
}
</syntaxhighlight>

Se pierde foarte puțin din claritatea codului, căci relația de recurență nu mai este susținută de apelul recursiv propriu-zis. Totuși, condițiile de recurență (din if-uri) sunt încă vizibile, iar codul necesită O(1) spațiu.

== STL este o armă cu două tăișuri ==

Această secțiune se aplică surselor scrise în afara concursurilor. La concurs, totul este permis. Totuși, nu uitați că omul folosește sculele cu care este obișnuit.

De ce venim la cerc? Pentru că vrem să învățăm algoritmi, nu doar să-i apelăm. Cu algoritmii din STL programați mai repede, dar nu învățați nimic. Sunt numeroase exemplele când trebuie să înțelegeți (și să particularizați) porțiuni dintr-un algoritm: pivotarea din quicksort, construirea automatului din KMP, operațiile pe vectori de biți.

Nu uitați că algoritmii din STL pot fi mai lenți sau mai consumatori de memorie decât cei scriși de voi. Este firesc, căci aceia sunt prea generali și adesea fac operații care nu sunt necesare pentru problema voastră. Qsort din stdlib, de exemplu, necesită aproape dublul memoriei și este mai lent. Am observat asta de mai multe ori. De exemplu, am trimis [http://varena.ro/job_detail/29271 două] [http://varena.ro/job_detail/29277 surse] la problema [http://varena.ro/problema/avioane Avioane]. A doua diferă doar prin faptul că mi-am scris propriul quicksort. Nu știu dacă și sortarea din biblioteca algorithm are această problemă.

La problema [http://varena.ro/problema/dirty Dirty], am comparat sursa mea cu a unor concurenți care făceau cam același lucru, doar că foloseau vectori STL (și iteratori) în loc de vectori C. Diferența de timp este considerabilă. Ajungeți să parsați manual fișierul de intrare ca să câștigați timp. Care mai e câștigul? Ce luați pe mere dați pe pere.

Nu uitați de ce lucrăm în C/C++, nu în PHP sau în Ruby: avem nevoie de viteză, iar C se pretează cel mai bine la asta.

=== Sortarea, înger și demon ===

Sortarea din STL merită un capitol special. Nu zic să nu o folosiți ca să câștigați 10 minute la concurs. (Dacă vă ia mai mult de 10 minute să vă implementați propria sortare, deja avem probleme mai grave). Dar dacă dați una-două fuga la sortare, riscați să pierdeți esențialul din vedere.

* Există cel puțin 5 sortări ușor de codat, fiecare cu avantajele ei (quicksort, mergesort, heapsort, radix sort, counting sort). Fiecare dintre ele are avantaje și poate fi personalizată. Luați ca exemplu problema numărării inversiunilor dintr-o permutare, dată la [http://www.math.bas.bg/keleved/shumen2013 Șumen 2013], care se rezolvă ușor cu un merge sort adaptat. Dacă vă gândiți la sortare ca la o cutie neagră, veți uita ce posibilități aveți.
* Radix sort și counting sort sunt O(n)! Dacă problema se pretează la o astfel de sortare, atunci '''sort()''' nu ajută, ci dăunează.
* Unele probleme se pot rezolva pur și simplu fără sortare. Nu vă adormiți gândirea cu stereotipuri de genul „încep cu o sortare, să fie”.

== Department of Redundancy Department ==

Evitați să copiați bucăți mari de cod cu copy-paste. Îl avem pe Victor Ponta pentru asta. Dacă aveți cazuri '''aproape''' identice, dar diferite pe alocuri, este mai bine să parametrizați codul și să-l mutați într-o funcție sau chiar într-un ''for''.

Un exemplu concret: problema [http://varena.ro/problema/avioane Avioane] cerea, pentru anumite elemente dintr-un vector, calcularea unor distanțe la stânga și la dreapta. Cu toții ați rezolvat problema pentru direcția stângă, apoi ați dublat codul și ați modificat ce era necesar ca să-l faceți să meargă și spre dreapta. Mă simt onorat că v-a plăcut problema atât de mult, încât ați rezolvat-o de două ori. :-) Iată două metode de a elimina redundanța:

# Parametrizați tot ce se modifică între direcția stângă și cea dreaptă: punctul de pornire, cel de oprire, pasul (+/- 1). Fratele meu Cristi a pus tot codul într-un for în care singurul parametru era pasul (+/- 1). Deci se poate.
# Calculați toate valorile spre stânga, apoi întoarceți vectorul pe dos și recalculați valorile tot spre stânga.

Din nou, principiul este DRY: ''Don't Repeat Yourself''. Riscați să găsiți un bug într-una din copii și să uitați să-l reparați și în cealaltă.

Bugurile de redundanță sunt greu de reparat pentru că avem de luptat și împotriva naturii noastre umane. Ni se pare că nu are sens să citim ambele blocuri, căci a doua e „la fel ca prima”. Nu vi s-a întâmplat niciodată să vă uitați 10 minute fără să vă dați seama ce e greșit în codul de mai jos?

<syntaxhighlight>
for (int i = 0; i < m; i++) {
for (int j = 0; i < n; j++) {
}
}
</syntaxhighlight>

== Dimensiunea datelor de intrare ==

Fiți întotdeauna atenți la valorile minime și maxime pe care le poate lua o variabilă. Dacă vă obișnuiți să lucrați numai cu ''int'' și cu ''long long'', veți uita că puteți face economii mari de memorie folosind short și char.

Mai mult, uneori valorile încap pe 4 biți, pe 2 sau chiar pe unul singur. Toate aceste cazuri pot fi tratate ușor cu rutine de 1-2 linii. Iată o implementare pentru baza 4 (codul complet este în [[media:two-bit.cpp]]).

<syntaxhighlight>
#define MAX_N 1000000

unsigned char b[MAX_N / 4];

int get(int i) {
return (b[i/4] >> (2 * (i % 4))) & 3;
}

void set(int i, int x) {
// Clear the previous value if needed
b[i/4] &= ~(3 << (2 * (i % 4)));
b[i/4] ^= x << (2 * (i % 4));
}
</syntaxhighlight>

Exemplu: la problema [http://varena.ro/problema/palindrom Palindrom] primeați foarte puțină memorie. Algoritmul de programare dinamică nu este dificil, dar pentru reconstituirea soluției avem nevoie de întreaga matrice, mai exact de triunghiul superior al unei matrice de dimensiuni n x n. Cum n ≤ 5.000, în aparență avem nevoie de 25 MB. În realitate, o celulă din matrice necesită un singur bit pentru stocare, deci necesarul de memorie este 5.000 x 5.000 / 2 / 8 = 1,56 MB.

== Parsarea intrării: când ai un ciocan, totul în jur pare un cui ==

Haideți să lămurim ceva: profesorii și propunătorii de probleme nu sunt sadici. Nu stau zile întregi să stoarcă fiecare picătură de eficiență dintr-o implementare, pentru ca apoi să vă ceară vouă să reușiți același lucru într-o oră. Limitele de timp sunt, în general, alese adăugând o marjă generoasă la o implementare curată, dar neoptimizată la sânge.

Dacă doriți să câștigați câteva zeci de milisecunde, aveți opțiunea să parsați intrarea. Dar amintiți-vă că sunteți pe un drum greșit și undeva ați pierdut din vedere ceva mult mai important. Nu lucrați cu ciocanul. Lucrați cu bisturiul.

Dacă totuși faceți parsarea datelor de intrare, faceți-o cu stil. Am observat codul următor (îl public anonim, dă-mi de veste dacă dorești credit).

<syntaxhighlight>
const int DIM = (1 << 12);
char buff[DIM];
int poz = 0;

void read(int &numar) {
numar = 0;
while (buff[poz] < '0' || buff[poz] > '9')
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
while ('0' <= buff[poz] && buff[poz] <= '9') {
numar = numar * 10 + buff[poz] - '0';
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
}
}
</syntaxhighlight>

Hai să-l scriem mai elegant și mai eficient de atât. I-am adus următoarele îmbunătățiri:

* (de stil) Funcția de citire a unui caracter trebuie separată. Separarea bufferării la un nivel abstract este un lucru bun. Această funcție amestecă citirea bufferată cu parsarea numărului.
* (de stil) Funcția citește în gol bufferul prima dată înainte de a citi primul bloc de pe disc. Este păcat.
* (de eficiență) Neapărat testați prezența unei cifre cu '''isdigit()''' din <ctype.h>. Codul de mai sus testează două condiții. '''isdigit()''' nu testează decât una, căci are un tabel de 256 de valori.
* (de eficiență) Declarați funcția / funcțiile inline. Compilatorul își poate da seama că este nevoie de asta, dar nu e garantat.
* (posibil de eficiență) Declarați fișierul de intrare global, ca să nu mai fie trimis ca parametru. Nu ar trebui să aibă niciun efect.

Primele patru modificări produc codul:

<syntaxhighlight>
#define BUF_SIZE 4096
char buf[BUF_SIZE];
int pos = BUF_SIZE;

inline char getChar(FILE *f) {
if (pos == BUF_SIZE) {
fread(buf, 1, BUF_SIZE, f);
pos = 0;
}
return buf[pos++];
}

inline int readInt(FILE *f) {
int result = 0;
char c;
do {
c = getChar(f);
} while (!isdigit(c));

do {
result = 10 * result + c - '0';
c = getChar(f);
} while (isdigit(c));

return result;
}
</syntaxhighlight>

Am rulat un experiment cu patru versiuni de program:

* una care citește cu fscanf
* una care citește cu codul de mai sus
* una care folosește primele patru optimizări
* una care folosește și a cincea optimizare

Fișierul de intrare are 10.000.000 de numere (79 MB). Am rulat fiecare program de zece ori, chiar pe serverul Varena, am eliminat cea mai rapidă și cea mai lentă rulare și am calculat media.

{|class="wikitable"
! versiune || timp mediu de rulare || sursă
|-
| cu fscanf || 4.31 s || [[media:parse1.cpp]]
|-
| cu codul de mai sus || 0.819 s || [[media:parse2.cpp]]
|-
| cu primele patru optimizări || 0.366 s || [[media:parse3.cpp]]
|-
| cu toate optimizările || 0.355 s || [[media:parse3.cpp]]
|}

Versiunea mai elegantă nu este mai lentă, ci chiar dimpotrivă. Pentru fișiere cu mărimi mai realiste (5-6 MB), versiunea 3 este cu circa 30 ms mai rapidă decât versiunea 2.

Nu uitați că puteți câștiga timp semnificativ, cam 50% față de versiunea cu '''fscanf(),''' folosind '''getc()''' pentru citirea caracter cu caracter. Folosim bufferul oferit de sistem. În multe situații poate fi suficient.

Morala? Să renunți la stil și să pierzi și din viteză este un compromis tare păgubos.

== O funcție este un contract ==

* Despre invarianți, cutii negre, contracte și comentarii.

Clasele 9-12 lecția 8 - 5 nov 2014

2025-10-26T12:34:52Z

Cata: /* Recursivitate inutilă */

Lecția de astăzi este mai ușoară, ca să ne dea timp să ne pregătim pentru barajele pentru Șumen ([http://varena.ro/runda/barajshumenjuniori2 juniori], [http://varena.ro/runda/barajshumenseniori1 seniori]). Aceasta nu înseamnă că este mai puțin importantă! Aștept de la voi să începeți să aplicați toate lucrurile discutate aici.

= Obiceiuri de programare =

== Preliminarii ==

Sunteți cu toții pasionați de informatică și sunteți buni la algoritmică. Este fantastic, dar nu va fi suficient pe termen lung. Ușor-ușor, trebuie să începeți să vă cizelați și felul în care codați. Trebuie să vă dezvoltați capacitatea de a vă judeca o sursă după alte criterii decât strict punctajul luat la concurs. Vorbim despre criterii ca: ușurința de înțelegere a codului sau ușurința de modificare și extindere.

Noi, profesorii, avem partea noastră de vină în felul dezlânat în care programați voi. Ne batem singuri pe spate că elevii știu algoritmi, dar nu ne pasă cum îi codează. Adevărul este că cele două merg mână în mână, mai ales apropo de ceea ce am mai spus: voi nu vedeți destul cod scris de alții. Deci o lecție pe an dedicată programării este doar un început.

== Programarea aproximativă ==

Banc: cică japonezii aud de Dacia -- mașină bună, fiabilă, piese ieftine. Cumpără planurile de la Dacia și încep și ei să o producă. Doar că, surpriză, de pe linia de asamblare le iese un tractor! Trimit un om la Pitești, să studieze uzina. Se uită el, se întoarce acasă, mai repară japonezii mici probleme la linia lor. Degeaba: de pe linia de asamblare ieșeau tractoare. Disperați, dau telefon în România și cer lămuriri. Românii îi liniștesc: „păi și nouă ne iese tot tractor, dar îl luăm la pilă!”

Toate subproblemele pe care le tratăm aici sunt doar vârfuri ale icebergului. Ele reflectă o problemă mai gravă: programarea aproximativă. Prin programare aproximativă înțelegem o serie de iterații de adăugare de cod care converge către o soluție. Programul capătă formă pe măsură ce îl scriem, ca și ideea de rezolvare:

* Mai am nevoie de un element în vector? Adaug 1 la lungimea lui.
* M-ar ajuta să am datele sortate? Ce idee bună, apelez un sort().
* Trebuie să ies prematur dintr-o buclă? Deja am scris-o folosind '''for''', deci inserez un '''break'''.

Nu ciocăniți ici și colo, nu programați reactiv, în funcție de erorile din iterația anterioară. Programați activ, gândindu-vă bine la algoritm și la detaliile lui și încercați să-l implementați bine din prima. Nu fiți lăutari, fiți virtuozi.

Veți vrea să mergeți la companii faimoase. Acolo oamenii se uită, încă de la interviu, la stilul vostru de codare. Iar, dacă veți fi acceptați, vă veți poticni la fiecare code review de aceleași observații. Dacă așteptați zece ani până să încercați să vă corectați, s-ar putea să fie prea târziu. Lenevirea creierului duce la o gândire încâlcită.

== Constante ==

Folosim în general constante pentru a face codul mai solid și mai ușor de modificat.

=== Constantele sunt sublime, dar lipsesc cu desăvârșire ===

Cel mai grav este să nu folosiți deloc constante. Orice repetiție, chiar și a unui singur număr, chiar și doar o dată, este o practică riscantă. Un programator bun își ordonează codul astfel încât o modificare undeva în program să nu necesite modificări în alte părți fără legătură. Acest principiu se numește [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself (DRY)].

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
int v[100000], w[100000];

...

int max = -2000000000;

...

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define INFINITY 2000000000

int v[MAX_N], w[MAX_N];

...

int max = -INFINITY;

...
</syntaxhighlight>
|}

Scenariu catastrofic: declarați 5 vectori de mărime 1.000. Testați programul, care trece toate testele mici. Înlocuiți 1.000 cu 100.000, dar omiteți una dintre aparițiile constantei. Trimiteți problema, care ia 0 puncte.

=== #define N "vreo 100000 și 17, să fie" ===

Aproape fără excepție am observat constante declarate cu „câteva” unități mai mari decât este necesar. Dacă problema specifică N ≤ 100.000, voi declarați 100.002, 100.005, 100.007. Unii mai creativi ajung la 111.111 (ce-i drept, estetica acestui număr este incontestabilă).

De ce faceți asta? Următoarele răspunsuri nu sunt acceptate:

* Îmi este teamă că programul are o viață proprie și că decide, de capul lui, să se reverse cu câteva elemente;
* Mă gândesc că biții nu sunt bine separați și că se pot păta unii de la alții;
* Cred că pointerul care iterează prin vector frânează greu și nu se va opri la timp;
* Am de gând să folosesc vectorul de la 1, deci un element deja s-a pierdut.

Următorul răspuns este acceptat:

* Nu am încredere în aptitudinile mele de programator și în robustețea codului pe care îl produc; vectorul este accesat și modificat în câteva locuri diferite și eu nu pot să demonstrez că mă încadrez în N elemente.

Nu programați în dorul lelii. Fiți stăpâni pe program. Nimeni nu jelește 10 octeți irosiți, dar este vorba de un principiu.

În plus, la matricele multidimensionale risipa se cumulează. 1.010 octeți în loc de 1.000? 1% risipă. 1.0103 octeți în loc de 1.0003? 3% risipă.

Dacă vă plac algoritmii, veți ajunge să învățați unii tot mai complicați. Dacă nu sunteți pe deplin stăpâni nici pe aceste cărămizi de la bază, vă va fi greu să construiți peste ele.

=== Patul lui Procust pentru constante ===

Adesea aveți nevoie de vectori de lungimi ușor diferite. Poate un vector se termină cu o santinelă, sau poate altul are santinele la ambele capete. Poate altul are N ≤ 100.000 elemente și va mai câștiga alte K ≤ 1.000 elemente în viitor. De cele mai multe ori, voi definiți constanta în program pentru a acoperi toate aceste cazuri.

Nu este bine, tot din principiu. Declarați o constantă egală cu cea specificată de datele problemei, apoi ajustați fiecare vector în funcție de necesități.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
#define MAX_N 101000
int v[MAX_N], w[MAX_N], x[MAX_N], y[MAX_N];

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define MAX_K 1000

int v[MAX_N];
int w[MAX_N + 1]; // bordat cu santinelă la sfârșit
int x[MAX_N + 2]; // bordat cu santinelă la ambele capete
int y[MAX_N + MAX_K]; // Va căpăta un element la fiecare iterație
</syntaxhighlight>
|}

Codul vostru va câștiga mult în eleganță și în claritate, căci scopul fiecărei variabile va deveni mai clar. Reiese și că 1 și 2 sunt constante (numărul de santinele nu depinde de mărimea intrării), dar K poate și el să varieze dacă datele problemei se schimbă.

== Break, continue și return prematur ==

Evităm, cu rare excepții, break, continue și return prematur pentru că fac codul mai greu de citit. Se aplică și la concurs, chiar dacă voi sunteți singurii cititori.

=== „Să oprească proștii la stop” ===

La semnele de stop (octogonul roșu), legea spune că trebuie să oprești complet mașina (să stea roata). În practică, mai devreme sau mai târziu toți șoferii ne dăm seama că putem să trecem pe lângă semn fără să oprim complet. Nu cunosc pe nimeni care să respecte la sânge această lege. „Rostogolirea” prin semnul de stop reduce uzura frânelor, deci are un avantaj palpabil. Dar suntem conștienți că facem o prostioară și că nu putem face asta oricând, oriunde -- în special când de pe strada cu prioritate vin mașini. Cine încalcă această lege fără discernământ se expune la accidente, potențial catastrofice.

La fel este și cu programarea nestructurată. Scopul nu este să urmăm orbește niște legi, ci să facem codul mai ușor de înțeles și de întreținut. Prin această prismă, situațiile legitime de folosire a programării nestructurate sunt rarisime.

=== Dar programez mai ușor așa ===

Viața nu e ușoară. Cu toții ne străduim azi ca să ne fie bine mai încolo, pe termen lung.

=== Dar scriu cod mai clar așa ===

Claritatea este în ochii cititorului. Dacă vă obișnuiți să programați aproximativ, orice program neaproximativ vi se va părea straniu.

Iată un exemplu tipic: căutarea lui ''x'' în vectorul ''v''.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
for (int i = 0; i < n; i++) {
if (v[i] == x) {
break;
}
}
</syntaxhighlight>
| <syntaxhighlight>
int i = 0;
while ((i < n) && (v[i] != x)) {
i++;
}

</syntaxhighlight>
|}

Codul este mai scurt și mai citibil. Versiunea cu break promite o condiție de ieșire (i >= n), apoi ne păcălește ieșind pe o cu totul altă condiție (v[i] == x). În versiunea structurată, ambele condiții sunt listate clar în instrucțiunea ''while''.

Un alt exemplu: un test dacă șirul ''s'' este palindrom.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
bool palindrom(char *s){
for (int i = 0; 2 * i < n; i++) {
if (s[i] != s[n - 1 - i]) {
return false;
}
return true;
}
</syntaxhighlight>
| <syntaxhighlight>
bool palindrom(char *s){
int i = 0;
while ((2 * i < n) && (s[i] == s[n - 1 - i])) {
i++;
}
return (s[i] == s[n - 1 - i]);
}
</syntaxhighlight>
|}

=== Dar cum pot să scriu un switch fără break? ===

Limbajul C a apărut prin 1972, când informaticienii abia începeau să înțeleagă diferențele între programarea structurată și cea nestructurată. Demonstrația că orice program se poate scrie [http://en.wikipedia.org/wiki/Structured_program_theorem numai cu blocuri structurate] datează din 1966. În anii următori, polemica programării structurate versus cea nestructurată a polarizat lumea informaticii. [http://en.wikipedia.org/wiki/Go_To_Statement_Considered_Harmful#Criticism_and_decline Dijkstra] era pro-structurare, pe când [http://www.scribd.com/doc/38873257/Knuth-1974-Structured-Programming-With-Go-to-Statements Knuth] a dat exemple când instrucțiunea GOTO produce cod mai citibil.

Nu este, deci, de mirare, că limbajul C încorporează un atavism ca ''break''. Îl vom folosi, dar doar fiindcă nu putem altfel. Nu abuzăm de el; în special, nu permitem „curgerea” dintr-o ramură într-alta. Fiecare ramură trebuie să aibă ''break''-ul propriu.

=== Când este acceptabil să programăm nestructurat? ===

Iată câteva exemple:

* Când o funcție are de testat 2-3-4 precondiții, este mai firesc să apelăm ''return'' prematur decât să scriem corpul principal al funcției sub 2-3-4 niveluri de indentare.
* Cazul de bază în funcțiile recursive poate fi pus la început și terminat cu ''return''.
* Pentru ''switch'' folosim ''break'' căci nu putem evita asta.

În toate situațiile folosim ''return'' sau ''break'' dintr-un ''if'', niciodată dintr-o buclă.

== Un program de 10 linii poate fi [http://en.wikipedia.org/wiki/Wikipedia:Too_long;_didn't_read TLDR] ==

Ați încercat vreodată să citiți o carte tipărită la o editură de bloc? Cu margini de 1 mm, font de 8 și spațiere minusculă? Nu-i așa că e enervant?

Și programele pot fi ilizibile. Nu veți lucra toată viața de unii singuri, iar într-o echipă lizibilitatea este la fel de importantă ca eficiența. Uneori mi se pare că scopul vostru este un program cât mai scurt. De unde și până unde?

Încercați să deprindeți următoarele aspecte:

* '''O instrucțiune pe linie.''' Liniile scurte fac codul mai citibil.
* '''Spațierea.''' O linie goală este ca o virgulă. Folosiți-o acolo unde programul face trecerea între două bucăți separate logic: două funcții, două blocuri logic distincte în aceeași funcție. Nu exagerați cu spațierea. Este important ca fiecare funcție să încapă pe un singur ecran.
* '''Lungimea numelor de variabile.''' O literă este acceptabilă numai pentru scopuri încetățenite: ''i, j, k'' pentru variabilele de ciclu, ''m, n'' pentru dimensiunile matricei. Pentru orice altceva, alegeți nume mai clare (dar nici 3 cuvinte, căci ajungem la linii prea lungi).
* '''Goana stupidă după scurtimea codului.''' Două lucruri rele nu fac un lucru bun. Voi scrieți cod lung pentru că acolo converge procesul iterativ, iar pe parcurs îl scurtați mâncând acolade, spațiere și scurtând numele de variabile.
* '''Virgula în loc de acolade.''' Un caz particular al punctului anterior. Sunteți tentați să folosiți virgula ca să înghesuiți două instrucțiuni în același if, fără să adăugați acolade. Vă puteți păcăli singuri.
* '''Folosim for numai pentru număr cunoscut de iterații.''' Rezistați tentației de a deveni hackeri. Nu este o regulă unanim acceptată, dar este o idee bună. Și [http://en.wikipedia.org/wiki/For_loop Wikipedia] o menționează.
* '''Variabile cât mai locale.''' Dacă tot folosiți toate prostiile din C++, măcar folosiți și lucrurile bune. Declarați variabilele cât mai local (fără însă a împăna tot programul cu declarații). În special evitați variabilele globale pentru programe netriviale. Este ușor să pierdeți socoteala cine le modifică și când.
* '''Evitați freopen().''' Este o idee proastă să închideți '''stdin''' și în special '''stdout'''. În '''stdout''' puteți tipări mesaje de depanare pe care, dacă cumva le uitați în program, nu se întâmplă nimic rău. Dar dacă '''stdout''' și fișierul de ieșire al problemei sunt unul și același, riscați să tipăriți gunoaie în fișierul de ieșire. În plus, '''freopen()''' este o metodă foarte lipsită de considerație. Într-un program mai mare, cine știe ce bibliotecă vrea să tipărească mesaje pe ecran. Voi îi răpiți această posibilitate.

== Recursivitate inutilă ==

Nu vă fie frică să eliminați recursivitatea acolo unde ea nu este necesară. Cel mai comun exemplu este la problemele de programare dinamică, acolo unde, pe lângă valoarea soluției, se cere și soluția explicită.

Exemplu: cel mai lung subșir comun între două șiruri. Presupunând că avem două șiruri, ''a'' de lungime ''m'', și ''b'' de lungime ''n'', și că am calculat matricea ''d'' pentru toate perechile de prefixe, soluția se calculează recursiv astfel:

<syntaxhighlight lang="c">
char s[MAX_SOL];

void solutie(int i, int j) {
if (d[i][j]) {
if (a[i] == b[j]) {
solutie(i - 1, j - 1);
s[d[i][j] - 1] = a[i];
} else if (d[i][j - 1] > d[i - 1][j] {
solutie(d[i][j - 1]);
} else {
solutie(d[i - 1][j]);
}
}
}
...
solutie(m - 1, n - 1);
</syntaxhighlight>

Nu este rău, dar nu uitați că recursivitatea cere timp și memorie! Stiva de apeluri poate avea O(n) niveluri. Dacă spațiul sau timpul sunt o problemă, eliminați recursivitatea:

<syntaxhighlight>
char solutie[MAX_SOL];

int i = m - 1, j = n - 1;
solutie[d[i][j]] = '\0';

while (d[i][j]) {
if (a[i] == b[j]) {
solutie[d[i][j] - 1] = a[i];
i--;
j--;
} else if (d[i][j - 1] > d[i - 1][j] {
j--;
} else {
i--;
}
}
</syntaxhighlight>

Se pierde foarte puțin din claritatea codului, căci relația de recurență nu mai este susținută de apelul recursiv propriu-zis. Totuși, condițiile de recurență (din if-uri) sunt încă vizibile, iar codul necesită O(1) spațiu.

== STL este o armă cu două tăișuri ==

Această secțiune se aplică surselor scrise în afara concursurilor. La concurs, totul este permis. Totuși, nu uitați că omul folosește sculele cu care este obișnuit.

De ce venim la cerc? Pentru că vrem să învățăm algoritmi, nu doar să-i apelăm. Cu algoritmii din STL programați mai repede, dar nu învățați nimic. Sunt numeroase exemplele când trebuie să înțelegeți (și să particularizați) porțiuni dintr-un algoritm: pivotarea din quicksort, construirea automatului din KMP, operațiile pe vectori de biți.

Nu uitați că algoritmii din STL pot fi mai lenți sau mai consumatori de memorie decât cei scriși de voi. Este firesc, căci aceia sunt prea generali și adesea fac operații care nu sunt necesare pentru problema voastră. Qsort din stdlib, de exemplu, necesită aproape dublul memoriei și este mai lent. Am observat asta de mai multe ori. De exemplu, am trimis [http://varena.ro/job_detail/29271 două] [http://varena.ro/job_detail/29277 surse] la problema [http://varena.ro/problema/avioane Avioane]. A doua diferă doar prin faptul că mi-am scris propriul quicksort. Nu știu dacă și sortarea din biblioteca algorithm are această problemă.

La problema [http://varena.ro/problema/dirty Dirty], am comparat sursa mea cu a unor concurenți care făceau cam același lucru, doar că foloseau vectori STL (și iteratori) în loc de vectori C. Diferența de timp este considerabilă. Ajungeți să parsați manual fișierul de intrare ca să câștigați timp. Care mai e câștigul? Ce luați pe mere dați pe pere.

Nu uitați de ce lucrăm în C/C++, nu în PHP sau în Ruby: avem nevoie de viteză, iar C se pretează cel mai bine la asta.

=== Sortarea, înger și demon ===

Sortarea din STL merită un capitol special. Nu zic să nu o folosiți ca să câștigați 10 minute la concurs. (Dacă vă ia mai mult de 10 minute să vă implementați propria sortare, deja avem probleme mai grave). Dar dacă dați una-două fuga la sortare, riscați să pierdeți esențialul din vedere.

* Există cel puțin 5 sortări ușor de codat, fiecare cu avantajele ei (quicksort, mergesort, heapsort, radix sort, counting sort). Fiecare dintre ele are avantaje și poate fi personalizată. Luați ca exemplu problema numărării inversiunilor dintr-o permutare, dată la [http://www.math.bas.bg/keleved/shumen2013 Șumen 2013], care se rezolvă ușor cu un merge sort adaptat. Dacă vă gândiți la sortare ca la o cutie neagră, veți uita ce posibilități aveți.
* Radix sort și counting sort sunt O(n)! Dacă problema se pretează la o astfel de sortare, atunci '''sort()''' nu ajută, ci dăunează.
* Unele probleme se pot rezolva pur și simplu fără sortare. Nu vă adormiți gândirea cu stereotipuri de genul „încep cu o sortare, să fie”.

== Department of Redundancy Department ==

Evitați să copiați bucăți mari de cod cu copy-paste. Îl avem pe Victor Ponta pentru asta. Dacă aveți cazuri '''aproape''' identice, dar diferite pe alocuri, este mai bine să parametrizați codul și să-l mutați într-o funcție sau chiar într-un ''for''.

Un exemplu concret: problema [http://varena.ro/problema/avioane Avioane] cerea, pentru anumite elemente dintr-un vector, calcularea unor distanțe la stânga și la dreapta. Cu toții ați rezolvat problema pentru direcția stângă, apoi ați dublat codul și ați modificat ce era necesar ca să-l faceți să meargă și spre dreapta. Mă simt onorat că v-a plăcut problema atât de mult, încât ați rezolvat-o de două ori. :-) Iată două metode de a elimina redundanța:

# Parametrizați tot ce se modifică între direcția stângă și cea dreaptă: punctul de pornire, cel de oprire, pasul (+/- 1). Fratele meu Cristi a pus tot codul într-un for în care singurul parametru era pasul (+/- 1). Deci se poate.
# Calculați toate valorile spre stânga, apoi întoarceți vectorul pe dos și recalculați valorile tot spre stânga.

Din nou, principiul este DRY: ''Don't Repeat Yourself''. Riscați să găsiți un bug într-una din copii și să uitați să-l reparați și în cealaltă.

Bugurile de redundanță sunt greu de reparat pentru că avem de luptat și împotriva naturii noastre umane. Ni se pare că nu are sens să citim ambele blocuri, căci a doua e „la fel ca prima”. Nu vi s-a întâmplat niciodată să vă uitați 10 minute fără să vă dați seama ce e greșit în codul de mai jos?

<syntaxhighlight>
for (int i = 0; i < m; i++) {
for (int j = 0; i < n; j++) {
}
}
</syntaxhighlight>

== Dimensiunea datelor de intrare ==

Fiți întotdeauna atenți la valorile minime și maxime pe care le poate lua o variabilă. Dacă vă obișnuiți să lucrați numai cu ''int'' și cu ''long long'', veți uita că puteți face economii mari de memorie folosind short și char.

Mai mult, uneori valorile încap pe 4 biți, pe 2 sau chiar pe unul singur. Toate aceste cazuri pot fi tratate ușor cu rutine de 1-2 linii. Iată o implementare pentru baza 4 (codul complet este în [[media:two-bit.cpp]]).

<syntaxhighlight>
#define MAX_N 1000000

unsigned char b[MAX_N / 4];

int get(int i) {
return (b[i/4] >> (2 * (i % 4))) & 3;
}

void set(int i, int x) {
// Clear the previous value if needed
b[i/4] &= ~(3 << (2 * (i % 4)));
b[i/4] ^= x << (2 * (i % 4));
}
</syntaxhighlight>

Exemplu: la problema [http://varena.ro/problema/palindrom Palindrom] primeați foarte puțină memorie. Algoritmul de programare dinamică nu este dificil, dar pentru reconstituirea soluției avem nevoie de întreaga matrice, mai exact de triunghiul superior al unei matrice de dimensiuni n x n. Cum n ≤ 5.000, în aparență avem nevoie de 25 MB. În realitate, o celulă din matrice necesită un singur bit pentru stocare, deci necesarul de memorie este 5.000 x 5.000 / 2 / 8 = 1,56 MB.

== Parsarea intrării: când ai un ciocan, totul în jur pare un cui ==

Haideți să lămurim ceva: profesorii și propunătorii de probleme nu sunt sadici. Nu stau zile întregi să stoarcă fiecare picătură de eficiență dintr-o implementare, pentru ca apoi să vă ceară vouă să reușiți același lucru într-o oră. Limitele de timp sunt, în general, alese adăugând o marjă generoasă la o implementare curată, dar neoptimizată la sânge.

Dacă doriți să câștigați câteva zeci de milisecunde, aveți opțiunea să parsați intrarea. Dar amintiți-vă că sunteți pe un drum greșit și undeva ați pierdut din vedere ceva mult mai important. Nu lucrați cu ciocanul. Lucrați cu bisturiul.

Dacă totuși faceți parsarea datelor de intrare, faceți-o cu stil. Am observat codul următor (îl public anonim, dă-mi de veste dacă dorești credit).

<syntaxhighlight>
const int DIM = (1 << 12);
char buff[DIM];
int poz = 0;

void read(int &numar) {
numar = 0;
while (buff[poz] < '0' || buff[poz] > '9')
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
while ('0' <= buff[poz] && buff[poz] <= '9') {
numar = numar * 10 + buff[poz] - '0';
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
}
}
</syntaxhighlight>

Hai să-l scriem mai elegant și mai eficient de atât. I-am adus următoarele îmbunătățiri:

* (de stil) Funcția de citire a unui caracter trebuie separată. Separarea bufferării la un nivel abstract este un lucru bun. Această funcție amestecă citirea bufferată cu parsarea numărului.
* (de stil) Funcția citește în gol bufferul prima dată înainte de a citi primul bloc de pe disc. Este păcat.
* (de eficiență) Neapărat testați prezența unei cifre cu '''isdigit()''' din <ctype.h>. Codul de mai sus testează două condiții. '''isdigit()''' nu testează decât una, căci are un tabel de 256 de valori.
* (de eficiență) Declarați funcția / funcțiile inline. Compilatorul își poate da seama că este nevoie de asta, dar nu e garantat.
* (posibil de eficiență) Declarați fișierul de intrare global, ca să nu mai fie trimis ca parametru. Nu ar trebui să aibă niciun efect.

Primele patru modificări produc codul:

<syntaxhighlight>
#define BUF_SIZE 4096
char buf[BUF_SIZE];
int pos = BUF_SIZE;

inline char getChar(FILE *f) {
if (pos == BUF_SIZE) {
fread(buf, 1, BUF_SIZE, f);
pos = 0;
}
return buf[pos++];
}

inline int readInt(FILE *f) {
int result = 0;
char c;
do {
c = getChar(f);
} while (!isdigit(c));

do {
result = 10 * result + c - '0';
c = getChar(f);
} while (isdigit(c));

return result;
}
</syntaxhighlight>

Am rulat un experiment cu patru versiuni de program:

* una care citește cu fscanf
* una care citește cu codul de mai sus
* una care folosește primele patru optimizări
* una care folosește și a cincea optimizare

Fișierul de intrare are 10.000.000 de numere (79 MB). Am rulat fiecare program de zece ori, chiar pe serverul Varena, am eliminat cea mai rapidă și cea mai lentă rulare și am calculat media.

{|class="wikitable"
! versiune || timp mediu de rulare || sursă
|-
| cu fscanf || 4.31 s || [[media:parse1.cpp]]
|-
| cu codul de mai sus || 0.819 s || [[media:parse2.cpp]]
|-
| cu primele patru optimizări || 0.366 s || [[media:parse3.cpp]]
|-
| cu toate optimizările || 0.355 s || [[media:parse3.cpp]]
|}

Versiunea mai elegantă nu este mai lentă, ci chiar dimpotrivă. Pentru fișiere cu mărimi mai realiste (5-6 MB), versiunea 3 este cu circa 30 ms mai rapidă decât versiunea 2.

Nu uitați că puteți câștiga timp semnificativ, cam 50% față de versiunea cu '''fscanf(),''' folosind '''getc()''' pentru citirea caracter cu caracter. Folosim bufferul oferit de sistem. În multe situații poate fi suficient.

Morala? Să renunți la stil și să pierzi și din viteză este un compromis tare păgubos.

== O funcție este un contract ==

* Despre invarianți, cutii negre, contracte și comentarii.

Clasele 9-12 lecția 8 - 5 nov 2014

2023-09-11T06:24:51Z

Cata:

Lecția de astăzi este mai ușoară, ca să ne dea timp să ne pregătim pentru barajele pentru Șumen ([http://varena.ro/runda/barajshumenjuniori2 juniori], [http://varena.ro/runda/barajshumenseniori1 seniori]). Aceasta nu înseamnă că este mai puțin importantă! Aștept de la voi să începeți să aplicați toate lucrurile discutate aici.

= Obiceiuri de programare =

== Preliminarii ==

Sunteți cu toții pasionați de informatică și sunteți buni la algoritmică. Este fantastic, dar nu va fi suficient pe termen lung. Ușor-ușor, trebuie să începeți să vă cizelați și felul în care codați. Trebuie să vă dezvoltați capacitatea de a vă judeca o sursă după alte criterii decât strict punctajul luat la concurs. Vorbim despre criterii ca: ușurința de înțelegere a codului sau ușurința de modificare și extindere.

Noi, profesorii, avem partea noastră de vină în felul dezlânat în care programați voi. Ne batem singuri pe spate că elevii știu algoritmi, dar nu ne pasă cum îi codează. Adevărul este că cele două merg mână în mână, mai ales apropo de ceea ce am mai spus: voi nu vedeți destul cod scris de alții. Deci o lecție pe an dedicată programării este doar un început.

== Programarea aproximativă ==

Banc: cică japonezii aud de Dacia -- mașină bună, fiabilă, piese ieftine. Cumpără planurile de la Dacia și încep și ei să o producă. Doar că, surpriză, de pe linia de asamblare le iese un tractor! Trimit un om la Pitești, să studieze uzina. Se uită el, se întoarce acasă, mai repară japonezii mici probleme la linia lor. Degeaba: de pe linia de asamblare ieșeau tractoare. Disperați, dau telefon în România și cer lămuriri. Românii îi liniștesc: „păi și nouă ne iese tot tractor, dar îl luăm la pilă!”

Toate subproblemele pe care le tratăm aici sunt doar vârfuri ale icebergului. Ele reflectă o problemă mai gravă: programarea aproximativă. Prin programare aproximativă înțelegem o serie de iterații de adăugare de cod care converge către o soluție. Programul capătă formă pe măsură ce îl scriem, ca și ideea de rezolvare:

* Mai am nevoie de un element în vector? Adaug 1 la lungimea lui.
* M-ar ajuta să am datele sortate? Ce idee bună, apelez un sort().
* Trebuie să ies prematur dintr-o buclă? Deja am scris-o folosind '''for''', deci inserez un '''break'''.

Nu ciocăniți ici și colo, nu programați reactiv, în funcție de erorile din iterația anterioară. Programați activ, gândindu-vă bine la algoritm și la detaliile lui și încercați să-l implementați bine din prima. Nu fiți lăutari, fiți virtuozi.

Veți vrea să mergeți la companii faimoase. Acolo oamenii se uită, încă de la interviu, la stilul vostru de codare. Iar, dacă veți fi acceptați, vă veți poticni la fiecare code review de aceleași observații. Dacă așteptați zece ani până să încercați să vă corectați, s-ar putea să fie prea târziu. Lenevirea creierului duce la o gândire încâlcită.

== Constante ==

Folosim în general constante pentru a face codul mai solid și mai ușor de modificat.

=== Constantele sunt sublime, dar lipsesc cu desăvârșire ===

Cel mai grav este să nu folosiți deloc constante. Orice repetiție, chiar și a unui singur număr, chiar și doar o dată, este o practică riscantă. Un programator bun își ordonează codul astfel încât o modificare undeva în program să nu necesite modificări în alte părți fără legătură. Acest principiu se numește [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself (DRY)].

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
int v[100000], w[100000];

...

int max = -2000000000;

...

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define INFINITY 2000000000

int v[MAX_N], w[MAX_N];

...

int max = -INFINITY;

...
</syntaxhighlight>
|}

Scenariu catastrofic: declarați 5 vectori de mărime 1.000. Testați programul, care trece toate testele mici. Înlocuiți 1.000 cu 100.000, dar omiteți una dintre aparițiile constantei. Trimiteți problema, care ia 0 puncte.

=== #define N "vreo 100000 și 17, să fie" ===

Aproape fără excepție am observat constante declarate cu „câteva” unități mai mari decât este necesar. Dacă problema specifică N ≤ 100.000, voi declarați 100.002, 100.005, 100.007. Unii mai creativi ajung la 111.111 (ce-i drept, estetica acestui număr este incontestabilă).

De ce faceți asta? Următoarele răspunsuri nu sunt acceptate:

* Îmi este teamă că programul are o viață proprie și că decide, de capul lui, să se reverse cu câteva elemente;
* Mă gândesc că biții nu sunt bine separați și că se pot păta unii de la alții;
* Cred că pointerul care iterează prin vector frânează greu și nu se va opri la timp;
* Am de gând să folosesc vectorul de la 1, deci un element deja s-a pierdut.

Următorul răspuns este acceptat:

* Nu am încredere în aptitudinile mele de programator și în robustețea codului pe care îl produc; vectorul este accesat și modificat în câteva locuri diferite și eu nu pot să demonstrez că mă încadrez în N elemente.

Nu programați în dorul lelii. Fiți stăpâni pe program. Nimeni nu jelește 10 octeți irosiți, dar este vorba de un principiu.

În plus, la matricele multidimensionale risipa se cumulează. 1.010 octeți în loc de 1.000? 1% risipă. 1.0103 octeți în loc de 1.0003? 3% risipă.

Dacă vă plac algoritmii, veți ajunge să învățați unii tot mai complicați. Dacă nu sunteți pe deplin stăpâni nici pe aceste cărămizi de la bază, vă va fi greu să construiți peste ele.

=== Patul lui Procust pentru constante ===

Adesea aveți nevoie de vectori de lungimi ușor diferite. Poate un vector se termină cu o santinelă, sau poate altul are santinele la ambele capete. Poate altul are N ≤ 100.000 elemente și va mai câștiga alte K ≤ 1.000 elemente în viitor. De cele mai multe ori, voi definiți constanta în program pentru a acoperi toate aceste cazuri.

Nu este bine, tot din principiu. Declarați o constantă egală cu cea specificată de datele problemei, apoi ajustați fiecare vector în funcție de necesități.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
#define MAX_N 101000
int v[MAX_N], w[MAX_N], x[MAX_N], y[MAX_N];

</syntaxhighlight>
| <syntaxhighlight>
#define MAX_N 100000
#define MAX_K 1000

int v[MAX_N];
int w[MAX_N + 1]; // bordat cu santinelă la sfârșit
int x[MAX_N + 2]; // bordat cu santinelă la ambele capete
int y[MAX_N + MAX_K]; // Va căpăta un element la fiecare iterație
</syntaxhighlight>
|}

Codul vostru va câștiga mult în eleganță și în claritate, căci scopul fiecărei variabile va deveni mai clar. Reiese și că 1 și 2 sunt constante (numărul de santinele nu depinde de mărimea intrării), dar K poate și el să varieze dacă datele problemei se schimbă.

== Break, continue și return prematur ==

Evităm, cu rare excepții, break, continue și return prematur pentru că fac codul mai greu de citit. Se aplică și la concurs, chiar dacă voi sunteți singurii cititori.

=== „Să oprească proștii la stop” ===

La semnele de stop (octogonul roșu), legea spune că trebuie să oprești complet mașina (să stea roata). În practică, mai devreme sau mai târziu toți șoferii ne dăm seama că putem să trecem pe lângă semn fără să oprim complet. Nu cunosc pe nimeni care să respecte la sânge această lege. „Rostogolirea” prin semnul de stop reduce uzura frânelor, deci are un avantaj palpabil. Dar suntem conștienți că facem o prostioară și că nu putem face asta oricând, oriunde -- în special când de pe strada cu prioritate vin mașini. Cine încalcă această lege fără discernământ se expune la accidente, potențial catastrofice.

La fel este și cu programarea nestructurată. Scopul nu este să urmăm orbește niște legi, ci să facem codul mai ușor de înțeles și de întreținut. Prin această prismă, situațiile legitime de folosire a programării nestructurate sunt rarisime.

=== Dar programez mai ușor așa ===

Viața nu e ușoară. Cu toții ne străduim azi ca să ne fie bine mai încolo, pe termen lung.

=== Dar scriu cod mai clar așa ===

Claritatea este în ochii cititorului. Dacă vă obișnuiți să programați aproximativ, orice program neaproximativ vi se va părea straniu.

Iată un exemplu tipic: căutarea lui ''x'' în vectorul ''v''.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
for (int i = 0; i < n; i++) {
if (v[i] == x) {
break;
}
}
</syntaxhighlight>
| <syntaxhighlight>
int i = 0;
while ((i < n) && (v[i] != x)) {
i++;
}

</syntaxhighlight>
|}

Codul este mai scurt și mai citibil. Versiunea cu break promite o condiție de ieșire (i >= n), apoi ne păcălește ieșind pe o cu totul altă condiție (v[i] == x). În versiunea structurată, ambele condiții sunt listate clar în instrucțiunea ''while''.

Un alt exemplu: un test dacă șirul ''s'' este palindrom.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight>
bool palindrom(char *s){
for (int i = 0; 2 * i < n; i++) {
if (s[i] != s[n - 1 - i]) {
return false;
}
return true;
}
</syntaxhighlight>
| <syntaxhighlight>
bool palindrom(char *s){
int i = 0;
while ((2 * i < n) && (s[i] == s[n - 1 - i])) {
i++;
}
return (s[i] == s[n - 1 - i]);
}
</syntaxhighlight>
|}

=== Dar cum pot să scriu un switch fără break? ===

Limbajul C a apărut prin 1972, când informaticienii abia începeau să înțeleagă diferențele între programarea structurată și cea nestructurată. Demonstrația că orice program se poate scrie [http://en.wikipedia.org/wiki/Structured_program_theorem numai cu blocuri structurate] datează din 1966. În anii următori, polemica programării structurate versus cea nestructurată a polarizat lumea informaticii. [http://en.wikipedia.org/wiki/Go_To_Statement_Considered_Harmful#Criticism_and_decline Dijkstra] era pro-structurare, pe când [http://www.scribd.com/doc/38873257/Knuth-1974-Structured-Programming-With-Go-to-Statements Knuth] a dat exemple când instrucțiunea GOTO produce cod mai citibil.

Nu este, deci, de mirare, că limbajul C încorporează un atavism ca ''break''. Îl vom folosi, dar doar fiindcă nu putem altfel. Nu abuzăm de el; în special, nu permitem „curgerea” dintr-o ramură într-alta. Fiecare ramură trebuie să aibă ''break''-ul propriu.

=== Când este acceptabil să programăm nestructurat? ===

Iată câteva exemple:

* Când o funcție are de testat 2-3-4 precondiții, este mai firesc să apelăm ''return'' prematur decât să scriem corpul principal al funcției sub 2-3-4 niveluri de indentare.
* Cazul de bază în funcțiile recursive poate fi pus la început și terminat cu ''return''.
* Pentru ''switch'' folosim ''break'' căci nu putem evita asta.

În toate situațiile folosim ''return'' sau ''break'' dintr-un ''if'', niciodată dintr-o buclă.

== Un program de 10 linii poate fi [http://en.wikipedia.org/wiki/Wikipedia:Too_long;_didn't_read TLDR] ==

Ați încercat vreodată să citiți o carte tipărită la o editură de bloc? Cu margini de 1 mm, font de 8 și spațiere minusculă? Nu-i așa că e enervant?

Și programele pot fi ilizibile. Nu veți lucra toată viața de unii singuri, iar într-o echipă lizibilitatea este la fel de importantă ca eficiența. Uneori mi se pare că scopul vostru este un program cât mai scurt. De unde și până unde?

Încercați să deprindeți următoarele aspecte:

* '''O instrucțiune pe linie.''' Liniile scurte fac codul mai citibil.
* '''Spațierea.''' O linie goală este ca o virgulă. Folosiți-o acolo unde programul face trecerea între două bucăți separate logic: două funcții, două blocuri logic distincte în aceeași funcție. Nu exagerați cu spațierea. Este important ca fiecare funcție să încapă pe un singur ecran.
* '''Lungimea numelor de variabile.''' O literă este acceptabilă numai pentru scopuri încetățenite: ''i, j, k'' pentru variabilele de ciclu, ''m, n'' pentru dimensiunile matricei. Pentru orice altceva, alegeți nume mai clare (dar nici 3 cuvinte, căci ajungem la linii prea lungi).
* '''Goana stupidă după scurtimea codului.''' Două lucruri rele nu fac un lucru bun. Voi scrieți cod lung pentru că acolo converge procesul iterativ, iar pe parcurs îl scurtați mâncând acolade, spațiere și scurtând numele de variabile.
* '''Virgula în loc de acolade.''' Un caz particular al punctului anterior. Sunteți tentați să folosiți virgula ca să înghesuiți două instrucțiuni în același if, fără să adăugați acolade. Vă puteți păcăli singuri.
* '''Folosim for numai pentru număr cunoscut de iterații.''' Rezistați tentației de a deveni hackeri. Nu este o regulă unanim acceptată, dar este o idee bună. Și [http://en.wikipedia.org/wiki/For_loop Wikipedia] o menționează.
* '''Variabile cât mai locale.''' Dacă tot folosiți toate prostiile din C++, măcar folosiți și lucrurile bune. Declarați variabilele cât mai local (fără însă a împăna tot programul cu declarații). În special evitați variabilele globale pentru programe netriviale. Este ușor să pierdeți socoteala cine le modifică și când.
* '''Evitați freopen().''' Este o idee proastă să închideți '''stdin''' și în special '''stdout'''. În '''stdout''' puteți tipări mesaje de depanare pe care, dacă cumva le uitați în program, nu se întâmplă nimic rău. Dar dacă '''stdout''' și fișierul de ieșire al problemei sunt unul și același, riscați să tipăriți gunoaie în fișierul de ieșire. În plus, '''freopen()''' este o metodă foarte lipsită de considerație. Într-un program mai mare, cine știe ce bibliotecă vrea să tipărească mesaje pe ecran. Voi îi răpiți această posibilitate.

== Recursivitate inutilă ==

Nu vă fie frică să eliminați recursivitatea acolo unde ea nu este necesară. Cel mai comun exemplu este la problemele de programare dinamică, acolo unde, pe lângă valoarea soluției, se cere și soluția explicită.

Exemplu: cel mai lung subșir comun între două șiruri. Presupunând că avem două șiruri, ''a'' de lungime ''m'', și ''b'' de lungime ''n'', și că am calculat matricea ''d'' pentru toate perechile de prefixe, soluția se calculează recursiv astfel:

<syntaxhighlight>
char s[MAX_SOL];

void solutie(int i, int j) {
if (d[i][j]) {
if (a[i] == b[j]) {
solutie(i - 1, j - 1);
s[d[i][j] - 1] = a[i];
} else if (d[i][j - 1] > d[i - 1][j] {
solutie(d[i][j - 1]);
} else {
solutie(d[i - 1][j]);
}
}
}
...
solutie(m - 1, n - 1);
</syntaxhighlight>

Nu este rău, dar nu uitați că recursivitatea cere timp și memorie! Stiva de apeluri poate avea O(n) niveluri. Dacă spațiul sau timpul sunt o problemă, eliminați recursivitatea:

<syntaxhighlight>
char solutie[MAX_SOL];

int i = m - 1, j = n - 1;
solutie[d[i][j]] = '\0';

while (d[i][j]) {
if (a[i] == b[j]) {
solutie[d[i][j] - 1] = a[i];
i--;
j--;
} else if (d[i][j - 1] > d[i - 1][j] {
j--;
} else {
i--;
}
}
</syntaxhighlight>

Se pierde foarte puțin din claritatea codului, căci relația de recurență nu mai este susținută de apelul recursiv propriu-zis. Totuși, condițiile de recurență (din if-uri) sunt încă vizibile, iar codul necesită O(1) spațiu.

== STL este o armă cu două tăișuri ==

Această secțiune se aplică surselor scrise în afara concursurilor. La concurs, totul este permis. Totuși, nu uitați că omul folosește sculele cu care este obișnuit.

De ce venim la cerc? Pentru că vrem să învățăm algoritmi, nu doar să-i apelăm. Cu algoritmii din STL programați mai repede, dar nu învățați nimic. Sunt numeroase exemplele când trebuie să înțelegeți (și să particularizați) porțiuni dintr-un algoritm: pivotarea din quicksort, construirea automatului din KMP, operațiile pe vectori de biți.

Nu uitați că algoritmii din STL pot fi mai lenți sau mai consumatori de memorie decât cei scriși de voi. Este firesc, căci aceia sunt prea generali și adesea fac operații care nu sunt necesare pentru problema voastră. Qsort din stdlib, de exemplu, necesită aproape dublul memoriei și este mai lent. Am observat asta de mai multe ori. De exemplu, am trimis [http://varena.ro/job_detail/29271 două] [http://varena.ro/job_detail/29277 surse] la problema [http://varena.ro/problema/avioane Avioane]. A doua diferă doar prin faptul că mi-am scris propriul quicksort. Nu știu dacă și sortarea din biblioteca algorithm are această problemă.

La problema [http://varena.ro/problema/dirty Dirty], am comparat sursa mea cu a unor concurenți care făceau cam același lucru, doar că foloseau vectori STL (și iteratori) în loc de vectori C. Diferența de timp este considerabilă. Ajungeți să parsați manual fișierul de intrare ca să câștigați timp. Care mai e câștigul? Ce luați pe mere dați pe pere.

Nu uitați de ce lucrăm în C/C++, nu în PHP sau în Ruby: avem nevoie de viteză, iar C se pretează cel mai bine la asta.

=== Sortarea, înger și demon ===

Sortarea din STL merită un capitol special. Nu zic să nu o folosiți ca să câștigați 10 minute la concurs. (Dacă vă ia mai mult de 10 minute să vă implementați propria sortare, deja avem probleme mai grave). Dar dacă dați una-două fuga la sortare, riscați să pierdeți esențialul din vedere.

* Există cel puțin 5 sortări ușor de codat, fiecare cu avantajele ei (quicksort, mergesort, heapsort, radix sort, counting sort). Fiecare dintre ele are avantaje și poate fi personalizată. Luați ca exemplu problema numărării inversiunilor dintr-o permutare, dată la [http://www.math.bas.bg/keleved/shumen2013 Șumen 2013], care se rezolvă ușor cu un merge sort adaptat. Dacă vă gândiți la sortare ca la o cutie neagră, veți uita ce posibilități aveți.
* Radix sort și counting sort sunt O(n)! Dacă problema se pretează la o astfel de sortare, atunci '''sort()''' nu ajută, ci dăunează.
* Unele probleme se pot rezolva pur și simplu fără sortare. Nu vă adormiți gândirea cu stereotipuri de genul „încep cu o sortare, să fie”.

== Department of Redundancy Department ==

Evitați să copiați bucăți mari de cod cu copy-paste. Îl avem pe Victor Ponta pentru asta. Dacă aveți cazuri '''aproape''' identice, dar diferite pe alocuri, este mai bine să parametrizați codul și să-l mutați într-o funcție sau chiar într-un ''for''.

Un exemplu concret: problema [http://varena.ro/problema/avioane Avioane] cerea, pentru anumite elemente dintr-un vector, calcularea unor distanțe la stânga și la dreapta. Cu toții ați rezolvat problema pentru direcția stângă, apoi ați dublat codul și ați modificat ce era necesar ca să-l faceți să meargă și spre dreapta. Mă simt onorat că v-a plăcut problema atât de mult, încât ați rezolvat-o de două ori. :-) Iată două metode de a elimina redundanța:

# Parametrizați tot ce se modifică între direcția stângă și cea dreaptă: punctul de pornire, cel de oprire, pasul (+/- 1). Fratele meu Cristi a pus tot codul într-un for în care singurul parametru era pasul (+/- 1). Deci se poate.
# Calculați toate valorile spre stânga, apoi întoarceți vectorul pe dos și recalculați valorile tot spre stânga.

Din nou, principiul este DRY: ''Don't Repeat Yourself''. Riscați să găsiți un bug într-una din copii și să uitați să-l reparați și în cealaltă.

Bugurile de redundanță sunt greu de reparat pentru că avem de luptat și împotriva naturii noastre umane. Ni se pare că nu are sens să citim ambele blocuri, căci a doua e „la fel ca prima”. Nu vi s-a întâmplat niciodată să vă uitați 10 minute fără să vă dați seama ce e greșit în codul de mai jos?

<syntaxhighlight>
for (int i = 0; i < m; i++) {
for (int j = 0; i < n; j++) {
}
}
</syntaxhighlight>

== Dimensiunea datelor de intrare ==

Fiți întotdeauna atenți la valorile minime și maxime pe care le poate lua o variabilă. Dacă vă obișnuiți să lucrați numai cu ''int'' și cu ''long long'', veți uita că puteți face economii mari de memorie folosind short și char.

Mai mult, uneori valorile încap pe 4 biți, pe 2 sau chiar pe unul singur. Toate aceste cazuri pot fi tratate ușor cu rutine de 1-2 linii. Iată o implementare pentru baza 4 (codul complet este în [[media:two-bit.cpp]]).

<syntaxhighlight>
#define MAX_N 1000000

unsigned char b[MAX_N / 4];

int get(int i) {
return (b[i/4] >> (2 * (i % 4))) & 3;
}

void set(int i, int x) {
// Clear the previous value if needed
b[i/4] &= ~(3 << (2 * (i % 4)));
b[i/4] ^= x << (2 * (i % 4));
}
</syntaxhighlight>

Exemplu: la problema [http://varena.ro/problema/palindrom Palindrom] primeați foarte puțină memorie. Algoritmul de programare dinamică nu este dificil, dar pentru reconstituirea soluției avem nevoie de întreaga matrice, mai exact de triunghiul superior al unei matrice de dimensiuni n x n. Cum n ≤ 5.000, în aparență avem nevoie de 25 MB. În realitate, o celulă din matrice necesită un singur bit pentru stocare, deci necesarul de memorie este 5.000 x 5.000 / 2 / 8 = 1,56 MB.

== Parsarea intrării: când ai un ciocan, totul în jur pare un cui ==

Haideți să lămurim ceva: profesorii și propunătorii de probleme nu sunt sadici. Nu stau zile întregi să stoarcă fiecare picătură de eficiență dintr-o implementare, pentru ca apoi să vă ceară vouă să reușiți același lucru într-o oră. Limitele de timp sunt, în general, alese adăugând o marjă generoasă la o implementare curată, dar neoptimizată la sânge.

Dacă doriți să câștigați câteva zeci de milisecunde, aveți opțiunea să parsați intrarea. Dar amintiți-vă că sunteți pe un drum greșit și undeva ați pierdut din vedere ceva mult mai important. Nu lucrați cu ciocanul. Lucrați cu bisturiul.

Dacă totuși faceți parsarea datelor de intrare, faceți-o cu stil. Am observat codul următor (îl public anonim, dă-mi de veste dacă dorești credit).

<syntaxhighlight>
const int DIM = (1 << 12);
char buff[DIM];
int poz = 0;

void read(int &numar) {
numar = 0;
while (buff[poz] < '0' || buff[poz] > '9')
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
while ('0' <= buff[poz] && buff[poz] <= '9') {
numar = numar * 10 + buff[poz] - '0';
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
}
}
</syntaxhighlight>

Hai să-l scriem mai elegant și mai eficient de atât. I-am adus următoarele îmbunătățiri:

* (de stil) Funcția de citire a unui caracter trebuie separată. Separarea bufferării la un nivel abstract este un lucru bun. Această funcție amestecă citirea bufferată cu parsarea numărului.
* (de stil) Funcția citește în gol bufferul prima dată înainte de a citi primul bloc de pe disc. Este păcat.
* (de eficiență) Neapărat testați prezența unei cifre cu '''isdigit()''' din <ctype.h>. Codul de mai sus testează două condiții. '''isdigit()''' nu testează decât una, căci are un tabel de 256 de valori.
* (de eficiență) Declarați funcția / funcțiile inline. Compilatorul își poate da seama că este nevoie de asta, dar nu e garantat.
* (posibil de eficiență) Declarați fișierul de intrare global, ca să nu mai fie trimis ca parametru. Nu ar trebui să aibă niciun efect.

Primele patru modificări produc codul:

<syntaxhighlight>
#define BUF_SIZE 4096
char buf[BUF_SIZE];
int pos = BUF_SIZE;

inline char getChar(FILE *f) {
if (pos == BUF_SIZE) {
fread(buf, 1, BUF_SIZE, f);
pos = 0;
}
return buf[pos++];
}

inline int readInt(FILE *f) {
int result = 0;
char c;
do {
c = getChar(f);
} while (!isdigit(c));

do {
result = 10 * result + c - '0';
c = getChar(f);
} while (isdigit(c));

return result;
}
</syntaxhighlight>

Am rulat un experiment cu patru versiuni de program:

* una care citește cu fscanf
* una care citește cu codul de mai sus
* una care folosește primele patru optimizări
* una care folosește și a cincea optimizare

Fișierul de intrare are 10.000.000 de numere (79 MB). Am rulat fiecare program de zece ori, chiar pe serverul Varena, am eliminat cea mai rapidă și cea mai lentă rulare și am calculat media.

{|class="wikitable"
! versiune || timp mediu de rulare || sursă
|-
| cu fscanf || 4.31 s || [[media:parse1.cpp]]
|-
| cu codul de mai sus || 0.819 s || [[media:parse2.cpp]]
|-
| cu primele patru optimizări || 0.366 s || [[media:parse3.cpp]]
|-
| cu toate optimizările || 0.355 s || [[media:parse3.cpp]]
|}

Versiunea mai elegantă nu este mai lentă, ci chiar dimpotrivă. Pentru fișiere cu mărimi mai realiste (5-6 MB), versiunea 3 este cu circa 30 ms mai rapidă decât versiunea 2.

Nu uitați că puteți câștiga timp semnificativ, cam 50% față de versiunea cu '''fscanf(),''' folosind '''getc()''' pentru citirea caracter cu caracter. Folosim bufferul oferit de sistem. În multe situații poate fi suficient.

Morala? Să renunți la stil și să pierzi și din viteză este un compromis tare păgubos.

== O funcție este un contract ==

* Despre invarianți, cutii negre, contracte și comentarii.

Note de curs, clasele 11-12, 21 noiembrie 2013

2020-12-14T14:39:18Z

Cata: înlocuiesc <source> cu <syntaxhighlight>

Zilele acestea m-am uitat pe multe surse de la concursurile din această toamnă. Apoi am plâns. Din lacrimile mele s-a născut lecția de azi!

= Chestiuni de programare =

== Preliminarii ==

Orice lucru rău trebuie spus încadrat de două lucruri bune. Voi sunteți printre cei mai buni elevi din generația voastră și sunt onorat să lucrez cu voi. Deci luați observațiile de mai jos nu ca pe o insultă personală, ci ca pe o ocazie să vă îmbunătățiți. Gata, am început cu un lucru bun. :-)

Noi, profesorii, avem partea noastră de vină în felul dezlânat în care programați voi. Ne batem singuri pe spate că elevii știu algoritmi, dar nu ne pasă cum îi codează. Adevărul este că cele două merg mână în mână, mai ales apropo de ceea ce am mai spus: voi nu vedeți destul cod scris de alții. Deci o lecție pe an dedicată programării este doar un început.

== Programarea aproximativă ==

Banc: cică japonezii aud de Dacia -- mașină bună, fiabilă, piese ieftine. Cumpără planurile de la Dacia și încep și ei să o producă. Doar că, surpriză, de pe linia de asamblare le iese un tractor! Trimit un om la Pitești, să studieze uzina. Se uită el, se întoarce acasă, mai repară japonezii mici probleme la linia lor. Degeaba: de pe linia de asamblare ieșeau tractoare. Disperați, dau telefon în România și cer lămuriri. Românii îi liniștesc: „păi și nouă ne iese tot tractor, dar îl luăm la pilă!”

Toate subproblemele pe care le tratăm aici sunt doar vârfuri ale icebergului. Ele reflectă o problemă mai gravă: programarea aproximativă. Prin programare aproximativă înțelegem o serie de iterații de adăugare de cod care converge către o soluție. Programul capătă formă pe măsură ce îl scriem, ca și ideea de rezolvare:

* Mai am nevoie de un element în vector? Adaug 1 la lungimea lui.
* M-ar ajuta să am datele sortate? Ce idee bună, apelez un sort().
* Trebuie să ies prematur dintr-o buclă? Deja am scris-o folosind '''for''', deci inserez un '''break'''.

Nu ciocăniți ici și colo, nu programați reactiv, în funcție de erorile din iterația anterioară. Programați activ, gândindu-vă bine la algoritm și la detaliile lui și încercați să-l implementați bine din prima.

Veți vrea să mergeți la companii faimoase. Acolo oamenii se uită, încă de la interviu, la stilul vostru de codare. Iar, dacă veți fi acceptați, vă veți poticni la fiecare code review de aceleași observații. Dacă așteptați zece ani până să încercați să vă corectați, s-ar putea să fie prea târziu. Lenevirea creierului duce la o gândire încâlcită.

== Constante ==

Folosim în general constante pentru a face codul mai solid și mai ușor de modificat.

=== Constantele sunt sublime, dar lipsesc cu desăvârșire ===

Cel mai grav este să nu folosiți deloc constante. Orice repetiție, chiar și a unui singur număr, chiar și doar o dată, este o practică riscantă. Un programator bun își ordonează codul astfel încât o modificare undeva în program să nu necesite modificări în alte părți fără legătură. Acest principiu se numește [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself (DRY)].

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight lang="c">
int v[100000], w[100000];

...

int max = -2000000000;

...

</syntaxhighlight>
| <syntaxhighlight lang="c">
#define MAX_N 100000
#define INFINITY 2000000000

int v[MAX_N], w[MAX_N];

...

int max = -INFINITY;

...
</syntaxhighlight>
|}

Scenariu catastrofic: declarați 5 vectori de mărime 1.000. Testați programul, care trece toate testele mici. Înlocuiți 1.000 cu 100.000, dar omiteți una dintre aparițiile constantei. Trimiteți problema, care ia 0 puncte.

=== #define N "vreo 100000 și 17, să fie" ===

Aproape fără excepție am observat constante declarate cu „câteva” unități mai mari decât este necesar. Dacă problema specifică N ≤ 100.000, voi declarați 100.002, 100.005, 100.007. Unii mai creativi ajung la 111.111 (ce-i drept, estetica acestui număr este incontestabilă).

De ce faceți asta? Următoarele răspunsuri nu sunt acceptate:

* Îmi este teamă că programul are o viață proprie și că decide, de capul lui, să se reverse cu câteva elemente;
* Mă gândesc că biții nu sunt bine separați și că se pot păta unii de la alții;
* Cred că pointerul care iterează prin vector frânează greu și nu se va opri la timp;
* Am de gând să folosesc vectorul de la 1, deci un element deja s-a pierdut.

Următorul răspuns este acceptat:

* Nu am încredere în aptitudinile mele de programator și în robustețea codului pe care îl produc; vectorul este accesat și modificat în câteva locuri diferite și eu nu pot să demonstrez că mă încadrez în N elemente.

Nu programați în dorul lelii. Fiți stăpâni pe program. Nimeni nu jelește 10 octeți irosiți, dar este vorba de un principiu.

În plus, la matricele multidimensionale risipa se cumulează. 1.010 octeți în loc de 1.000? 1% risipă. 1.0103 octeți în loc de 1.0003? 3% risipă.

Dacă vă plac algoritmii, veți ajunge să învățați unii tot mai complicați. Dacă nu sunteți pe deplin stăpâni nici pe aceste cărămizi de la bază, vă va fi greu să construiți peste ele.

=== Patul lui Procust pentru constante ===

Adesea aveți nevoie de vectori de lungimi ușor diferite. Poate un vector se termină cu o santinelă, sau poate altul are santinele la ambele capete. Poate altul are N ≤ 100.000 elemente și va mai câștiga alte K ≤ 1.000 elemente în viitor. De cele mai multe ori, voi definiți constanta în program pentru a acoperi toate aceste cazuri.

Nu este bine, tot din principiu. Declarați o constantă egală cu cea specificată de datele problemei, apoi ajustați fiecare vector în funcție de necesități.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight lang="c">
#define MAX_N 101000
int v[MAX_N], w[MAX_N], x[MAX_N], y[MAX_N];

</syntaxhighlight>
| <syntaxhighlight lang="c">
#define MAX_N 100000
#define MAX_K 1000

int v[MAX_N];
int w[MAX_N + 1]; // bordat cu santinelă la sfârșit
int x[MAX_N + 2]; // bordat cu santinelă la ambele capete
int y[MAX_N + MAX_K]; // Va căpăta un element la fiecare iterație
</syntaxhighlight>
|}

Codul vostru va câștiga mult în eleganță și în claritate, căci scopul fiecărei variabile va deveni mai clar. Reiese și că 1 și 2 sunt constante (numărul de santinele nu depinde de mărimea intrării), dar K poate și el să varieze dacă datele problemei se schimbă.

== Break, continue și return prematur ==

Evităm, cu rare excepții, break, continue și return prematur pentru că fac codul mai greu de citit. Se aplică și la concurs, chiar dacă voi sunteți singurii cititori.

=== „Să oprească proștii la stop” ===

La semnele de stop (octogonul roșu), legea spune că trebuie să oprești complet mașina (să stea roata). În practică, mai devreme sau mai târziu toți șoferii ne dăm seama că putem să trecem pe lângă semn fără să oprim complet. Nu cunosc pe nimeni care să respecte la sânge această lege. „Rostogolirea” prin semnul de stop reduce uzura frânelor, deci are un avantaj palpabil. Dar suntem conștienți că facem o prostioară și că nu putem face asta oricând, oriunde -- în special când de pe strada cu prioritate vin mașini. Cine încalcă această lege fără discernământ se expune la accidente, potențial catastrofice.

La fel este și cu programarea nestructurată. Scopul nu este să urmăm orbește niște legi, ci să facem codul mai ușor de înțeles și de întreținut. Prin această prismă, situațiile legitime de folosire a programării nestructurate sunt rarisime.

=== Dar programez mai ușor așa ===

Viața nu e ușoară. Cu toții ne străduim azi ca să ne fie bine mai încolo, pe termen lung.

=== Dar scriu cod mai clar așa ===

Claritatea este în ochii cititorului. Dacă vă obișnuiți să programați aproximativ, orice program neaproximativ vi se va părea straniu.

Iată un exemplu tipic: căutarea lui ''x'' în vectorul ''v''.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight lang="c">
for (int i = 0; i < n; i++) {
if (v[i] == x) {
break;
}
}
</syntaxhighlight>
| <syntaxhighlight lang="c">
int i = 0;
while ((i < n) && (v[i] != x)) {
i++;
}

</syntaxhighlight>
|}

Codul este mai scurt și mai citibil. Versiunea cu break promite o condiție de ieșire (i >= n), apoi ne păcălește ieșind pe o cu totul altă condiție (v[i] == x). În versiunea structurată, ambele condiții sunt listate clar în instrucțiunea ''while''.

Un alt exemplu: un test dacă șirul ''s'' este palindrom.

{|class="wikitable"
! Așa nu
! Așa da
|-
| <syntaxhighlight lang="c">
bool palindrom(char *s){
for (int i = 0; 2 * i < n; i++) {
if (s[i] != s[n - 1 - i]) {
return false;
}
return true;
}
</syntaxhighlight>
| <syntaxhighlight lang="c">
bool palindrom(char *s){
int i = 0;
while ((2 * i < n) && (s[i] == s[n - 1 - i])) {
i++;
}
return (s[i] == s[n - 1 - i]);
}
</syntaxhighlight>
|}

=== Dar cum pot să scriu un switch fără break? ===

Limbajul C a apărut prin 1972, când informaticienii abia începeau să înțeleagă diferențele între programarea structurată și cea nestructurată. Demonstrația că orice program se poate scrie [http://en.wikipedia.org/wiki/Structured_program_theorem numai cu blocuri structurate] datează din 1966. În anii următori, polemica programării structurate versus cea nestructurată a polarizat lumea informaticii. [http://en.wikipedia.org/wiki/Go_To_Statement_Considered_Harmful#Criticism_and_decline Dijkstra] era pro-structurare, pe când [http://www.scribd.com/doc/38873257/Knuth-1974-Structured-Programming-With-Go-to-Statements Knuth] a dat exemple când instrucțiunea GOTO produce cod mai citibil.

Nu este, deci, de mirare, că limbajul C încorporează un atavism ca ''break''. Îl vom folosi, dar doar fiindcă nu putem altfel. Nu abuzăm de el; în special, nu permitem „curgerea” dintr-o ramură într-alta. Fiecare ramură trebuie să aibă ''break''-ul propriu.

=== Când este acceptabil să programăm nestructurat? ===

Iată câteva exemple:

* Când o funcție are de testat 2-3-4 precondiții, este mai firesc să apelăm ''return'' prematur decât să scriem corpul principal al funcției sub 2-3-4 niveluri de indentare.
* Cazul de bază în funcțiile recursive poate fi pus la început și terminat cu ''return''.
* Pentru ''switch'' folosim ''break'' căci nu putem evita asta.

În toate situațiile folosim ''return'' sau ''break'' dintr-un ''if'', niciodată dintr-o buclă.

== Un program de 10 linii poate fi [http://en.wikipedia.org/wiki/Wikipedia:Too_long;_didn't_read TLDR] ==

Ați încercat vreodată să citiți o carte tipărită la o editură de bloc? Cu margini de 1 mm, font de 8 și spațiere minusculă? Nu-i așa că e enervant?

Și programele pot fi ilizibile. Nu veți lucra toată viața de unii singuri, iar într-o echipă lizibilitatea este la fel de importantă ca eficiența. Uneori mi se pare că scopul vostru este un program cât mai scurt. De unde și până unde?

Încercați să deprindeți următoarele aspecte:

* '''O instrucțiune pe linie.''' Liniile scurte fac codul mai citibil.
* '''Spațierea.''' O linie goală este ca o virgulă. Folosiți-o acolo unde programul face trecerea între două bucăți separate logic: două funcții, două blocuri logic distincte în aceeași funcție. Nu exagerați cu spațierea. Este important ca fiecare funcție să încapă pe un singur ecran.
* '''Lungimea numelor de variabile.''' O literă este acceptabilă numai pentru scopuri încetățenite: ''i, j, k'' pentru variabilele de ciclu, ''m, n'' pentru dimensiunile matricei. Pentru orice altceva, alegeți nume mai clare (dar nici 3 cuvinte, căci ajungem la linii prea lungi).
* '''Goana stupidă după scurtimea codului.''' Două lucruri rele nu fac un lucru bun. Voi scrieți cod lung pentru că acolo converge procesul iterativ, iar pe parcurs îl scurtați mâncând acolade, spațiere și scurtând numele de variabile.
* '''Virgula în loc de acolade.''' Un caz particular al punctului anterior. Sunteți tentați să folosiți virgula ca să înghesuiți două instrucțiuni în același if, fără să adăugați acolade. Vă puteți păcăli singuri.
* '''Folosim for numai pentru număr cunoscut de iterații.''' Rezistați tentației de a deveni hackeri. Nu este o regulă unanim acceptată, dar este o idee bună. Și [http://en.wikipedia.org/wiki/For_loop Wikipedia] o menționează.
* '''Variabile cât mai locale.''' Dacă tot folosiți toate prostiile din C++, măcar folosiți și lucrurile bune. Declarați variabilele cât mai local (fără însă a împăna tot programul cu declarații). În special evitați variabilele globale pentru programe netriviale. Este ușor să pierdeți socoteala cine le modifică și când.
* '''Evitați freopen().''' Este o idee proastă să închideți '''stdin''' și în special '''stdout'''. În '''stdout''' puteți tipări mesaje de depanare pe care, dacă cumva le uitați în program, nu se întâmplă nimic rău. Dar dacă '''stdout''' și fișierul de ieșire al problemei sunt unul și același, riscați să tipăriți gunoaie în fișierul de ieșire. În plus, '''freopen()''' este o metodă foarte lipsită de considerație. Într-un program mai mare, cine știe ce bibliotecă vrea să tipărească mesaje pe ecran. Voi îi răpiți această posibilitate.

== Recursivitate inutilă ==

Nu vă fie frică să eliminați recursivitatea acolo unde ea nu este necesară. Cel mai comun exemplu este la problemele de programare dinamică, acolo unde, pe lângă valoarea soluției, se cere și soluția explicită.

Exemplu: cel mai lung subșir comun între două șiruri. Presupunând că avem două șiruri, ''a'' de lungime ''m'', și ''b'' de lungime ''n'', și că am calculat matricea ''d'' pentru toate perechile de prefixe, soluția se calculează recursiv astfel:

<syntaxhighlight lang="c">
char s[MAX_SOL];

void solutie(int i, int j) {
if (d[i][j]) {
if (a[i] == b[j]) {
solutie(i - 1, j - 1);
s[d[i][j] - 1] = a[i];
} else if (d[i][j - 1] > d[i - 1][j] {
solutie(d[i][j - 1]);
} else {
solutie(d[i - 1][j]);
}
}
}
...
solutie(m - 1, n - 1);
</syntaxhighlight>

Nu este rău, dar nu uitați că recursivitatea cere timp și memorie! Stiva de apeluri poate avea O(n) niveluri. Dacă spațiul sau timpul sunt o problemă, eliminați recursivitatea:

<syntaxhighlight lang="c">
char solutie[MAX_SOL];

int i = m - 1, j = n - 1;
solutie[d[i][j]] = '\0';

while (d[i][j]) {
if (a[i] == b[j]) {
solutie[d[i][j] - 1] = a[i];
i--;
j--;
} else if (d[i][j - 1] > d[i - 1][j] {
j--;
} else {
i--;
}
}
</syntaxhighlight>

Se pierde foarte puțin din claritatea codului, căci relația de recurență nu mai este susținută de apelul recursiv propriu-zis. Totuși, condițiile de recurență (din if-uri) sunt încă vizibile, iar codul necesită O(1) spațiu.

== STL este o armă cu două tăișuri ==

Această secțiune se aplică surselor scrise în afara concursurilor. La concurs, totul este permis. Totuși, nu uitați că omul folosește sculele cu care este obișnuit.

De ce venim la cerc? Pentru că vrem să învățăm algoritmi, nu doar să-i apelăm. Cu algoritmii din STL programați mai repede, dar nu învățați nimic. Sunt numeroase exemplele când trebuie să înțelegeți (și să particularizați) porțiuni dintr-un algoritm: pivotarea din quicksort, construirea automatului din KMP, operațiile pe vectori de biți.

Nu uitați că algoritmii din STL pot fi mai lenți sau mai consumatori de memorie decât cei scriși de voi. Este firesc, căci aceia sunt prea generali și adesea fac operații care nu sunt necesare pentru problema voastră. Qsort din stdlib, de exemplu, necesită aproape dublul memoriei și este mai lent. Am observat asta de mai multe ori. De exemplu, am trimis [http://varena.ro/job_detail/29271 două] [http://varena.ro/job_detail/29277 surse] la problema [http://varena.ro/problema/avioane Avioane]. A doua diferă doar prin faptul că mi-am scris propriul quicksort. Nu știu dacă și sortarea din biblioteca algorithm are această problemă.

La problema [http://varena.ro/problema/dirty Dirty], am comparat sursa mea cu a unor concurenți care făceau cam același lucru, doar că foloseau vectori STL (și iteratori) în loc de vectori C. Diferența de timp este considerabilă. Ajungeți să parsați manual fișierul de intrare ca să câștigați timp. Care mai e câștigul? Ce luați pe mere dați pe pere.

Nu uitați de ce lucrăm în C/C++, nu în PHP sau în Ruby: avem nevoie de viteză, iar C se pretează cel mai bine la asta.

=== Sortarea, înger și demon ===

Sortarea din STL merită un capitol special. Nu zic să nu o folosiți ca să câștigați 10 minute la concurs. (Dacă vă ia mai mult de 10 minute să vă implementați propria sortare, deja avem probleme mai grave). Dar dacă dați una-două fuga la sortare, riscați să pierdeți esențialul din vedere.

* Există cel puțin 5 sortări ușor de codat, fiecare cu avantajele ei (quicksort, mergesort, heapsort, radix sort, counting sort). Fiecare dintre ele are avantaje și poate fi personalizată. Luați ca exemplu problema numărării inversiunilor dintr-o permutare, dată la [http://www.math.bas.bg/keleved/shumen2013 Șumen 2013], care se rezolvă ușor cu un merge sort adaptat. Dacă vă gândiți la sortare ca la o cutie neagră, veți uita ce posibilități aveți.
* Radix sort și counting sort sunt O(n)! Dacă problema se pretează la o astfel de sortare, atunci '''sort()''' nu ajută, ci dăunează.
* Unele probleme se pot rezolva pur și simplu fără sortare. Nu vă adormiți gândirea cu stereotipuri de genul „încep cu o sortare, să fie”.

== Department of Redundancy Department ==

Evitați să copiați bucăți mari de cod cu copy-paste. Îl avem pe Victor Ponta pentru asta. Dacă aveți cazuri '''aproape''' identice, dar diferite pe alocuri, este mai bine să parametrizați codul și să-l mutați într-o funcție sau chiar într-un ''for''.

Un exemplu concret: problema [http://varena.ro/problema/avioane Avioane] cerea, pentru anumite elemente dintr-un vector, calcularea unor distanțe la stânga și la dreapta. Cu toții ați rezolvat problema pentru direcția stângă, apoi ați dublat codul și ați modificat ce era necesar ca să-l faceți să meargă și spre dreapta. Mă simt onorat că v-a plăcut problema atât de mult, încât ați rezolvat-o de două ori. :-) Iată două metode de a elimina redundanța:

# Parametrizați tot ce se modifică între direcția stângă și cea dreaptă: punctul de pornire, cel de oprire, pasul (+/- 1). Fratele meu Cristi a pus tot codul într-un for în care singurul parametru era pasul (+/- 1). Deci se poate.
# Calculați toate valorile spre stânga, apoi întoarceți vectorul pe dos și recalculați valorile tot spre stânga.

Din nou, principiul este DRY: ''Don't Repeat Yourself''. Riscați să găsiți un bug într-una din copii și să uitați să-l reparați și în cealaltă.

Bugurile de redundanță sunt greu de reparat pentru că avem de luptat și împotriva naturii noastre umane. Ni se pare că nu are sens să citim ambele blocuri, căci a doua e „la fel ca prima”. Nu vi s-a întâmplat niciodată să vă uitați 10 minute fără să vă dați seama ce e greșit în codul de mai jos?

<syntaxhighlight lang="c">
for (int i = 0; i < m; i++) {
for (int j = 0; i < n; j++) {
}
}
</syntaxhighlight>

== Dimensiunea datelor de intrare ==

Fiți întotdeauna atenți la valorile minime și maxime pe care le poate lua o variabilă. Dacă vă obișnuiți să lucrați numai cu ''int'' și cu ''long long'', veți uita că puteți face economii mari de memorie folosind short și char.

Mai mult, uneori valorile încap pe 4 biți, pe 2 sau chiar pe unul singur. Toate aceste cazuri pot fi tratate ușor cu rutine de 1-2 linii. Iată o implementare pentru baza 4 (codul complet este în [[media:two-bit.cpp]]).

<syntaxhighlight lang="c">
#define MAX_N 1000000

unsigned char b[MAX_N / 4];

int get(int i) {
return (b[i/4] >> (2 * (i % 4))) & 3;
}

void set(int i, int x) {
// Clear the previous value if needed
b[i/4] &= ~(3 << (2 * (i % 4)));
b[i/4] ^= x << (2 * (i % 4));
}
</syntaxhighlight>

Exemplu: la problema [http://varena.ro/problema/palindrom Palindrom] primeați foarte puțină memorie. Algoritmul de programare dinamică nu este dificil, dar pentru reconstituirea soluției avem nevoie de întreaga matrice, mai exact de triunghiul superior al unei matrice de dimensiuni n x n. Cum n ≤ 5.000, în aparență avem nevoie de 25 MB. În realitate, o celulă din matrice necesită un singur bit pentru stocare, deci necesarul de memorie este 5.000 x 5.000 / 2 / 8 = 1,56 MB.

== Parsarea intrării: când ai un ciocan, totul în jur pare un cui ==

Haideți să lămurim ceva: profesorii și propunătorii de probleme nu sunt sadici. Nu stau zile întregi să stoarcă fiecare picătură de eficiență dintr-o implementare, pentru ca apoi să vă ceară vouă să reușiți același lucru într-o oră. Limitele de timp sunt, în general, alese adăugând o marjă generoasă la o implementare curată, dar neoptimizată la sânge.

Dacă doriți să câștigați câteva zeci de milisecunde, aveți opțiunea să parsați intrarea. Dar amintiți-vă că sunteți pe un drum greșit și undeva ați pierdut din vedere ceva mult mai important. Nu lucrați cu ciocanul. Lucrați cu bisturiul.

Dacă totuși faceți parsarea datelor de intrare, faceți-o cu stil. Am observat codul următor (îl public anonim, dă-mi de veste dacă dorești credit).

<syntaxhighlight lang="c">
const int DIM = (1 << 12);
char buff[DIM];
int poz = 0;

void read(int &numar) {
numar = 0;
while (buff[poz] < '0' || buff[poz] > '9')
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
while ('0' <= buff[poz] && buff[poz] <= '9') {
numar = numar * 10 + buff[poz] - '0';
if (++poz == DIM)
fread(buff, 1, DIM, stdin), poz = 0;
}
}
</syntaxhighlight>

Hai să-l scriem mai elegant și mai eficient de atât. I-am adus următoarele îmbunătățiri:

* (de stil) Funcția de citire a unui caracter trebuie separată. Separarea bufferării la un nivel abstract este un lucru bun. Această funcție amestecă citirea bufferată cu parsarea numărului.
* (de stil) Funcția citește în gol bufferul prima dată înainte de a citi primul bloc de pe disc. Este păcat.
* (de eficiență) Neapărat testați prezența unei cifre cu '''isdigit()''' din <ctype.h>. Codul de mai sus testează două condiții. '''isdigit()''' nu testează decât una, căci are un tabel de 256 de valori.
* (de eficiență) Declarați funcția / funcțiile inline. Compilatorul își poate da seama că este nevoie de asta, dar nu e garantat.
* (posibil de eficiență) Declarați fișierul de intrare global, ca să nu mai fie trimis ca parametru. Nu ar trebui să aibă niciun efect.

Primele patru modificări produc codul:

<syntaxhighlight lang="c">
#define BUF_SIZE 4096
char buf[BUF_SIZE];
int pos = BUF_SIZE;

inline char getChar(FILE *f) {
if (pos == BUF_SIZE) {
fread(buf, 1, BUF_SIZE, f);
pos = 0;
}
return buf[pos++];
}

inline int readInt(FILE *f) {
int result = 0;
char c;
do {
c = getChar(f);
} while (!isdigit(c));

do {
result = 10 * result + c - '0';
c = getChar(f);
} while (isdigit(c));

return result;
}
</syntaxhighlight>

Am rulat un experiment cu patru versiuni de program:

* una care citește cu fscanf
* una care citește cu codul de mai sus
* una care folosește primele patru optimizări
* una care folosește și a cincea optimizare

Fișierul de intrare are 10.000.000 de numere (79 MB). Am rulat fiecare program de zece ori, chiar pe serverul Varena, am eliminat cea mai rapidă și cea mai lentă rulare și am calculat media.

{|class="wikitable"
! versiune || timp mediu de rulare || sursă
|-
| cu fscanf || 4.31 s || [[media:parse1.cpp]]
|-
| cu codul de mai sus || 0.819 s || [[media:parse2.cpp]]
|-
| cu primele patru optimizări || 0.366 s || [[media:parse3.cpp]]
|-
| cu toate optimizările || 0.355 s || [[media:parse3.cpp]]
|}

Versiunea mai elegantă nu este mai lentă, ci chiar dimpotrivă. Pentru fișiere cu mărimi mai realiste (5-6 MB), versiunea 3 este cu circa 30 ms mai rapidă decât versiunea 2.

Nu uitați că puteți câștiga timp semnificativ, cam 50% față de versiunea cu '''fscanf(),''' folosind '''getc()''' pentru citirea caracter cu caracter. Folosim bufferul oferit de sistem. În multe situații poate fi suficient.

Morala? Să renunți la stil și să pierzi și din viteză este un compromis tare păgubos.

Pregătirea unui concurs

2018-10-12T08:23:26Z

Cata:

== Regulament intern al comisiei ==

* Unii membri nu vor avea drept de vot. Fără a jigni pe nimeni, nu toți dorim același lucru de la un concurs, iar asta se reflectă în voturile pe probleme. Unii vor să arate ce probleme dure pot ei să producă. Alții vor să testeze dacă concurenții cunosc un algoritm în particular. Cu un vot 100% democratic, lucrurile se vor duce mereu pe acest făgaș greșit.

* Membrii trebuie să contribuie cu volumul de muncă așteptat de la ei (estimativ 40-60 de ore).

* Membrii trebuie să contribuie din timp (vezi calendarul), nu în ultimele 3 zile.

* Membrii trebuie să trimită surse didactice, citibile, comentate. Este foarte dăunător să propagăm conceptul (greșit) că singurul scop al unui program este să facă ce trebuie. Dacă concursul este internațional, toate numele de variabile și comentariile trebuie să fie în engleză.

* Membrii trebuie să fie disponibili pentru două întâlniri în persoană. Facem excepție pentru membrii care nu locuiesc în București, dar și ei trebuie să fie disponibili pentru o videoconferință.

* Membrii trebuie să îi informeze pe restul despre progresele făcute și planuri de viitor, printr-un e-mail periodic. Membrii vor primi mementouri prin e-mail pentru asta (săptămânal la început, la 3-4 zile spre final). Cei care omit să răspundă la un memento vor primi un avertisment. Cei care omit al doilea răspuns vor fi înlocuiți.

* Membrii trebuie să anunțe cât mai repede dacă își dau seama că nu mai pot contribui, din orice motive.

* Dacă sunt autorii unei probleme, membrii trebuie să fie disponibili pe telefon sau în persoană în timpul concursului, în afară de cazul în care altcineva acceptă această răspundere.

* Membrii trebuie să contribuie cu câteva ore și după concurs, pentru analiza finală (de exemplu, pentru a analiza sursele concurenților ca să vedem cine a reușit să fenteze probleme).

* Membrii vor face un minim de efort să se descurce cu tehnologiile folosite (să-și încarce testele în mediu, să adauge surse la repository etc.). Va exista un coordonator al acestor activități, dar el nu poate face singur totul.

== Regulament de concurs ==

* Sursele tuturor concurenților vor fi publicate după concurs, în domeniul public. Prin înscrierea în concurs, concurenții sunt de acord să renunțe la orice formă de copyright pe sursele lor. Nu neapărat toate variantele trimise vor fi publicate, dar cel puțin cea care determină scorul la fiecare problemă (ultima sau cea cu punctaj maxim, după caz).

== Tehnologii folosite ==

=== Repository ===

Vom folosi un repository privat pentru toate documentele (surse, teste, enunțuri). Există multe variante (GitHub / GitLab / Bitbucket / instalare proprie de GitLab etc.)

=== Mediul de concurs ===

Vom folosi un mediu de concurs pe măsură ce problemele se conturează. Este probabil bine ca acesta să fie același cu cel folosit la concursul în sine. Până acum am lucrat cu [https://cms-dev.github.io/ CMS] și cu [https://csacademy.com/ CS Academy]. Beneficii:

* Membrii comisiei își pot testa sursele devreme.
* Comisia poate afla ușor ce metode sunt deja implementate, ce punctaje iau și ce mai este de făcut pentru fiecare problemă.
** Pentru asta, sursele trimise trebuie să conțină, într-un comentariu, numele autorului și metoda de rezolvare.

Cerințe de la mediu:

* Să aibă opțiunea pentru feedback complet / parțial.
* Să permită vederea tuturor surselor trimise (nu doar ultimele N sau orice de acest gen).
* Să permită relativ ușor organizarea unui concurs paralel online.

=== De analizat: pregătirea subiectelor în Polygon ===

Dan sugerează [https://polygon.codeforces.com/ Polygon] pentru pregătirea de probleme cu mai puține greșeli.

=== E-mail ===

Principalul mijloc de comunicare este o listă de e-mail, care are două avantaje:

# Este asincron. Nu presupune ore fixe.
# Ajunge la toți membrii simultan, spre deosebire de telefon.

Evident, membrii pot comunica între ei pe orice canale, dar tot ce este de interes general trebuie să ajungă și pe lista de e-mail.

Eticheta pe e-mail este:

* Dacă un mesaj este pentru tine, răspunde în maxim 24h. Nu ține lumea în loc.
* Probleme separate în threaduri separate.

== Ce înseamnă o problemă? ==

Crearea unei probleme de concurs înseamnă mai mult decât o sursă care să ia 100p.

În primul rând este nevoie de o '''idee'''. Acest pas durează cât durează, arta nu poate fi grăbită. Ca să facem un set bun de 6 probleme + 1-2 rezerve, realist avem nevoie de 13-15 idei.

Punerea în practică presupune:

* Tot ce înseamnă discuții pe e-mail despre problemă, dezbaterea algoritmilor etc.
* Formalizarea enunțului, pentru ca lumea să poată începe să trimită surse. Îl putem modifica ulterior, aducând la zi sursele trimise.
* Minim două soluții optime.
* Minim o soluție forță brută, dar cât mai corectă (cât mai greu de greșit).
* Minim două mânăreli (idei ușoare sau surse foarte scurte care încearcă să obțină cât mai multe puncte).
* Generatorul de teste. Autorul generatorului trebuie să prezinte în mare algoritmul de generare și cel puțin o altă persoană să-l analizeze.
* Generarea testelor.
* O sursă care să facă assert că testele încărcate efectiv în mediul de concurs corespund limitelor promise în enunț.
* Stabilirea limitelor pentru punctaje parțiale.
* Implementarea surselor pentru punctaje parțiale (e.g. un algoritm în O(N log^2 N) în loc de O(N log N)).
* Soluția în format PDF, cât mai clară.
* După concurs, analiza surselor concurenților pentru a vedea cine a reușit să fenteze problema. Ne interesează:
** cine a reușit să ia 90-100p cu o abordare diferită de a comisiei;
** cine a reușit să ia 40-50p sau mai mult cu o sursă foarte scurtă.

Toate sursele trebuie să fie didactice și comentate. Este jenant și needucativ să publicăm cod neinteligibil. Nu vă bazați pe altcineva să facă asta pentru voi.

Asta înseamnă zeci de ore per problemă. Nu este o glumă. Gândiți-vă bine dacă aveți acest timp înainte de a accepta invitația în comisie. Dacă tăiem orice colțuri de la această cale, concursul va avea de suferit.

== Calendar ==

{| class="wikitable"
! termen
! responsabil
! activitate
|-
| 4 luni
| organizatorul
| Stabilește câte probleme dorim și la ce nivel (OJI, ONI, lot).
|-
| 4 luni
| organizatorul
| Caută membri pentru comisie. Le transmite clar așteptările de mai sus.
|-
| 3 luni
| comisia
| Componența comisiei este definitivată. 
Membrii propun probleme pe lista de e-mail. 
Comisia planifică întâlniri în persoană.
|-
| 3 luni
| organizatorul
| Stabilește mediul de concurs. 
Caută sysadmin pentru mediu. Acesta are nevoie de timp să învețe sistemul.
|-
| 2 luni
| sysadminul
| Procură calculatoarele necesare pentru mediu (probabil unul singur). 
Livrează un mediu funcțional cu conturi și parole pentru membrii comisiei.
|-
| 2 - 1 luni
| comisia
| Are două întâlniri în care dezbate problemele. 
Identifică minim 3 probleme de care este sigură, la care poate lucra (vezi secțiunea „Ce înseamnă o problemă?”).
|-
| 2 luni - 1 săptămână
| comisia
| Lucrează la implementări cu tot ce ține de aceasta.
|-
| 4 săptămâni
| comisia
| Setul de probleme este definitivat. 
Autorii problemelor caută oameni pentru diversele faze ale implementării și escaladează din timp dacă nu găsesc.
|-
| 2 săptămâni
| organizatorul
| Compilează listele de concurenți.
|-
| 1 săptămână
| comisia
| Implementarea este finalizată.
|-
| 1 săptămână
| organizatorul
| Team leaderii colaborează pentru traduceri. 
Neclaritățile sunt colectate și trimise comisiei.
|-
| 3-4 zile
| comisia
| Comisia corectează neclaritățile.
|-
| 3-4 zile
| organizatorul
| Team leaderii definitivează traducerile.
|-
| 3 zile
| sysadminul
| Creează conturile concurenților. 
Creează 10 conturi generice pentru situații de urgență. 
Dacă mediul este partajat cu alte activități (ex. Varena), sysadminul se asigură că nu există teme sau alte concursuri cu deadline în timpul concursului nostru.
|-
| 2 zile înainte
| organizatorul
| Tipărește și multiplică subiectele.
|-
| în dimineața concursului
| sysadminul
| Pornește firewall-ul. Trebuie tăiat accesul la orice în afară de mediu și alte resurse convenite anterior (cplusplus.com etc.).
|-
| după concurs
| comisia
| Analizează sursele concurenților pentru a vedea cine și cum a reușit să fenteze problemele.
|-
| după concurs
| comisia
| Publică arhiva completă cu enunțuri, soluții, teste, surse.
|}

== TODO ==

De adăugat la document: organizarea unui practice session cu o problemă sau (dacă concursul real include și probleme interactive) cu două probleme, din care una interactivă.

De adăugat: organizarea unui concurs în liceu pe același hardware, pentru un pic de stress testing.

De adăugat: cerințe mai generale pentru CMS: cîți workeri, workerii să fie echivalenți, să fie hardware decent, workerul pentru concursul online să fie echivalent cu cei de la concursul real etc.

Numărul de workeri să țină cont și de numărul de concurenți (2018: 3 workeri Core 2 Duo la 104 concurenți).

Psihologia concursurilor de informatică

2018-03-31T13:45:15Z

Cata:

'''Notă 1''': Există și o [https://github.com/CatalinFrancu/psycho variantă Latex] a acestei cărți.

'''Notă 2''': Am publicat această carte în 1997 la Editura L&S Infomat. În 20 de ani s-au schimbat multe. Materia predată s-a schimbat mult. Concursurile s-au schimbat mult. Limbajele C și C++ au înlocuit aproape complet limbajul Pascal la concursuri. Mai ales, eu cel de acum nu mai sunt de acord cu unele principii, moduri de exprimare și stiluri de programare din această carte. Totuși, ocazional lumea îmi mai cere o copie a ei și mă simt jenat să le trimit un fișier Word (apropo de principii). De aceea, am publicat cartea online. Am păstrat tot conținutul original, făcând doar modificări minime de formatare pentru compatibilitatea cu MediaWiki (cuvântul „migălos” abia începe să descrie aceste modificări). — Cătălin, București, 2 martie 2018.

----

<blockquote>Această carte îi este dedicată fratelui meu Cristi, căruia îi datorez o mare parte din cunoștințele mele în domeniul programării. Un gând bun pentru familia mea și pentru prietenii mei, care mi-au luat toate îndatoririle de pe umeri cât timp am scris cartea de față. Fără înțelegerea și răbdarea lor, nu mi-aș fi putut duce munca la bun sfârșit.</blockquote>

* [[Psihologia concursurilor de informatică/0 Cuvânt înainte|Cuvânt înainte]]
* [[Psihologia concursurilor de informatică/1 Concursul de informatică|Capitolul I: Concursul de informatică (de la extaz la agonie)]]
* [[Psihologia concursurilor de informatică/2 Lucrul cu numere mari|Capitolul II: Lucrul cu numere mari]]
* [[Psihologia concursurilor de informatică/3 Lucrul cu structuri mari de date|Capitolul III: Lucrul cu structuri mari de date]]
* [[Psihologia concursurilor de informatică/4 Heap-uri și tabele de dispersie|Capitolul IV: Heap-uri și tabele de dispersie]]
* [[Psihologia concursurilor de informatică/5 Despre algoritmi exponențiali și îmbunătățirea lor|Capitolul V: Despre algoritmi exponențiali și îmbunătățirea lor]]
* [[Psihologia concursurilor de informatică/6 Probleme de concurs 1|Capitolul VI: Probleme de concurs (1-6)]]
* [[Psihologia concursurilor de informatică/6 Probleme de concurs 2|Capitolul VI: Probleme de concurs (7-12)]]
* [[Psihologia concursurilor de informatică/6 Probleme de concurs 3|Capitolul VI: Probleme de concurs (13-18)]]
* [[Psihologia concursurilor de informatică/7 Bibliografie|Bibliografie]]

Psihologia concursurilor de informatică/6 Probleme de concurs 3

2018-03-12T10:55:14Z

Cata:

⇦ înapoi la [[Psihologia concursurilor de informatică]]

= Capitolul VI: Probleme de concurs (13-18) =

== Problema 13 ==

Probabil că orice elev care are cât de cât experiență în programare a auzit despre '''problema celui mai lung subșir crescător'''. Când este prezentată la concurs, problema e „învelită” sub diverse forme. Aici o vom formaliza din punct de vedere matematic.

'''ENUNȚ''': Se dă un vector cu '''''N''''' elemente numere întregi. Se cere să se determine cel mai lung subșir crescător.

'''Intrarea''': Fișierul de tip text <tt>INPUT.TXT</tt> conține pe prima linie numărul '''''N''''' de elemente din vector ('''''N'''''≤10.000), iar pe fiecare din următoarele '''''N''''' linii se află câte un element al vectorului.

'''Ieșirea''': În fișierul de tip text <tt>OUTPUT.TXT</tt> se vor lista pe prima linie lungimea '''''L''''' a celui mai lung subșir crescător, iar pe următoarele '''''L''''' linii subșirul în sine. Dacă există mai multe soluții, se va tipări una singură.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>6 2 5 7 3 4 1</tt>
| <tt>3 2 3 4</tt>
|}

'''Timp de implementare''': 45 minute.

'''Timp de rulare''': 5 secunde.

'''Complexitate cerută''': <math>O(N \log N)</math>.

'''REZOLVARE''': Începem prin a lămuri diferența dintre noțiunile de „subșir” și „subsecvență”. Fie '''''V'''''[1], '''''V'''''[2], ..., '''''V'''''[N], vectorul citit. Prin '''subșir de lungime ''L''''' al vectorului V se înțelege o succesiune nu neapărat continuă de elemente <math>V[K_1], V[K_2], \dots, V[K_L]</math>, unde <math>K_1<K_2< ... <K_L</math>. Prin '''subsecvență de lungime ''L''''' a vectorului, începând de la poziția '''K''', se înțelege succesiunea continuă de elemente '''''V'''''['''''K'''''], '''''V'''''['''''K'''''+1], ..., '''''V'''''['''''K'''''+'''''L'''''-1].

Rezolvarea prin metoda programării dinamice este în general cunoscută și nu vom insista asupra ei. Probabil că aflarea celui mai lung subșir crescător este punctul de plecare al oricărui elev în învățarea programării dinamice. Totuși, această metodă de rezolvare are complexitatea <math>O(N^2)</math>. În continuare prezentăm o metodă mai puțin cunoscută și ceva mai dificil de implementat, dar mult mai eficientă. Ea are complexitatea <math>O(N \log N)</math>. Vom enunța principiul de rezolvare, urmat de o schiță a demonstrației de corectitudine.

Fie '''''V''''' vectorul citit. Se parcurge vectorul de la stânga la dreapta și se construiesc în paralel doi vectori '''''P''''' și '''''Q''''', astfel: inițial vectorul '''''Q''''' este vid. Se ia fiecare element din '''''V''''' și se suprascrie peste cel mai mic element din '''''Q''''' care este strict mai mare ca el. Dacă nu există un asemenea element în '''''Q''''', cu alte cuvinte dacă elementul analizat din '''''V''''' este mai mare ca toate elementele din '''''Q''''', atunci el este adăugat la sfârșitul vectorului '''''Q'''''. Concomitent, se notează în vectorul '''''P''''' poziția pe care a fost adăugat în vectorul '''''Q''''' elementul din '''''V'''''. Iată cum se construiesc vectorii '''''P''''' și '''''Q''''' pentru exemplul din enunț:

[[File:Psycho-fig68.png]]

Lungimea '''''L''''' la care ajunge vectorul '''''Q''''' la sfârșitul acestei prelucrări este tocmai lungimea celui mai lung subșir crescător al vectorului '''''V'''''. Pentru a afla exact și care sunt elementele subșirului crescător se procedează astfel: se caută ultima apariție în vectorul '''''P''''' a valorii '''''L'''''. Să spunem că ea este găsită pe poziția <math>K_L</math>. Se caută apoi ultima apariție în vectorul '''''P''''' a valorii '''''L'''''-1, anterior poziției <math>K_L</math>. Ea va fi pe poziția <math>K_{L-1}<K_{L}</math>. Analog se caută în vectorul '''''P''''' valorile '''''L'''''-2, '''''L'''''-3, ..., 2, 1. Subșirul crescător este <math>S=(V[K_1], V[K2], \dots, V[K_L])</math>.

În figura de mai sus au fost hașurate elementele respective găsite în vectorul '''''P'''''. Vectorul '''''Q''''' are la sfârșit lungimea '''''L'''''=3, deci cel mai lung subșir crescător are trei elemente. Se caută în vectorul '''''P''''' cifrele 3, 2 și 1 și se găsesc pe pozițiile <math>K_1=1</math>, <math>K_2=4</math> și <math>K_3=5</math>, ceea ce înseamnă că cel mai lung subșir crescător este (2, 3, 4).

Demonstrația (care, fără a pierde din corectitudine, face apel la intuiție...) folosește aceleași notații de mai sus și are următoarele etape:

'''1. Vectorul ''Q'' este în permanență sortat crescător.'''

Demonstrația acestei afirmații se face prin inducție. După primul pas (inserarea elementului '''''V'''''[1]), vectorul '''''Q''''' are un singur element și este bineînțeles ordonat. Trebuie acum arătat că dacă vectorul Q este sortat după inserarea elementului '''''V'''''['''''i'''''-1], el rămâne sortat și după inserarea lui '''''V'''''['''''i''''']. Într-adevăr, pentru elementul '''''V'''''['''''i'''''] există două variante:

* '''''V'''''['''''i'''''] este mai mare decât toate elementele lui '''''Q''''', caz în care este adăugat la sfârșitul lui '''''Q''''', care rămâne sortat;
* Există '''''t'''''>1 astfel încât '''''Q'''''['''''t'''''-1]≤'''''V'''''['''''i''''']<'''''Q'''''['''''t'''''], caz în care '''''V'''''['''''i'''''] se suprascrie peste '''''Q'''''['''''t''''']. Dar '''''Q'''''['''''t''''']≤ '''''Q'''''['''''t'''''+1] ⇒ '''''Q'''''['''''t'''''-1]≤'''''V'''''['''''i''''']<'''''Q'''''['''''t'''''+1] și vectorul '''''Q''''' rămâne sortat.

Această deducție ne va fi utilă în calculul complexității algoritmului.

'''2. Odată ce au fost scrise pentru prima oară, elementele vectorului ''Q'' nu mai pot decât să scadă sau să rămână constante. Ele nu pot crește niciodată.'''

Afirmația este evidentă, decurgând din modul de construcție a lui '''''Q'''''.

'''3. Elementele din vectorul ''V'' de la poziția <math>K_{i-1}+1</math> la poziția <math>K_{i}-1</math> sunt fie mai mici decât <math>V[K_{i-1}]</math>, fie mai mari decât <math>V[K_i]</math>.'''

Acest lucru este natural, deoarece dacă ar exista <math>K_{i-1}<X<K_i</math> astfel încât <math>V[K_{i-1}] \leq V[X] \leq V[K_i]</math>, atunci șirul '''''S''''' ar putea fi extins cu elementul '''''V'''''['''''X'''''], deci nu ar fi subșir maximal, contradicție.

'''4. Toate elementele care urmează în ''V'' după <math>V[K_L]</math> sunt mai mici decât <math>V[K_L]</math>.'''

Dacă ar exista <math>X>K_L</math> astfel încât <math>V[X] \geq V[K_L]</math>, atunci '''''S''''' ar putea fi extins la dreapta cu '''''V'''''['''''X'''''], contradicție.

'''5. Elementul <math>V[K_1]</math> este suprascris peste poziția ''Q''[1].'''

Demonstrația este imediată: Dacă elementul <math>V[K_1]</math> este inserat în '''''Q''''' pe o poziție '''''t'''''>1, rezultă că, în momentul tratării lui <math>V[K_1]</math>, pe poziția '''''t'''''-1 în vectorul '''''Q''''' exista deja un număr <math>X<V[K_1]</math>. Aceasta înseamnă că '''''S''''' poate fi prelungit la stânga cu '''''X''''', deci '''''S''''' nu este un subșir crescător maxim, contradicție.

'''6. Orice element <math>V[K_i]</math> va fi suprascris în ''Q'' pe poziția următoare celei pe care a fost scris <math>V[K_{i-1}]</math>'''

Demonstrație: Să presupunem că <math>V[K_{i-1}]</math> a fost scris peste '''''Q'''''['''''t''''']. Înainte de a ajunge să tratăm elementul <math>V[K_i]</math>, a trebuit să tratăm elementele <math>V[K_{i-1}+1], V[K_{i-1}+2], \dots, V[K_{i}-1]</math>, care, după cum s-a stabilit la punctul (3), pot fi:

* mai mici decât <math>V[K_{i-1}]</math>, caz în care ele vor fi scrise în vector pe poziții mai mici sau egale cu '''''t''''', iar '''''Q'''''['''''t'''''] va scădea, deci <math>Q[t] \leq V[K_{i-1}]</math> (conform punctului 2);
* mai mari decât <math>V[K_i]</math>, caz în care vor fi scrise în '''''Q''''' pe poziții mai mari decât '''''t''''', așadar <math>Q[t+1]>V[K_i]</math>.

Se obține lanțul de inegalități <math>Q[t] \leq V[K_{i-1}] \leq V[K_i] \leq Q[t+1]</math>, de unde rezultă conform modului de construcție că <math>V[K_i]</math> va fi scris peste '''''Q'''''['''''t'''''+1]. Cu aceasta, folosind și punctul (5), am demonstrat că <math>V[K_i]</math> este scris pe poziția '''''Q'''''['''''i'''''], ∀'''''i'''''=1, 2, ..., '''''L'''''. După tratarea primelor <math>K_L</math> elemente din '''''V''''', vectorul '''''Q''''' are lungimea '''''L'''''. Mai rămâne de văzut ce se întâmplă cu elementele <math>V[K_L+1], \dots, V[N]</math>.

'''7. Elementele care îi urmează lui <math>V[K_L]</math> se scriu în ''Q'' pe poziții mai mici sau egale cu ''L''.'''

Acest fapt este intuitiv dacă se ține cont de punctul (4). Deducem că la final vectorul '''''Q''''' are lungime '''''L''''', adică aceeași cu a lui '''''S'''''. Modul de reconstituire a lui '''''S''''' din vectorul '''''P''''' este corect. Trebuie să avem grijă ca, atunci când căutăm în vectorul '''''P''''' o apariție a valorii '''''X''''', să o alegem pe ultima disponibilă, altfel pot apărea erori. Spre exemplu, pentru vectorii dați în exemplu, '''''V'''''=(2, 5, 7, 3, 4, 1) și '''''P'''''=(1, 2, 3, 2, 3, 1), dacă se alege prima apariție a lui 2 (pe poziția a doua), avem subșirul '''''S'''''=(2, 5, 4) care nu este crescător. Dacă însă alegem ultima apariție a lui 2 (pe poziția a patra), avem subșirul crescător maximal '''''S'''''=(2, 3, 4).

Calculul complexității este ușor de făcut:

* Pentru construcția vectorilor '''''P''''' și '''''Q''''' sunt necesare '''''N''''' inserții în vectorul '''''Q''''', care este sortat; o inserție binară cere <math>O(\log N)</math>, așadar complexitatea primei părți este <math>O(N \log N)</math>.
* Pentru reconstituirea lui '''''S''''' se face o singură parcurgere a vectorului '''''P''''', deci <math>O(N)</math>.

Complexitatea totală a algoritmului este <math>O(N \log N)</math>.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#define Infinity 30000
typedef int Vector[10001];

Vector V,P,Q,*S;
int N,Len; /* Len = Lungimea vectorului Q */

void ReadData(void)
{ FILE *F=fopen("input.txt","rt");
int i;

fscanf(F,"%d",&N);
for(i=1;i<=N;i++) fscanf(F,"%d",&V[i]);
fclose(F);
}

int Insert(int K,int Lo,int Hi)
{ int Mid=(Lo+Hi)/2;

if (Lo==Hi)
{ if (Hi>Len) Q[++Len+1]=Infinity;
Q[Lo]=K;
return Lo;
}
else if (K<Q[Mid]) return Insert(K,Lo,Mid);
else return Insert(K,Mid+1,Hi);
}

void BuildPQ(void)
{ int i,Place;

Len=0;Q[1]=Infinity;
for (i=1;i<=N;i++)
P[i]=Insert(V[i],1,Len+1);
}

void BuildS(void)
{ int i,K=N;

S=malloc(sizeof(*S));
for (i=Len;i;i--)
{ while (P[K]!=i) K--;
(*S)[i]=V[K];
}
}

void WriteSolution(void)
{ FILE *F=fopen("output.txt","wt");
int i;

fprintf(F,"%d\n",Len);
for(i=1;i<=Len;i++) fprintf(F,"%d\n",(*S)[i]);

fclose(F);
}

void main(void)
{
ReadData();
BuildPQ();
BuildS();
WriteSolution();
}
</syntaxhighlight>

Menționăm că în sursa de mai sus se putea construi vectorul '''''S''''' peste vectorul '''''Q''''', deoarece pentru construirea lui '''''S''''' nu avem nevoie decât de elementele vectorului '''''P'''''. În acest fel, programul ar fi avut nevoie numai de trei vectori, iar volumul total de date nu ar fi depășit un segment. Am preferat totuși varianta în care vectorul '''''S''''' este alocat dinamic pentru a evita confuziile.

== Problema 14 ==

Continuăm cu două probleme foarte asemănătoare. Atât de asemănătoare, încât diferența dintre ele pare - la o privire superficială - neglijabilă. Totuși, algoritmul de rezolvare se schimbă fundamental.

'''ENUNȚ''': '''''N''''' grămezi de mere trebuie împărțite la '''''N''''' copii. Deoarece copiii sunt buni prieteni, trebuie ca împărțirea să se facă în mod echitabil, fiecare primind același număr de mere. Spiritul de dreptate al copiilor este atât de puternic, încât ei preferă ca unele mere să nu fie date nici unui copil, decât ca unii să primească mai multe mere ca alții. O condiție suplimentară este ca fie toate merele dintr-o grămadă să fie împărțite copiilor, fie grămada să nu mai fie împărțită deloc. Desigur, interesul este ca fiecare copil să primească un număr cât mai mare de mere.

Să se selecteze un număr de grămezi din cele '''''N''''' astfel încât numărul total de mere să se dividă cu '''''N''''', iar suma selectată să fie maximă. Dacă există mai multe soluții, se cere una singură.

'''Intrarea''': Fișierul de intrare <tt>INPUT.TXT</tt> conține pe prima linie numărul '''''N''''' de grămezi (1≤'''''N'''''≤100). Pe a doua linie se dau cantitățile de mere din cele '''''N''''' grămezi ('''''N''''' numere naturale pozitive, toate mai mici ca 200, separate prin spații).

'''Ieșirea''': În fișierul <tt>OUTPUT.TXT</tt> se va scrie pe prima linie numărul maxim de mere găsit. Pe a doua linie se vor tipări indicii grămezilor selectate, în ordine crescătoare.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>4 3 2 5 7</tt>
| <tt>12 1 3 4</tt><ref>Greșeală în original, corect: <tt>1 2 4</tt></ref>
|}

'''Timp de implementare''': 45 minute - maxim o oră.

'''Timp de rulare''': 1 secundă.

'''Complexitate cerută''': <math>O(N^2)</math>.

'''REZOLVARE''': O primă modalitate, de altfel foarte comodă, este să verificăm toate posibilitățile de a selecta grămezi. Aceasta presupune să generăm toate submulțimile mulțimii de grămezi, iar pentru fiecare submulțime să calculăm suma merelor. În felul acesta putem afla submulțimea pentru care suma merelor se divide cu '''''N''''' și este maximă. Din nefericire, această soluție, banal de implementat, are o complexitate exponențială, mai precis <math>O(N \times 2^N)</math>, deoarece există <math>2^N</math> submulțimi ale mulțimii grămezilor și pentru fiecare submulțime putem calcula suma merelor în timp liniar. Prin urmare, suntem departe de complexitatea cerută în enunț.

Punctul de plecare pentru rezolvarea corectă a problemei este din nou principiul de optimalitate al programării dinamice. Să notăm cu '''''M'''''[1], '''''M'''''[2], ..., '''''M'''''['''''N'''''] cantitățile de mere din fiecare grămadă. Să considerăm că submulțimea optimă conține în total '''''S''''' mere, iar grămada cu numărul '''''N''''' face parte din ea. Fie '''''K''''' restul împărțirii lui '''''M'''''['''''N'''''] la '''''N''''', deci

<math>M[N] \equiv K \pmod{N}</math>

Atunci suma '''''S''''' - '''''M'''''['''''N'''''] dă restul ('''''N'''''-'''''K''''') mod '''''N''''' la împărțirea prin '''''N''''', de unde deducem că

<math>S - M[N] \equiv N - K \pmod{N}</math>

De asemenea, putem afirma că '''''S''''' - '''''M'''''['''''N'''''] este cea mai mare dintre toate sumele care se pot obține folosind grămezile 1, 2, ..., '''''N'''''-1 și care dau același rest la împărțirea prin '''''N'''''. Demonstrația nu este grea: dacă ar exista o sumă mai mare decât '''''S''''' - '''''M'''''['''''N'''''] congruentă cu ('''''N'''''-'''''K''''') modulo '''''N''''', am putea folosi această sumă și grămada '''''M'''''['''''N'''''] pentru a obține o sumă '''''S’'''''>'''''S''''' astfel încât

<math>S' \equiv 0 \pmod{N}</math>

Această observație ne sugerează și metoda de rezolvare a problemei. Pentru a afla care este submulțimea de sumă maximă, avem două variante:

* Grămada '''''N''''' face parte din această submulțime, caz în care trebuie să descoperim cea mai mare sumă care se poate obține adunând grămezi dintre primele '''''N'''''-1 și care dă restul ('''''N'''''-'''''K''''') la împărțirea prin '''''N''''';
* Grămada '''''N''''' nu face parte din această submulțime, caz în care trebuie să descoperim cea mai mare sumă care se poate obține adunând grămezi dintre primele '''''N'''''-1 și care se împarte exact la '''''N'''''.

Pentru că nu putem ști de la început dacă grămada a '''''N'''''-a face sau nu parte din submulțimea maximală, trebuie să avem răspunsul pregătit pentru ambele situații. Mai mult, pentru a putea afla care sunt sumele maxime formate cu primele '''''N'''''-1 grămezi care dau diferite resturi (în cazul nostru 0 sau '''''N'''''-'''''K''''') la împărțirea prin '''''N''''', trebuie să reluăm exact aceeași problemă: grămada cu numărul '''''N'''''-1 poate face sau nu parte din submulțime. În concluzie, putem formaliza problema astfel: avem nevoie să putem răspunde la toate întrebările de forma „Care este suma maximă care se poate forma cu grămezi din primele '''''P''''' astfel încât restul la împărțirea prin '''''N''''' să fie '''''Q'''''?”. Vom nota răspunsul la această întrebare cu '''''R'''''['''''P''''','''''Q'''''] (unde 1≤'''''P'''''≤'''''N''''' și 0≤'''''Q'''''<'''''N'''''). Răspunsurile tuturor întrebărilor se pot deci dispune într-o matrice '''''R''''', iar scopul nostru este să-l aflăm pe '''''R'''''['''''N''''',0]. Am observat că pentru a-l putea afla pe '''''R'''''['''''P''''','''''Q'''''] avem nevoie de două valori din linia '''''P'''''-1 a matricei (după cum grămada '''''P''''' face sau nu parte din submulțimea optimă). Pentru a afla toate elementele liniei '''''P''''' a matricei, este deci foarte probabil să avem nevoie de întreaga linie '''''P'''''-1.

Astfel, problema se reduce la a compune o linie a matricei din cea precedentă. Dacă presupunem că grămada '''''P''''' nu intră în componența submulțimii optime, atunci linia '''''P''''' este identică cu linia '''''P'''''-1:

<math>R[P,Q] = R[P - 1, Q], \forall 0 \leq Q < N</math>

Dacă presupunem că grămada '''''P''''' face parte din submulțime, atunci avem egalitatea:

<math>R[P,Q] = R[P - 1, (Q - M[P])\,\bmod\,N] + M[P], \forall 0 \leq Q < N</math>

Alegând dintre aceste variante pe cea care ne convine mai mult, obținem:

<math>
R[P,Q] = \max
\begin{Bmatrix}
R[P - 1, Q] \\
R[P - 1, (Q - M[P])\,\bmod\,N] + M[P]
\end{Bmatrix}
\forall 0 \leq Q < N
</math>

În felul acesta se completează fără nici un fel de probleme matricea '''''R'''''. După cum am spus, '''''R'''''['''''N''''',0] indică suma maximă divizibilă cu '''''N'''''. Mai rămâne de văzut cum se face reconstituirea soluției. De fapt, nu avem decât să parcurgem aceleași etape ale raționamentului, dar în sens invers. Respectiv: dacă '''''R'''''['''''N''''',0] = '''''R'''''['''''N'''''-1,0], atunci deducem că grămada a '''''N'''''-a nu a fost folosită pentru a se obține suma maximă și avem nevoie să obținem suma maximă divizibilă cu '''''N''''' din primele '''''N'''''-1 grămezi (adică '''''R'''''['''''N'''''-1,0]). Dacă '''''R'''''['''''N''''',0] ≠ '''''R'''''['''''N'''''-1,0], atunci grămada a '''''N'''''-a a fost folosită și avem nevoie să obținem suma maximă de rest ('''''N'''''-'''''M'''''['''''N''''']) modulo '''''P''''' folosind primele '''''N'''''-1 grămezi. Pe cazul general, pentru a obține suma maximă de rest '''''Q''''' folosind primele '''''P''''' grămezi, avem două posibilități:

* Dacă '''''R'''''['''''P''''','''''Q'''''] = '''''R'''''['''''P'''''-1,'''''Q'''''], atunci grămada '''''P''''' nu este folosită și trebuie să obținem același rest '''''Q''''' folosind doar primele '''''P'''''-1 grămezi;
* Dacă '''''R'''''['''''P''''','''''Q'''''] ≠ '''''R'''''['''''P'''''-1,'''''Q'''''], atunci grămada '''''P''''' este folosită și trebuie să obținem restul ('''''Q'''''- '''''M'''''['''''P''''']) modulo '''''N''''' folosind primele '''''P'''''-1 grămezi;

Menționăm că programul este puțin diferit de ceea ce s-a explicat până acum, în sensul că prima linie din matricea '''''R''''' corespunde ultimei grămezi de mere, a doua linie corespunde penultimei grămezi de mere ș.a.m.d. Cu alte cuvinte, grămezile de mere sunt procesate în ordine inversă. Am făcut acest lucru pentru a ușura procedura de aflare a soluției; se observă că prima oară se decide dacă ultima grămadă face parte din submulțime, apoi penultima etc. Deci și la găsirea soluției se generează grămezile în ordine inversă. Prin această dublă inversiune, indicii grămezilor de mere selectate vor fi listați în ordine crescătoare. Dacă am fi prelucrat grămezile de mere în ordinea lor din fișier, s-ar fi impus scrierea unei proceduri recursive pentru afișarea soluției.

Să facem și calculul complexității acestui program. Citirea datelor se face în <math>O(N)</math>, la fel și reconstituirea soluției. Pentru a completa o linie din matrice, avem nevoie să parcurgem linia precedentă, adică <math>O(N)</math>. Pentru compunerea întregii matrice, timpul necesar este pătratic.

Mai trebuie făcută o singură observație referitoare la modul de inițializare a matricei. Vom adăuga în matricea '''''R''''' linia cu numărul 0, care va conține sumele maxime ce se pot obține fără a folosi nici o grămadă. Desigur, se poate obține numai suma 0, care dă restul 0 la împărțirea prin '''''N''''', iar alte sume nu se pot obține. Vom pune deci '''''R'''''[0,0]=0 și '''''R'''''[0,i]='''''Impossible''''' pentru orice 1 ≤ i < '''''N''''', unde '''''Impossible''''' este o constantă specială (preferabil negativă, pentru a nu se confunda cu valorile obișnuite din matrice).

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 101
#define Impossible -30000

int M[NMax], R[NMax][NMax], N;
void ReadData(void)
{ FILE *F = fopen("input.txt", "rt");
int i;

fscanf(F, "%d\n", &N);
for (i=1; i<=N; fscanf(F, "%d", &M[i++]));
fclose(F);
}

void Share(void)
{ int i,j;

R[0][0]=0;
for (i=1; i<N; R[0][i++]=Impossible);

for (i=1; i<=N; i++)
{
for (j=0; j<N; j++)
R[i][j] = R[i-1][j];
for (j=0; j<N; j++)
if (R[i-1][j] != Impossible
&& R[i-1][j] + M[N+1-i] >
R[i][ (R[i-1][j]+M[N+1-i]) % N ])
R[i][ (R[i-1][j]+M[N+1-i]) % N ] =
R[i-1][j] + M[N+1-i];
}
}

void WriteSolution(void)
{ FILE *F = fopen("output.txt", "wt");
int i,j;

fprintf(F, "%d\n", R[N][0]);
j=0;
for (i=N; i; i--)
if (R[i][j] != R[i-1][j])
{
fprintf(F, "%d ", N+1-i);
j = (j + N - M[N+1-i]%N) % N;
}
fprintf(F, "\n");
fclose(F);
}

void main(void)
{
ReadData();
Share();
WriteSolution();
}
</syntaxhighlight>

== Problema 15 ==

Problema următoare a fost propusă la proba de baraj de la Olimpiada Națională de Informatică, Slatina 1995 și este un exemplu tipic de aplicare a principiului lui Dirichlet.

'''ENUNȚ''': La un SHOP din Slatina se găsesc spre vînzare P-1 (P este un număr prim) produse unicat de costuri '''''X'''''(1)$, '''''X'''''(2)$, ..., '''''X'''''('''''P'''''-1)$. Nici unul din produse nu poate fi cumpărat prin plata exactă cu bancnote de '''''P'''''$. în SHOP intră un olimpic care are un număr nelimitat de bancnote de '''''P'''''$ și o singură bancnotă de '''''Q'''''$ (1 ≤ '''''Q''''' ≤ '''''P'''''-1). Ce produse trebuie să cumpere olimpicul pentru a putea plăti exact produsele cumpărate?

'''Intrarea''': Datele de intrare se dau în fișierul de intrare <tt>INPUT.TXT</tt> ce conține două linii:

* pe prima linie valorile lui '''''P''''' și '''''Q''''';
* pe a doua linie valorile costurilor produselor.

Ieșirea se va face în fișierul <tt>OUTPUT.TXT</tt> unde se vor lista în ordine crescătoare indicii produselor cumpărate de olimpic.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>5 4 1 3 6 7</tt>
| <tt>1 2</tt>
|}

'''Timp de implementare''': la Slatina s-au acordat cam 90 de minute, dar 45 ar trebui să fie suficiente.

'''Timp de rulare pentru fiecare test''': 1 sec.

'''Complexitate cerută''': <math>O(P)</math>.

Enunțul original nu specifica nici o limită maximă pentru valoarea lui P. Vom adăuga noi această limită, respectiv '''''P''''' < 10000.

'''REZOLVARE''': Problema se reduce la a găsi un grup de obiecte pentru care suma costurilor să fie divizibilă cu '''''P''''' sau să fie congruentă cu '''''Q''''' modulo '''''P'''''. Am văzut deja în problema precedentă că dispunem de o soluție <math>O(N^2)</math> pentru a găsi un număr de elemente care să se dividă cu '''''P'''''. În cazul nostru, trebuie să observăm însă că nu avem '''''P''''' obiecte, ci numai '''''P'''''-1; în schimb, dispunem de o bancnotă suplimentară de valoare '''''Q'''''. Aceste diferențe vor fi explicate mai târziu și se va vedea că ele nu schimbă cu nimic natura problemei. Diferența esențială provine din faptul că nu se mai cere ca suma numerelor să fie maximă, ca în problema precedentă. Orice combinație de numere care dau o sumă potrivită este suficientă.

Să începem prin a explica principiul lui Dirichlet, care de altfel face apel numai la intuiție și nu necesită cunoștințe speciale de matematică. Acest principiu spune că dacă distribuim '''''N''''' obiecte în '''''K''''' cutii, atunci cel puțin într-o cutie se vor afla minim <math>\lceil N/K \rceil</math> obiecte (aici prin <math>\lceil N/K \rceil</math> se înțelege „cel mai mic întreg mai mare decât<ref>Greșeală în original. Corect: mai mare sau egal cu</ref> '''''N'''''/'''''K'''''”). Demonstrația se face prin reducere la absurd: dacă în fiecare cutie s-ar afla mai puțin decât <math>\lceil N/K \rceil</math> obiecte, atunci numărul total de obiecte ar fi mai mic decât <math>K \times \lceil N/K \rceil</math>, adică mai mic decât '''''N'''''.

Spre exemplu, oricum am distribui 7 obiecte în 4 cutii, putem fi siguri că cel puțin într-o cutie se vor afla minim <math>\lceil 7/4 \rceil = 2</math> obiecte. Într-adevăr, dacă toate cutiile ar conține cel mult câte un obiect, atunci numărul total de obiecte nu ar putea fi mai mare ca 4, ceea ce este absurd.

Să vedem acum cum s-ar putea aplica acest principiu la problema de față. Să facem notația

<math>S(k) = \sum_{i = 1}^{k} X(i)</math>

și convenția '''''S'''''(0) = 0. Prin urmare, putem scrie egalitatea

<math>S(k_2) - S(k_1) = \sum_{i = k_1}^{k_2} X(i)</math>

Dacă găsim în vectorul '''''S''''' două valori <math>S(k_1)</math> și <math>S(k_2)</math> care dau același rest la împărțirea prin '''''P''''', înseamnă că diferența lor se divide cu '''''P''''', deci șirul de obiecte <math>k_1+1, k_1+2, \dots, k_2</math> poate constitui o soluție.

Să presupunem pentru început că dispunem de '''''P''''' obiecte. Se pune întrebarea: ce valori poate lua restul împărțirii lui '''''S'''''('''''k''''') prin '''''P'''''? Desigur, orice valoare între 0 și '''''P'''''-1. Există deci în total '''''P''''' resturi distincte. Pe de altă parte, există '''''P'''''+1 elemente în vectorul '''''S''''' (se consideră și elementul '''''S'''''(0)). Începem să recunoaștem aici principiul lui Dirichlet, în care „obiectele” sunt resturile <math>S(0)\,\bmod\,P,\, S(1)\,\bmod\,P,\, \dots, S(P)\,\bmod\,P</math>, iar cutiile sunt clasele de resturi modulo '''''P'''''. Avem de distribuit P+1 obiecte în P cutii, așadar cel puțin într-o cutie se vor afla <math>\lceil (P+1)/P \rceil = 2</math> obiecte. Prin urmare, vor exista cu siguranță doi indici <math>k_1 < k_2</math> astfel încât <math>S(k_2) - S(k_1) \equiv 0 \pmod{P}</math>. Nu avem decât să tipărim secvența <math>k_1+1, k_1+2, ..., k_2</math>.

Să vedem acum ce se întâmplă dacă avem numai '''''P'''''-1 obiecte, așa cum este cazul problemei. Atunci avem numai '''''P''''' resturi posibile, deci se poate ca toate elementele din '''''S''''' să dea resturi distincte la împărțirea prin '''''P'''''. Dar în acest caz, există un indice '''''k''''' astfel încât <math>S(k) \equiv Q \pmod{N}</math>, deci trebuie doar să tipărim secvența de indici 1, 2, ..., '''''k'''''.

Pentru a reuni aceste două cazuri într-unul singur, putem considera expresia '''''S'''''('''''k''''') drept un alt mod de a scrie expresia '''''S'''''('''''k''''') - '''''S'''''(0). Problema se reduce la a căuta doi indici <math>k_1 , k_2 \in \{0, 1, 2, ..., P\}</math> astfel încât <math>(S(k_2) - S(k_1))\,\bmod\,N \in [0,Q]</math>. Să nu uităm că trebuie să efectuăm această operație într-un timp liniar, deci nu avem voie să comparăm pur și simplu două câte două elementele vectorului '''''S'''''. Vom prezenta modul în care se pot găsi două elemente congruente modulo '''''P''''', cazul celălalt tratându-se analog. Metoda constă în crearea unui alt vector, '''''L''''', în care '''''L'''''('''''i''''') = '''''j''''' înseamnă că suma '''''S'''''('''''j''''') dă restul '''''i''''' la împărțirea prin '''''P'''''. Inițial, toate elementele vectorului '''''L''''' vor avea o valoare specială, eventual negativă. Apoi se parcurge vectorul '''''S''''' și pentru fiecare '''''S'''''('''''j''''') se efectuează operația '''''L'''''('''''S'''''('''''j''''') mod '''''P''''')=j. În momentul în care se încearcă reatribuirea unui element din '''''L''''' care are deja o valoare dată, înseamnă că am găsit cei doi indici pe care îi căutam.

Iată un exemplu. Dacă '''''P'''''=7 și '''''X'''''=(8, 8, 2, 6, 13, 3), rezultă vectorul '''''S'''''=(8, 16, 18, 24, 37, 40). Resturile la împărțirea prin 7 sunt respectiv 1, 2, 4, 3, 2 și 5.

[[File:Psycho-fig69.png]]

După cum se vede, restul 2 poate fi obținut atât cu primele două obiecte, cât și cu primele 5, deci suma prețurilor obiectelor 3, 4 și 5 este divizibilă cu 7.

Un ultim detaliu de implementare constă în aceea că nu este necesară memorarea vectorului '''''S''''', ci numai a elementului curent; orice alte informații care ne trebuie la un moment dat le putem afla din vectorii '''''X''''' și '''''L'''''. Pentru memorarea elementului curent din '''''S''''', se pornește cu valoarea 0 și la fiecare pas se adaugă valoarea elementului corespunzător din '''''X'''''.

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 10000
#define None -1

int X[NMax], L[NMax], P, Q;

void ReadData(void)
{ FILE *F = fopen("input.txt", "rt");
int i;

fscanf(F, "%d %d\n", &P, &Q);
for (i=1; i<P; fscanf(F, "%d", &X[i++]));
fclose(F);
}

void FindSum(void)
{ long S=0;
FILE *F = fopen("output.txt", "wt");
int i,j;

for (i=1, L[0]=0; i<P; L[i++] = None);
i=0;
while ( L[ (S+=X[++i]) % P ]==None && // Restul 0
L[ (S%P+P-Q) % P ]==None ) // Restul Q
L[S%P]=i;
for (j = 1 + ((L[S%P]!=None)? L[S%P]: L[ (S%P+P-Q) % P ]);
j <= i; fprintf(F, "%d ", j++));
fclose(F);
}

void main(void)
{
ReadData();
FindSum();
}
</syntaxhighlight>

== Problema 16 ==

Următoarele probleme aparțin categoriei de probleme pe care, dacă ne grăbim, le putem clasifica drept „ușoare”. Într-adevăr, ele au soluții vizibile și foarte la îndemână, dar și soluții mai subtile și mult mai performante. Pentru a obliga cititorul să se gândească și la aceste soluții, am ales limite pentru datele de intrare suficient de mari încât să facă nepractice rezolvările „la minut”.

'''ENUNȚ''': (Generarea unui arbore oarecare când i se cunosc gradele) Se dă un vector cu '''''N''''' numere întregi. Se cere să se construiască un arbore cu '''''N''''' noduri numerotate de la 1 la '''''N''''' astfel încât gradele celor '''''N''''' noduri să fie exact numerele din vector. Dacă acest lucru nu este posibil, se va da un mesaj de eroare corespunzător.

'''Intrarea''': Datele de intrare se află în fișierul <tt>INPUT.TXT</tt>. Pe prima linie se află numărul de noduri '''''N''''' ('''''N''''' ≤ 10000), iar pe a doua linie se află cele '''''N''''' numere separate prin spații. Toate numerele sunt strict pozitive și mai mici ca 10000.

Ieșirea se va face în fișierul <tt>OUTPUT.TXT</tt>. Dacă problema are soluție, se va tipări arborele prin muchiile lui. Fiecare muchie se va lista pe câte o linie, prin nodurile adiacente separate printr-un spațiu. Dacă problema nu are soluție, se va afișa un mesaj corespunzător.

'''Exemple''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>6 1 2 3 2 1 1</tt>
| <tt>1 4 2 5 3 6 4 6 5 6</tt>
|-
| <tt>3 2 2 1</tt>
| <tt>Problema nu are solutie!</tt>
|}

'''Timp de implementare''': 30 minute - 45 minute.

'''Timp de rulare''': 2-3 secunde.

'''Complexitate cerută''': <math>O(N \log N)</math>; dacă vectorul citit la intrare se presupune sortat, se cere o complexitate <math>O(N)</math>.

'''REZOLVARE''': Să începem prin a ne pune întrebarea: când are problema soluție și când nu?

Se știe că un arbore oarecare cu '''''N''''' noduri are '''''N'''''-1 muchii. Fiecare din aceste muchii va contribui cu o unitate la gradele nodurilor adiacente. Deducem de aici că suma gradelor tuturor nodurilor este egală cu dublul numărului de muchii, adică, notând cu '''''G'''''[1], '''''G'''''[2], ..., '''''G'''''['''''N'''''] gradele nodurilor,

<math>\sum_{i = 1}^{N} G[i] = 2 \cdot (N - 1)</math>

Am aflat deci o condiție necesară pentru ca problema să aibă soluție. O a doua condiție este ca toate nodurile să aibă grade cuprinse între 1 și '''''N'''''-1. Totuși, ținând cont de afirmația enunțului că toate numerele din vector sunt strict pozitive, rezultă că a doua condiție nu mai trebuie verificată. Iată de ce: să presupunem că am verificat prima condiție și am constatat că suma celor '''''N''''' numere este 2('''''N'''''-1), iar unul dintre numere este cel puțin '''''N'''''. Atunci ar rezulta că suma celorlalte '''''N'''''-1 numere este cel mult '''''N'''''-2, de unde rezultă că există cel puțin un nod de grad 0, ceea ce contrazice informația din enunț. Prin urmare, numai prima condiție este importantă, cea de-a doua fiind redundantă.

Vom demonstra că această condiție este și suficientă indicând efectiv modul de construcție a arborelui în cazul în care ea este satisfăcută. Începem prin a sorta vectorul de numere. Acest lucru era oricum de așteptat, deoarece complexitatea <math>N \log N</math> ne-o permite. Trebuie numai să avem grijă să alegem un algoritm de sortare de complexitate <math>N \log N</math>. Programul care urmează folosește heapsort-ul. Odată ce am sortat vectorul, trebuie să reconstituim muchiile în timp liniar, și iată cum:

* Se poate demonstra că primele două elemente din vectorul sortat au valoarea 1. Într-adevăr, dacă toate elementele ar fi mai mari sau egale cu 2, atunci suma lor ar fi mai mare sau egală cu 2'''''N''''', ori noi știm că suma trebuie să fie 2'''''N'''''-2, adică există cel puțin două elemente egale cu 1 în vector. Acest lucru rezultă imediat dacă ne gândim că orice arbore are cel puțin două frunze.
* Vom căuta în vector primul număr mai mare sau egal cu 2. Se pune întrebarea: există întotdeauna acest număr? Nu cumva există un arbore în care toate nodurile au grad 1? Să aplicăm condiția precedentă și să vedem ce se întâmplă. Dacă toate nodurile au grad 1, atunci suma gradelor este '''''N''''', ceea ce conduce la ecuația:
:<math>N = 2 \cdot (N - 1) \implies N = 2</math>
* Iată deci că există un singur arbore în care toate nodurile sunt frunze, anume cel cu 2 noduri unite printr-o muchie. Vom reveni mai târziu la acest caz particular. Deocamdată presupunem că există în vector un număr mai mare ca 1, pe poziția '''''K''''' în vector. Atunci vom uni nodul 1 din arbore (care știm că are gradul 1) cu nodul '''''K'''''. În felul acesta, nodul 1 și-a completat numărul necesar de vecini și poate fi neglijat pe viitor, iar '''''G'''''['''''K'''''] va fi decrementat cu o unitate, întrucât nodul '''''K''''' și-a completat unul din vecini. Astfel, problema s-a redus la un arbore cu '''''N'''''-1 noduri numerotate de la 2 la '''''N'''''.
* Vectorul '''''G''''' este în continuare sortat, deoarece '''''G'''''['''''K'''''-1] = 1 < G['''''K'''''] ≤ '''''G'''''['''''K'''''+1] înainte de decrementarea lui '''''G'''''['''''K'''''], deci după decrementare vom avea '''''G'''''['''''K'''''-1] = 1 ≤ '''''G'''''['''''K'''''] < '''''G'''''['''''K'''''+1], adică dubla relație de ordonare se păstrează.
* Întrucât secvența '''''G'''''[2], '''''G'''''[3], ..., '''''G'''''['''''N'''''] reprezintă gradele unui arbore, putem aplica același raționament ca mai înainte pentru a deduce că '''''G'''''[2]=1. Cu ce nod vom uni nodul 2? Dacă '''''G'''''['''''K''''']>1, îl vom uni cu nodul '''''K'''''. Dacă prin decrementare, '''''G'''''['''''K'''''] a ajuns la valoarea 1, vom trece la nodul '''''K'''''+1 (despre care știm că are gradul mai mare ca 1) și vom trasa muchia 2 ↔ ('''''K'''''+1).
* Procedeul acesta se repetă până când au fost trasate '''''N'''''-2 muchii. Aceasta înseamnă că a mai rămas o singură muchie de trasat. Iată deci că, mai devreme sau mai târziu, este oricum inevitabil să ajungem la cazul particular de arbore de care am amintit mai devreme. Deoarece la primul pas am unit nodul 1 cu nodul '''''K''''', la al doilea pas am unit nodul 2 cu un alt nod ('''''K''''' sau '''''K'''''+1) ș.a.m.d., rezultă că în '''''N'''''-2 iterații, toate nodurile de la 1 la '''''N'''''-2 și-au completat numărul de vecini. De aici rezultă că ultima muchie pe care o vom trasa este ('''''N'''''-1) ↔ '''''N'''''; putem să tipărim această muchie „cu ochii închiși”, fără nici un fel de teste suplimentare. Ultima muchie trasată este diferită de celelalte și necesită o operație separată de trasare din cauză că, în timp ce primele '''''N'''''-2 iterații uneau o frunză cu un nod intern, această ultimă iterație are de unit două frunze, deci nu are sens să mai căutăm un nod de grad mai mare ca 1.

Aceasta este metoda de lucru. Calculul complexității este simplu: Avem nevoie doar de doi indici: Unul care marchează frunza curentă (în program el se numește pur și simplu <tt>i</tt>) și care avansează la fiecare pas, și unul care marchează primul număr mai mare ca 1 din vector (în program se numește <tt>First</tt>) și care se incrementează cu cel mult 1 la fiecare pas (deci de mai puțin de '''''N''''' ori în total). De aici rezultă complexitatea liniară a algoritmului.

Să vedem cum se comportă această metodă pe cazul particular al exemplului 1:

[[File:Psycho-fig70.png]]

Mai trebuie remarcat că soluția nu este unică. Propunem ca temă cititorului să scrie un program care să verifice în timp <math>O(N \log N)</math> dacă soluția furnizată de un alt program este corectă.

<syntaxhighlight lang="c">
#include <stdio.h>
int G[10001], N;
long Sum;
FILE *OutF;

void ReadData(void)
{ FILE *F=fopen("input.txt","rt");
int i;

fscanf(F,"%d\n",&N);
for (i=1, Sum=0; i<=N; i++)
{ fscanf(F,"%d",&G[i]);
Sum+=G[i];
}
fclose(F);
}

void Sift(int K, int N)
/* Cerne al K-lea element dintr-un heap de N elemente */
{ int Son;

/* Alege un fiu mai mare ca tatal */
if (K<<1<=N)
{ Son=K<<1;
if (K<<1<N && G[(K<<1)+1]>G[(K<<1)])
Son++;
if (G[Son]<=G[K]) Son=0;
}
else Son=0;
while (Son)
{ /* Schimba G[K] cu G[Son] */
G[K]=(G[K]^G[Son])^(G[Son]=G[K]);
K=Son;
/* Alege un alt fiu */
if (K<<1<=N)
{ Son=K<<1;
if (K<<1<N && G[(K<<1)+1]>G[(K<<1)])
Son++;
if (G[Son]<=G[K]) Son=0;
}
else Son=0;
}
}

void HeapSort(void)
{ int i;

/* Construieste heap-ul */
for (i=N>>1; i;) Sift(i--,N);
/* Sorteaza vectorul */
for (i=N; i>=2;)
{ G[1]=(G[1]^G[i])^(G[i]=G[1]);
Sift(1,--i);
}
}

void Match(void)
{ int i, First=1;

while (G[First]==1 && First<N) First++;
/* Trebuie adaugata si conditia First<N
pentru a acoperi cazul particular N=2 */
for (i=1; i<=N-2; i++)
{ fprintf(OutF,"%d %d\n", i, First);
First+=(--G[First]==1);
}
fprintf(OutF,"%d %d\n", N-1, N);
}

void main(void)
{
ReadData();
OutF=fopen("output.txt","wt");
if (Sum==(N-1)<<1)
{ HeapSort();
Match();
}
else fputs("Problema nu are solutie!\n",OutF);
fclose(OutF);
}
</syntaxhighlight>

== Problema 17 ==

Iată un nou exemplu de problemă care admite două rezolvări: una evidentă, dar neeficientă și una mai puțin evidentă dar cu mult mai eficientă.

'''ENUNȚ''': Fie '''''V''''' un vector. Arborele cartezian atașat vectorului '''''V''''' este un arbore binar care se obține astfel: Dacă vectorul '''''V''''' este vid (are 0 elemente), atunci arborele cartezian atașat lui este de asemenea vid. Altfel, se selectează elementul de valoare minimă din vector și se pune în rădăcina arborelui, iar arborii cartezieni atașați fragmentelor de vector din stânga (respectiv din dreapta) elementului minim se pun în subarborele stâng, respectiv drept al rădăcinii. Iată, de exemplu, care este arborele cartezian al următorului vector cu 8 elemente:

[[File:Psycho-fig71.png]]

În figură au fost încadrate prin dreptunghiuri punctate porțiunile din stânga, respectiv din dreapta elementului minim, împreună cu subarborii atașați. Trebuie observat că arborele cartezian atașat unui vector poate să nu fie unic, în cazul în care există mai multe elemente de valoare minimă. Vom impune ca o condiție suplimentară ca elementul care va fi trecut în rădăcină să fie cel mai din stânga dintre minime (cel cu indicele cel mai mic). Astfel, arborele cartezian este unic.

Cerința problemei este ca, dându-se un vector, să i se construiască arborele cartezian.

'''Intrarea''': Fișierul de intrare <tt>INPUT.TXT</tt> conține pe prima linie valoarea lui '''''N''''' ('''''N''''' ≤ 10000), iar pe a doua '''''N''''' numere naturale mai mici ca 30000, separate prin spații.

Ieșirea se va face în fișierul text <tt>OUTPUT.TXT</tt> sub următoarea formă:

<math>T_1 \quad T_2 \quad T_3 \quad \dots \quad T_N</math>

unde <math>T_i</math> este indicele în vector al elementului care este părintele lui '''''V'''''['''''i'''''] în arborele cartezian. Dacă '''''V'''''['''''i'''''] este rădăcina arborelui, atunci <math>T_i = 0</math>.

'''Exemplu''': Pentru exemplul dat mai sus, fișierul <tt>INPUT.TXT</tt> este:

<pre>
8
8 2 4 1 5 3 6 4
</pre>

După cum reiese din figură, tatăl elementului 8 este elementul 2, adică al doilea în vector; tatăl elementului 2 este elementul 1, adică al 4-lea în vector; tatăl elementului 5 este elementul 3, adică al 6-lea în vector ș.a.m.d. Fișierul de ieșire este deci:

<pre>
2 4 2 0 6 4 8 6
</pre>

'''Complexitate cerută''': <math>O(N)</math>.

'''Timp de implementare''': 45 minute - 1h.

'''Timp de rulare''': 2 secunde.

'''REZOLVARE''': Nu întâmplător s-a impus o complexitate liniară pentru rezolvarea acestei probleme. Altfel, ea ar fi trivială în <math>O(N^2)</math>, prin următoarea metodă: scriem o procedură care parcurge vectorul și caută minimul, apoi se reapelează pentru bucățile de vector aflate în stânga, respectiv în dreapta minimului. Pentru a demonstra că această variantă de rezolvare are complexitate pătratică, să ne imaginăm cum s-ar comporta ea pe cazul:

<math>V = (N \quad N-1 \quad N-2 \quad \dots \quad 2 \quad 1)</math>

La primul apel, procedura ar face '''''N''''' comparații pentru a parcurge vectorul (deoarece elementul minim este ultimul în vector) și s-ar reapela pentru porțiunea din vector care cuprinde primele '''''N'''''-1 elemente. La al doilea apel, ar face '''''N'''''-1 comparații și s-ar reapela pentru primele '''''N'''''-2 elemente etc. În concluzie, numărul total de comparații făcute este

<math>N + (N-1) + (N-2) + \cdots + 1 = \frac{N(N + 1)}{2}</math>

de unde rezultă complexitatea. O problemă interesantă, pe care îi vom lăsa plăcerea cititorului să o rezolve, este de a demonstra că această versiune '''nu poate atinge o complexitate mai bună decât <math>O(N \log N)</math>''' și de a arăta care sunt cazurile cele mai favorabile pe care se obține această complexitate.

A doua metodă este și ea destul de ușor de înțeles și de implementat. Ceea este mai greu de acceptat este că ea are complexitate liniară, așa cum vom încerca să explicăm la sfârșit. Iată mai întâi principiul de rezolvare: vom porni cu un arbore cartezian vid și, la fiecare pas, vom adăuga câte un element al vectorului '''''V''''' la acest arbore, astfel încât structura obținută să rămână un arbore cartezian. La al '''''k'''''-lea pas, vom adăuga elementul '''''V'''''['''''k'''''] în arbore și vom restructura arborele în așa fel încât să obținem arborele cartezian atașat primelor '''''k''''' elemente din '''''V'''''. Trebuie să ne concentrăm atenția asupra a două lucruri:

# Cunoscând arborele cartezian atașat primelor '''''k'''''-1 vârfuri și elementul '''''V'''''['''''k'''''], cum se obține arborele cartezian atașat primelor '''''k''''' vârfuri?
# Cum reușim să actualizăm de '''''N''''' ori arborele astfel încât timpul total consumat să fie liniar?

Pentru a răspunde la prima întrebare, pe lângă vectorii '''''V''''' și '''''T''''', mai este necesară o stivă '''''S''''', în care vom stoca elemente ale vectorului '''''V'''''. Inițial, stiva este vidă. Atunci când un nou element '''''X''''' sosește, el va fi introdus în stivă imediat după ultimul număr din stivă care are o valoare mai mică sau egală cu '''''X'''''. Toate elementele care se aflau înainte în stivă pe poziții mai mari sau egale cu poziția pe care a fost inserat '''''X''''' vor fi eliminate din stivă, iar elementul care se afla exact pe poziția lui '''''X''''' va deveni fiul stâng al lui '''''X'''''. '''''X''''' însuși va deveni fiul drept al predecesorului său în stivă. La fiecare moment, primul element din stivă este rădăcina arborelui cartezian.

Pentru a înțelege mai bine principiul de funcționare al stivei, să analizăm mai de aproape exemplul din enunț.

La început stiva este vidă. Primul element din V are valoarea 8, drept care îl vom pune în stivă, iar arborele cartezian va avea un singur nod:

[[File:Psycho-fig72.png]]

Următorul element sosit este 2. Acesta este mai mic decât 8, deci trebuie introdus înaintea lui în stivă. El va fi deci primul element din stivă și rădăcina arborelui cartezian la acest moment. Concomitent, 8 va fi eliminat din stivă și va deveni fiul stâng al lui 2:

[[File:Psycho-fig73.png]]

Se observă că arborele obținut este tocmai arborele cartezian atașat secvenței ('''''V'''''[1], '''''V'''''[2]). Următorul element este 4, care este mai mare decât 2, deci trebuie adăugat în vârful stivei. Nici un element nu este eliminat din stivă, iar 4 devine fiul drept al lui 2:

[[File:Psycho-fig74.png]]

Următorul element sosit este 1, care este mai mic decât toate numerele din stivă. Stiva se va goli, iar numărul 2 (cel peste care se va scrie 1) va deveni fiul stâng al lui 1:

[[File:Psycho-fig75.png]]

Deja arborele începe să semene cu forma sa finală. Urmează elementul 5, care va fi adăugat în stivă și „atârnat” în dreapta lui 1:

[[File:Psycho-fig76.png]]

Elementul 3 este mai mic<ref>Greșeală în original.</ref> ca 1, căruia îi va deveni fiu drept, dar mai mare<ref>Greșeală în original.</ref> ca 5, pe care îl va elimina din stivă:

[[File:Psycho-fig77.png]]

Următorul număr, 6, va fi adăugat la extremitatea dreaptă a arborelui și în vârful stivei:

[[File:Psycho-fig78.png]]

În sfârșit, elementul 4 va fi fiul drept al lui 3 și îl va elimina din stivă pe 6, care îi va deveni fiu stâng:

[[File:Psycho-fig79.png]]

Se observă că arborele a ajuns tocmai la forma sa corectă. Trebuie acum să ne ocupăm de un detaliu de implementare. Pentru a afla poziția pe care trebuie inserat un element în stivă avem două metode:

# Putem să căutăm în stivă de la dreapta la stânga (ar fi mai corect spus „de la vârf spre bază”) până dăm de un element mai mic decât cel de inserat; programul folosește această metodă și îi vom discuta în final eficiența.
# Putem face o căutare binară în stivă, întrucât elementele din stivă au valori crescătoare de la bază spre vârf (lăsăm demonstrația acestei afirmații în seama cititorului). O căutare binară într-un vector de '''''k''''' elemente poate necesita, în cazul cel mai nefavorabil, <math>\log k</math> comparații. În cazul cel mai nefavorabil, când vectorul '''''V''''' este sortat crescător, elementele vor fi introduse pe rând în stivă și nu vor mai fi scoase, deci la fiecare pas se vor face <math>\log k</math> comparații, unde '''''k''''' ia valori de la 1 la '''''N'''''. Complexitatea care rezultă este mai slabă decât cea cerută:

<math>
O(\log 1 + \log 2 + \cdots + \log N) = O(\sum_{k = 1}^{N} \log k) = O(\log \prod_{k = 1}^{N} k) = O(\log N!) = O(N \cdot \log N)
</math>

Acesta este unul din puținele cazuri în care căutarea binară este mai ineficientă decât cea secvențială.

Pentru ușurința programării, sursa C de mai jos reține în stiva '''''S''''' nu valorile elementelor, ci indicii lor în vectorul '''''V''''' (deoarece aceștia sunt ceruți pentru construcția vectorului '''''T''''').

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 10001

int V[NMax], /* Vectorul */
T[NMax], /* Vectorul de tati */
S[NMax], /* Stiva */
N; /* Numarul de elemente */

void ReadData(void)
{ FILE *F=fopen("input.txt","rt");
int i;

fscanf(F,"%d\n",&N);
for (i=1; i<=N;)
fscanf(F, "%d", &V[i++]);
}

void BuildTree(void)
{ int i,k,LenS=0;

S[0]=0; /* Pentru ca initial T[1] sa fie 0 */
for (i=1; i<=N; i++)
{ /* Cauta pozitia pe care va fi inserat V[i] */
k=LenS+1;
while (V[S[k-1]]>V[i]) k--;
/* Face corecturile in S si T */
T[i]=S[k-1];
if (k<=LenS) T[S[k]]=i;
/* i este ultimul element din stiva, deci... */
S[LenS=k]=i;
}
}

void WriteSolution(void)
{ FILE *F=fopen("output.txt","wt");
int i;
for (i=1; i<=N;)
fprintf(F,"%d ",T[i++]);
fprintf(F,"\n");
}

void main(void)
{
ReadData();
BuildTree();
WriteSolution();
}
</syntaxhighlight>

Acum să analizăm și complexitatea acestui algoritm. În primul rând, ea nu poate fi mai bună decât <math>O(N)</math>, pentru că aceasta este complexitatea funcțiilor de intrare și ieșire. Procedura <tt>BuildTree</tt> se compune dintr-un ciclu <tt>for</tt> în care se execută patru operații în timp constant și o instrucțiune repetitivă <tt>while</tt>. Numărul total de operații în timp constant care se execută în procedură este prin urmare <math>O(N)</math>. Problema este: care este numărul total maxim de evaluări ale condiției logice din bucla <tt>while</tt>? Aparent, bucla while se execută de <math>O(N)</math> ori, deci numărul total de evaluări ar fi <math>O(N^2)</math>. Să aruncăm totuși o privire mai atentă.

Fiecare evaluare a condiției din bucla <tt>while</tt> are ca efect decrementarea lui '''''k''''' și, implicit, eliminarea unui element deja existent în stivă. Pe de altă parte, fiecare element este introdus în stivă o singură dată și deci nu poate fi eliminat din stivă decât cel mult o dată. Așadar numărul maxim de elemente ce pot fi eliminate din stivă pe parcursul executării procedurii <tt>BuildTree</tt> este '''''N'''''-1, deci numărul total de evaluări ale condiției este <math>O(N)</math>. De aici rezultă că programul are complexitate liniară.

== Problema 18 ==

'''ENUNȚ''': Se dă un vector nesortat cu elemente numere reale oarecare. Considerând că vectorul ar fi sortat, se cere să se găsească distanța maximă între două elemente consecutive ale sale, fără însă a sorta efectiv vectorul.

'''Intrarea''': Fișierul <tt>INPUT.TXT</tt> conține pe prima linie numărul '''''N''''' de elemente din vector ('''''N''''' ≤ 5000). Pe următoare linie se dau numerele separate prin spații.

'''Ieșirea''': Pe ecran se va tipări un mesaj de forma:

Distanța maximă este D

'''Exemplu''': Pentru fișierul de intrare cu conținutul

<pre>
4
5 3.2 2 3.7
</pre>

răspunsul trebuie să fie

<pre>
Distanța maximă este 1.5
</pre>

'''Timp de implementare''': 30 minute.

'''Timp de rulare''': 2-3 secunde.

'''Complexitate cerută''': <math>O(N)</math>.

'''REZOLVARE''': Desigur că primul lucru la care ne gândim este să sortăm vectorul și să îl parcurgem apoi de la stânga la dreapta, căutând distanța maximă între două elemente consecutive. Complexitatea unui asemenea algoritm este <math>O(N \log N)</math>. Nici această soluție nu este rea, iar la un concurs, comisiei de corectare i-ar veni destul de greu să găsească teste care să departajeze un algoritm în <math>O(N \log N)</math> de unul liniar, chiar și pentru '''''N''''' = 5000. Totuși, vom arăta care este algoritmul liniar; în primul rând de dragul „artei”, iar în al doilea rând pentru că nu este cu mult mai greu de implementat decât o sortare.

Primul lucru care trebuie făcut este găsirea maximului și a minimului din vector; să notăm aceste valori cu <math>V_{\mathit{max}}</math> și <math>V_{\mathit{min}}</math>. Aceste operații se fac în timp liniar, eventual chiar la citirea datelor din fișier. Apoi se împarte intervalul <math>[V_{\mathit{max}}, V_{\mathit{min}}</math><ref>Greșeală în original.</ref> de pe axa reală în '''''N'''''-1 intervale egale. Iată cazul exemplului din enunț, unde <math>V_{\mathit{min}} = 2</math> și <math>V_{\mathit{max}} = 5</math>:

[[File:Psycho-fig80.png]]

Lungimea fiecărui interval va fi deci de

<math>
D = \frac{V_{\mathit{max}} - V_{\mathit{min}}}{N - 1} \quad
</math>
(în cazul nostru <math>D = 1</math>)

De ce s-a făcut această împărțire? Dacă notăm cu <math>D_{\mathit{max}}</math> distanța maximă pe axă între două numere vecine, adică tocmai valoarea pe care o căutăm, se poate demonstra că <math>D_{\mathit{max}} \geq D</math>. Într-adevăr, între cele '''''N''''' numere de pe axă se formează '''''N'''''-1 intervale. Dacă presupunem că <math>D_{\mathit{max}} < D</math>, rezultă că distanța între oricare două numere consecutive de pe axă este mai mică decât <math>D</math>. De aici deducem că distanța dintre primul și ultimul număr, adică , este mai mică decât de ('''''N'''''-1) ori <math>D</math>. Dar aceasta duce la relația:

<math>
V_{\mathit{max}} - V_{\mathit{min}} < (N - 1) \cdot \frac{V_{\mathit{max}} - V_{\mathit{min}}}{N - 1}
\implies
V_{\mathit{max}} - V_{\mathit{min}} < V_{\mathit{max}} - V_{\mathit{min}}
</math>,

relație care este absurdă; demonstrația afirmației <math>D_{\mathit{max}} \geq D</math> este completă.

Următorul pas pe care îl avem de făcut este să parcurgem încă o dată vectorul de numere și să aflăm pentru fiecare element căruia dintre intervalele de lungime îi aparține. Și această operație se poate face în <math>O(N)</math>. Convenim ca dacă un număr '''''X''''' se află exact la limita dintre două intervale, adică

<math>
X = V_{\mathit{min}} + k \cdot D, \quad 0 \leq k < N
</math>

el să fie considerat ca aparținând intervalului din dreapta. Aceasta înseamnă că elementul de valoare <math>V_{\mathit{max}}</math> nu aparține nici unuia din cele '''''N'''''-1 intervale, ci celui de-al '''''N'''''-lea interval, <math>[V_{\mathit{max}}, V_{\mathit{max}} + D]</math>. Să vedem la ce ne ajută acest lucru. Din moment ce <math>D_{\mathit{max}} \geq D</math>, rezultă că este imposibil ca distanța maximă să se producă între două numere din același interval, deoarece distanța în cadrul aceluiași interval nu poate atinge valoarea <math>D</math>. Este deci obligatoriu ca distanța maximă să apară între două elemente din intervale distincte. Să urmărim în figura următoare ce alte proprietăți mai au aceste numere:

[[File:Psycho-fig81.png]]

Dacă '''''X''''' și '''''Y''''' sunt valorile între care diferența este maximă, este de la sine înțeles că între ele nu mai există nici un număr, deoarece se prespune că '''''X''''' și '''''Y''''' sunt consecutive în vectorul sortat. Aceasta înseamnă însă că '''''X''''' este cel mai mare număr din intervalul său, iar numărul '''''X’''''' nu poate exista acolo unde a fost el figurat. Analog, '''''Y''''' este cel mai mic număr din intervalul său, iar numărul '''''Y’''''' nu poate exista. De fapt, în nici unul din intervalele dintre cele care le cuprind pe '''''X''''' și '''''Y''''' nu poate exista nici un număr.

Prin urmare, diferența maximă se poate produce numai între maximul unui interval și minimul imediat următor. Următorul pas în găsirea soluției presupune aflarea pentru fiecare din cele '''''N'''''-1 intervale (sau '''''N''''' dacă îl considerăm și pe ultimul, cel care nu îl conține decât pe <math>V_{\mathit{max}}</math>) a minimului și a maximului. Și acest pas se execută în <math>O(N)</math>, deoarece procesarea fiecărui element din vector se reduce la numai două comparări, cu minimul și cu maximul intervalului în care se încadrează el. Vor rezulta doi vectori care în program se vor numi '''''Lo''''' și '''''Hi'''''. Iată care sunt valorile lor pentru exemplul nostru:

[[File:Psycho-fig82.png]]

Deoarece în intervalul [4,5) nu se află elemente, rezultă că elementele corespunzătoare din vectorii '''''Lo''''' și '''''Hi''''' trebuie să aibă o valoare specială care să informeze programul asupra acestui lucru. De exemplu, sursa oferită mai jos folosește următorul artificiu: inițializează vectorul '''''Lo''''' cu valori foarte mari (<math>V_{\mathit{max}} + 1</math>), astfel încât orice număr „repartizat” într-un interval să modifice această valoare. Similar, vectorul '''''Hi''''' este inițializat cu <math>V_{\mathit{min}} - 1</math>. Dacă pentru un interval aceste valori se păstrează până la sfârșit, putem trage concluzia că în respectivul interval nu se află nici un număr.

În continuare, elementele vectorilor '''''Lo''''' și '''''Hi''''' se amestecă formând un nou vector '''''W''''' care de data aceasta este sortat. Sortarea este foarte ușoară, pentru că nu avem decât să așezăm numerele în ordinea '''''Lo'''''[1], '''''Hi'''''[1], '''''Lo'''''[2], '''''Hi'''''[2], ..., '''''Lo'''''['''''N'''''], Hi['''''N''''']. Deși la prima vedere pare că noul vector rezultat are 2'''''N''''' elemente, de fapt el are numai '''''N''''' elemente, pentru că:

* Dacă într-un interval '''''K''''' există un singur număr, (cazul intervalelor [2,3) și [5,6)) sau există numai numere egale, atunci '''''Lo'''''['''''K'''''] = '''''Hi'''''['''''K'''''] și este suficient să copiem în '''''W''''' una singură dintre aceste două valori;
* Dacă într-un interval nu există nici un număr, putem să nu copiem nici o valoare în vectorul '''''W'''''.

Astfel, construcția vectorului '''''W''''' se poate face în timp liniar, mai exact în <math>O(2N)</math>. Se observă că la această construcție se poate întâmpla ca unele numere să „dispară”, adică să nu fie trecute în vectorul '''''W'''''. De exemplu, dacă între numerele 3.2 și 3.7 ar mai fi existat un număr, 3.5, el nu ar fi fost nici minim, nici maxim pentru intervalul său, deci nu ar fi fost copiat. Totuși, trierea în acest fel a elementelor nu afectează în nici un fel soluția. În cazul nostru, nu se întâmplă să dispară nici un element, deci '''''W''''' = (2, 3.2, 3.7, 5).

După ce am construit vectorul '''''W''''', nu mai avem decât să-l parcurgem de la stânga la dreapta și să tipărim diferența maximă întâlnită între două numere consecutive (repetăm, vectorul '''''W''''' este sortat), această ultimă etapă necesitând și ea un timp liniar. Nu se poate obține o complexitate inferioară celei liniare, întrucât citirea datelor presupune ea însăși '''''N''''' operații.

Ca un detaliu de implementare, odată ce au fost construiți vectorii '''''Lo''''' și '''''Hi''''', vectorul '''''V''''' nu mai este necesar, deci putem construi chiar în el vectorul '''''W''''', pentru a economisi memorie.

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 5000
float V[NMax+1], Lo[NMax+1], Hi[NMax+1];
float Delta, Max, Min;
int N;

void ReadData(void)
/* Citeste vectorul si afla maximul si minimul */
{ FILE *F=fopen("input.txt", "rt");
int i;

fscanf(F, "%d\n", &N);
fscanf(F, "%f", &V[1]);
Max=Min=V[1];

for (i=2; i<=N; i++)
{
fscanf(F, "%f", &V[i]);
if (V[i]>Max) Max=V[i];
else if (V[i]<Min) Min=V[i];
}
fclose(F);
}

void Split(void)
{ int i, K;

Delta = (Max-Min)/(N-1);
/* Se initializeaza vectorii Lo si Hi */
for (i=0; i<=N; Lo[i]=Max+1, Hi[i++]=Min-1);

/* Se construiesc intervalele */
for (i=1; i<=N; i++)
{
K = (V[i]-Min)/Delta;
if (V[i]<Lo[K]) Lo[K]=V[i];
if (V[i]>Hi[K]) Hi[K]=V[i];
}
}

void Rebuild(void)
/* Rescrie vectorul V, pentru a economisi memorie,
pastrand numai capetele intervalelor */
{ int i, M=0;

for (i=0;i<N; i++)
{
if (Lo[i] != Max+1) V[++M]=Lo[i];
if (Hi[i] != Min-1 && Hi[i] != Lo[i]) V[++M]=Hi[i];
}
N=M;
}

void FindGap(void)
/* Acum cautarea distantei maxime se face
secvential, vectorul fiind sortat */
{ int i;
float Gap=0;

for (i=2; i<=N; i++)
if (V[i]-V[i-1] > Gap)
Gap = V[i]-V[i-1];
printf("Distanta maxima este %0.3f\n", Gap);
}

void main(void)
{
ReadData();
if (Max==Min)
puts("0");
else
{
Split();
Rebuild();
FindGap();
}
}
</syntaxhighlight>

File:Psycho-fig82.png

2018-03-11T09:32:51Z

Cata:

File:Psycho-fig81.png

2018-03-11T09:32:35Z

Cata:

File:Psycho-fig80.png

2018-03-11T09:32:19Z

Cata:

File:Psycho-fig79.png

2018-03-11T09:32:08Z

Cata:

File:Psycho-fig78.png

2018-03-11T09:31:55Z

Cata:

File:Psycho-fig77.png

2018-03-11T09:31:43Z

Cata:

File:Psycho-fig76.png

2018-03-11T09:31:20Z

Cata:

File:Psycho-fig75.png

2018-03-11T09:31:01Z

Cata:

File:Psycho-fig74.png

2018-03-11T09:30:47Z

Cata:

File:Psycho-fig73.png

2018-03-11T09:30:27Z

Cata:

File:Psycho-fig72.png

2018-03-11T09:30:15Z

Cata:

File:Psycho-fig71.png

2018-03-11T09:29:01Z

Cata:

File:Psycho-fig70.png

2018-03-11T09:28:42Z

Cata:

File:Psycho-fig69.png

2018-03-11T09:28:30Z

Cata:

File:Psycho-fig68.png

2018-03-11T09:28:15Z

Cata:

Psihologia concursurilor de informatică/6 Probleme de concurs 2

2018-03-09T14:38:01Z

Cata:

⇦ înapoi la [[Psihologia concursurilor de informatică]]

= Capitolul VI: Probleme de concurs (7-12) =

== Problema 7 ==

Problema programării unui turneu de fotbal a fost dată spre rezolvare la a III-a Balcaniadă de Informatică, Varna 1995. Vom prezenta mai întâi enunțul nemodificat al problemei, după care vom adăuga câteva detalii care o vor face mai „provocatoare”.

'''ENUNȚ''': Una din sarcinile Ministerului Sporturilor dintr-o țară balcanică este de a organiza un campionat de fotbal cu '''''N''''' echipe (numerotate de la 1 la '''''N'''''). Campionatul constă din '''''N''''' etape (dacă '''''N''''' este impar) sau '''''N'''''-1 etape (dacă '''''N''''' este par); orice două echipe dispută între ele un joc și numai unul. Scrieți un program care realizează o programare a campionatului.

'''Intrarea''': Numărul de echipe '''''N''''' (2 ≤ '''''N''''' ≤ 24) va fi dat la intrarea standard (tastatură).

'''Ieșirea''' se va face în fișierul text <tt>OUTPUT.TXT</tt> sub forma unui tabel cu numere întregi avînd '''''N''''' linii. Al '''''j'''''-lea element din linia '''''i''''' este numărul echipei care joacă cu echipa '''''i''''' în etapa '''''j''''' (evident, dacă '''''i''''' joacă cu '''''k''''' în etapa '''''j''''', atunci în tabel '''''k''''' joacă cu '''''i''''' în aceeași etapă). Dacă echipa '''''i''''' este liberă în etapa '''''j''''', atunci al '''''j'''''-lea element al liniei '''''i''''' este zero.

'''Exemple''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>3</tt>
| <tt>2 3 0 
1 0 3 
0 1 2</tt>
|-
| <tt>4</tt>
| <tt>2 3 4 
1 4 3 
4 1 2 
3 2 1</tt>
|}

'''Timp de implementare''': circa 1h 45’

'''Timp de execuție''': 33 secunde

Iată și modificările pe care le propunem pentru a aduce cu adevărat problema la nivel de concurs:

* Limita pentru numărul de echipe este '''''N''''' ≤ 200;
* '''Timpul de implementare''' este de 45 minute;
* '''Timpul de execuție''' este de 2-3 secunde;
* '''Complexitatea cerută''' este <math>O(N^2)</math>.

'''REZOLVARE''': Vom lăsa pe seama cititorului conceperea, implementarea și testarea unei rezolvări backtracking (adoptată de majoritatea în timpul concursului). De altfel, la Balcaniadă concurenții au avut la dispoziție calculatoare 486 / 50 Mhz, iar un backtracking îngrijit funcționa cam până la '''''N''''' = 18 în timpul impus, ceea ce asigura cam 75% din punctajul maxim. În afară de aceasta, se mai puteau face și alte lucruri nu tocmai elegante, având în vedere că datele de ieșire nu erau foarte mari. Pentru '''''N'''''>18, mulți concurenți lăsau programul să meargă până când termina (câteva minute bune sau chiar mai mult), apoi scriau rezultatele într-un fișier temporar. Matricea rezultată era inclusă ca o constantă în codul sursă. Programul care era dat comisiei de corectare se prefăcea că „se gândește” timp de câteva secunde, apoi scria pur și simplu matricea în fișierul de ieșire. Cu aceasta s-au luat punctaje foarte apropiate de maxim. Totuși, pentru '''''N'''''=24 un backtracking ar fi stat foarte mult pentru a găsi soluția. Tot timpul acesta, calculatorul era blocat, neputând fi folosit. De aceea, mulți concurenți nu au luat punctajul maxim, preferând să renunțe la ultimele teste și să rezolve celelalte probleme. Oricum, backtracking-ul este în acest caz o soluție pentru care raportul punctaj obținut / timp consumat este foarte convenabil.

Există însă și o soluție care poate asigura un punctaj maxim fără bătăi de cap și fără să folosească „date preprocesate”. Ea are complexitatea <math>O(N^2)</math> și nu face decât o singură parcurgere a matricei de ieșire. Ce-i drept, autorul a pierdut cam trei ore pentru a o găsi și implementa în timp de concurs, compromițând aproape rezolvarea celorlalte două probleme din ziua respectivă, dar comisia de corectare a fost plăcut impresionată, programul fiind singurul care mergea instantaneu. Rămâne ca voi să alegeți între eleganță și eficiență...

Dacă ținem cont și de restricțiile suplimentare propuse, rezolvarea backtracking nu mai este valabilă. În această situație, iată care este metoda care stă la baza rezolvării în timp pătratic. În primul rând se reduce cazul când '''''N''''' este impar la un caz când '''''N''''' este par, prin mărirea cu 1 a lui '''''N''''' și introducerea unei echipe fictive. În fiecare etapă se consideră că echipa care trebuia să joace cu echipa fictivă stă de fapt „pe bară”. Iată de exemplu cum se rezolvă cazul '''''N'''''=3:

a) Se programează un campionat cu 4 echipe, echipa 4 fiind echipa fictivă:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3
|-
| '''1''' || 2 || 3 || 4
|-
| '''2''' || 1 || 4 || 3
|-
| '''3''' || 4 || 1 || 2
|-
| '''4''' || 3 || 2 || 1
|}

b) Se neglijează ultima linie din tabel, meciurile echipei fictive nefiind importante:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3
|-
| '''1''' || 2 || 3 || 4
|-
| '''2''' || 1 || 4 || 3
|-
| '''3''' || 4 || 1 || 2
|}

c) Peste tot unde apare cifra 4, ea este înlocuită cu 0:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3
|-
| '''1''' || 2 || 3 || 0
|-
| '''2''' || 1 || 0 || 3
|-
| '''3''' || 0 || 1 || 2
|}

Mai rămâne să vedem cum se tratează cazul când '''''N''''' este par. E destul de greu de dat o demonstrație matematică metodei care urmează; de fapt, nici nu există una, problema fiind rezolvată în timp de concurs prin inducție incompletă (adică s-a constatat cu creionul pe hârtie că metoda merge pentru '''''N'''''=4, 6, 8 și 10, apoi s-a scris programul care să facă același lucru și s-a constatat că merge și pentru valori mai mari). Să tratăm și aici cazul '''''N'''''=8, apoi să generalizăm procedeul.

Vor fi șapte etape și, fără a reduce cu nimic generalitatea problemei, putem presupune că echipa 1 joacă pe rând cu echipele 2, 3, 4, 5, 6, 7 și 8. Deocamdată tabelul arată astfel:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3 || Etapa 4 || Etapa 5 || Etapa 6 || Etapa 7
|-
| '''1''' || 2 || 3 || 4 || 5 || 6 || 7 || 8
|-
| '''2''' || 1 || || || || || ||
|-
| '''3''' || || 1 || || || || ||
|-
| '''4''' || || || 1 || || || ||
|-
| '''5''' || || || || 1 || || ||
|-
| '''6''' || || || || || 1 || ||
|-
| '''7''' || || || || || || 1 ||
|-
| '''8''' || || || || || || || 1
|}

Echipa 2 are deja programat un meci cu echipa 1 în prima etapă și mai are de programat meciurile cu echipele 3, 4, 5, 6, 7 și 8 în celelalte etape. Așezarea se poate face oricum, cu condiția ca echipele 1 și 2 să nu își aleagă același partener în aceeași etapă. De exemplu, putem programa meciul 2-3 în etapa a 3-a, meciul 2-4 în etapa a 4-a, ..., iar meciul 2-8 în etapa a 2-a. Astfel am completat linia a doua a tabloului:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3 || Etapa 4 || Etapa 5 || Etapa 6 || Etapa 7
|-
| '''1''' || 2 || 3 || 4 || 5 || 6 || 7 || 8
|-
| '''2''' || 1 || 8 || 3 || 4 || 5 || 6 || 7
|-
| '''3''' || || 1 || 2 || || || ||
|-
| '''4''' || || || 1 || 2 || || ||
|-
| '''5''' || || || || 1 || 2 || ||
|-
| '''6''' || || || || || 1 || 2 ||
|-
| '''7''' || || || || || || 1 || 2
|-
| '''8''' || || 2 || || || || || 1
|}

Echipa 3 are programate meciurile cu 1 și 2 și mai are de programat meciurile cu echipele 4, 5, 6, 7 și 8. Pentru a nu crea conflicte (adică două echipe să nu-și aleagă același adversar), putem aplica același procedeu: pornim de la etapa a 5-a și completăm toate celulele goale ale liniei a 3-a cu numerele de la 4 la 8, mergând circular spre dreapta:

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3 || Etapa 4 || Etapa 5 || Etapa 6 || Etapa 7
|-
| '''1''' || 2 || 3 || 4 || 5 || 6 || 7 || 8
|-
| '''2''' || 1 || 8 || 3 || 4 || 5 || 6 || 7
|-
| '''3''' || 7 || 1 || 2 || 8 || 4 || 5 || 6
|-
| '''4''' || || || 1 || 2 || 3 || ||
|-
| '''5''' || || || || 1 || 2 || 3 ||
|-
| '''6''' || || || || || 1 || 2 || 3
|-
| '''7''' || 3 || || || || || 1 || 2
|-
| '''8''' || || 2 || || 3 || || || 1
|}

Se folosește aceeași metodă pentru a completa și celelalte linii ale matricei. Pentru fiecare linie '''''i''''' ('''''i''''' ≤ '''''N'''''-1):

* Se caută pe linia '''''i''''' apariția valorii '''''i'''''-1;
* Se caută primul spațiu liber (mergând circular spre dreapta). Primul spațiu liber înseamnă prima etapă în care se poate programa meciul dintre echipele '''''i''''' și '''''i'''''+1 (trebuie ca ambele să fie libere în acea etapă). Se constată experimental că trebuie început de la a doua poziție liberă de după apariția valorii '''''i'''''-1;
* Se merge circular spre dreapta și, în căsuțele libere întâlnite se trec valorile '''''i'''''+1, '''''i'''''+2, ..., '''''N'''''. Concomitent, pe aceleași coloane ale liniilor '''''i'''''+1, '''''i'''''+2, ..., '''''N''''' se trece valoarea '''''i'''''.

{|class="wikitable"
! Echipa || Etapa 1 || Etapa 2 || Etapa 3 || Etapa 4 || Etapa 5 || Etapa 6 || Etapa 7
|-
| '''1''' || 2 || 3 || 4 || 5 || 6 || 7 || 8
|-
| '''2''' || 1 || 8 || 3 || 4 || 5 || 6 || 7
|-
| '''3''' || 7 || 1 || 2 || 8 || 4 || 5 || 6
|-
| '''4''' || 6 || 7 || 1 || 2 || 3 || 8 || 5
|-
| '''5''' || 8 || 6 || 7 || 1 || 2 || 3 || 4
|-
| '''6''' || 4 || 5 || 8 || 7 || 1 || 2 || 3
|-
| '''7''' || 3 || 4 || 5 || 6 || 8 || 1 || 2
|-
| '''8''' || 5 || 2 || 6 || 3 || 7 || 4 || 1
|}

Fiecare linie a matricei poate fi parcursă in acest fel de maxim 2 ori (o dată pentru găsirea coloanei de start și o dată pentru completarea liniei), deci numărul total de celule vizitate este cel mult <math>2 \times N^2</math>. Complexitatea pătratică este cea optimă, deoarece programul trebuie în orice caz să tipărească la ieșire circa <math>N^2</math> numere.

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 200
unsigned char A[NMax+1][NMax+1];
int N,RealN;

void FindNextFree(int Line,int *K)
/* Cauta (circular) urmatorul spatiu liber pe linia Line */
{ do *K=*K%(N-1)+1;
while (A[Line][*K]);
}

void MakeMatrix(void)
{ int i,j,k;

for (i=1;i<=N;i++)
for (j=1;j<=N;j++) A[i][j]=0;
for (i=1;i<N;i++) /* Pentru fiecare echipa */
{ if (i==1) /* Alege coloana de start */
j=1;
else { j=0;
do j++; while (A[i][j]!=i-1);
FindNextFree(i,&j);
FindNextFree(i,&j);
}
for (k=i+1;k<=N;k++) /* Completeaza circular linia */
{ A[i][j]=k;
A[k][j]=i;
if (k<N) FindNextFree(i,&j);
}
}
}

void WriteMatrix(void)
{ int i,j;
FILE *F=fopen("output.txt","wt");

for (i=1;i<=RealN;i++)
{ for (j=1;j<N;j++)
fprintf(F,"%4d",A[i][j]>RealN ? 0 : A[i][j]);
fprintf(F,"\n");
}
fclose(F);
}

void main(void)
{
printf("N=");scanf("%d",&RealN);
N=RealN+RealN%2; /* Se adauga 1 daca RealN e impar */
MakeMatrix();
WriteMatrix();
}
</syntaxhighlight>

== Problema 8 ==

Problema '''codului lui Pruffer'''<ref>Greșeală în original, corect: Prüfer</ref> pentru arborii generali, mai exact cea a decodificării acestui cod, este genul de problemă care nu este excesiv de grea, dar care necesită un artificiu fără de care nu se poate ajunge la complexitatea optimă.

'''ENUNȚ''': Un arbore general neorientat conex cu '''''N'''''+2 vârfuri se poate codifica eficient printr-un vector cu '''''N''''' numere, astfel:

* Numerotăm nodurile de la 1 la '''''N'''''+2 într-o ordine oarecare;
* Eliminăm cea mai mică frunză (nod de grad 1) și adăugăm în vector numărul nodului de care ea aparținea;
* Reluăm procedeul pentru arborele rămas: tăiem cea mai mică frunză și adăugăm în vector numărul nodului de care ea aparținea;
* Repetăm procedeul până mai rămân doar două noduri.

Vectorul rezultat se numește codificare Pruffer a arborelui dat. Iată un exemplu de construcție a codului Pruffer atașat arborelui din figura de mai jos:

[[File:Psycho-fig64.png]]

Codul lui Pruffer se obține astfel:

* Îl tăiem pe 3 și scriem 1;
* Îl tăiem pe 4 și scriem 5;
* Îl tăiem pe 6 și scriem 2;
* Îl tăiem pe 2 și scriem 5;
* Îl tăiem pe 5 și scriem 1;

Deci codificarea este (1, 5, 2, 5, 1) (și mai rămâne muchia 1-7, lucru care este evident, deoarece 1 și 7 sunt singurele noduri care nu au fost tăiate).

Așadar fiecărui arbore oarecare cu '''''N'''''+2 noduri i se poate atașa un vector cu '''''N''''' componente numere naturale cuprinse între 1 și '''''N'''''+2. Se poate demonstra că funcția definită între cele două mulțimi (mulțimea arborilor și mulțimea vectorilor) este bijectivă. De aici rezultă două lucruri:

# Există <math>(N+2)^N</math> arbori generali cu '''''N'''''+2 noduri.
# Codificarea Pruffer admite și decodificare (deoarece funcția de codificare este bijectivă). Tocmai aceasta este problema de rezolvat. Se dă un vector de '''''N''''' numere întregi, fiecare cuprins între 1 și '''''N'''''+2. Se cere să se tipărească cele '''''N'''''+1 muchii ale arborelui decodificat.

'''Intrarea''' se face din fișierul text <tt>INPUT.TXT</tt> care conține două linii. Pe prima linie se dă '''''N''''' (1 ≤ '''''N''''' ≤ 10000), pe a doua cele '''''N''''' numere separate prin spații.

'''Ieșirea''' se va face în fișierul text <tt>OUTPUT.TXT</tt>. Acesta va conține muchiile arborelui, câte una pe linie, o muchie fiind indicată prin vârfurile adiacente separate printr-un spațiu.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>5 1 5 2 5 1</tt>
| <tt>5 2 
1 3 
4 5 
7 1 
6 2 
1 5</tt>
|}

'''Timp de implementare''': 45 minute.

'''Timp de rulare''': 2-3 secunde.

'''Complexitate cerută''': <math>O(N)</math>.

'''REZOLVARE''': Să pornim de la exemplul particular prezentat mai sus, urmând ca apoi să generalizăm algoritmul.

Primim la intrare '''''N'''''=5 (deducem că arborele are 7 noduri) și codificarea (1, 5, 2, 5, 1). Primul element din vector este 1. Știm deci că, la primul pas, a fost eliminată o frunză al cărei părinte este nodul 1. Întrebarea este: ce număr purta respectiva frunză? În nici un caz 1, deoarece numărul 1 îl avea tatăl ei. Nici 2, nici 5 nu ar putea fi, deoarece aceste numere apar mai târziu în codificare, deci „mai este nevoie” de ele și nu pot fi încă eliminate. Rămân 3, 4, 6 și 7. Dintre acestea noi știm că a fost tăiată cea mai mică frunză. Este însă ușor de văzut că toate nodurile enumerate sunt frunze în arborele inițial (deoarece nu mai apar în vector, adică nici un alt nod nu mai este legat de ele), deci îl vom alege pe cel mai mic cu putință, adică pe 3. Rezultă că prima muchie tăiată a fost (1,3).

Pe poziția a doua în codificare apare numărul 5. Ce număr ar putea avea frunza tăiată? 1 și 2 mai apar ulterior în codificare deci nu pot fi eliminate încă, 5 este chiar tatăl frunzei necunoscute, iar 3 a fost deja eliminat. Dintre 4, 6 și 7, frunza cu numărul cel mai mic este 4, deci următoarea muchie tăiată este (4,5).

În continuare apare un 2. Cel mai mic nod care nu mai apare în vector și nici nu a fost deja eliminat este 6, deci muchia este (6,2). Se observă că mai departe nu mai apare nici un 2 în codificare, de unde deducem că după tăierea nodului 6, nodul 2 a devenit frunză și va putea fi la rândul său eliminat. Cu un raționament analog, următoarele muchii eliminate sunt (2,5) și (5,1), iar singurele noduri rămase sunt 1 și 7. Arborele a fost reconstituit corect.

Deci procedeul general este: pentru fiecare număr dintre cele '''''N''''' din vector, nodul care aparținea de el poartă cel mai mic număr care nu intervine ulterior în codificare și nu a fost tăiat deja. Astfel se generează '''''N''''' muchii. A '''''N'''''+1-a muchie are drept capete ultimele noduri rămase netăiate.

Acesta este algoritmul. Trebuie să ne ocupăm acum de partea de implementare.

Pentru a testa la orice moment dacă un nod mai apare sau nu în vector, este bine să se creeze la citirea datelor un vector care să rețină numărul de apariții în codificare al fiecărui nod. Pentru exemplul dat, vectorul de apariții va fi '''''Apar'''''=(2,1,0,0,2,0,0), semnificând că 1 și 5 apar de câte două ori, 2 apare o singură dată, iar 3, 4, 6 și 7 nu apar deloc. La fiecare pas, când se „restaurează” o muchie, se decrementează poziția corespunzătoare tatălui în vectorul de apariții. Un număr nu mai apare ulterior în codificare dacă pe poziția sa din vectorul de apariții se află un 0.

Astfel, o primă versiune de program ar putea fi:

<pre>
intrare: N, V[1..N].
construieste vectorul Apar[1..N+2]
pentru i de la 1 la N:
cauta primul j pentru care Apar[j]=0 si j nu a fost taiat;
scrie muchia (j,V[i]);
Apar[j] = Apar[j]-1;
marcheaza nodul j ca fiind taiat.
</pre>

După cum se observă, căutarea celui mai mic nod j se face în timp liniar, ceea ce înseamnă că algoritmul complet va necesita un timp pătratic. Pentru a-l reduce la o complexitate liniară, începem prin a observa că la fiecare pas alegem frunza cu numărul cel mai mic. Aceasta înseamnă că, în general, numărul frunzei alese spre a fi tăiată va crește la fiecare pas. Astfel, prima oară am tăiat nodul 4, apoi nodul 7. Singurul caz când va fi tăiată o frunză mai mică decât cea dinaintea ei este atunci când unui nod cu număr mic i se taie toate frunzele și devine el însuși o frunză, putănd fi tăiat. În exemplul nostru, nodul 2 nu putea fi eliminat de la început, deși avea un număr mic, deoarece mai avea atașată frunza 6. După eliminarea muchiei (6,2), nodul 2 a devenit frunză și a fost eliminat imediat.

Putem deci păstra într-o variabilă (care în program se numește '''''Next''''') următoarea frunză care care trebuie eliminată. Dacă prin decrementarea numărului de apariții la pasul curent nu s-a creat nici un zero în vectorul '''''Apar''''', sau s-a creat un zero, dar pe o poziție '''''K'''''>'''''Next''''', atunci totul este bine și la pasul următor se va elimina nodul '''''Next'''''. Dacă s-a creat un zero pe o poziție '''''K''''' mai mică decât '''''Next''''', rezultă că în arbore există acum două frunze, '''''K''''' și '''''Next''''', '''''K''''' fiind mai mică, deci prioritară. Atunci la pasul următor se va elimina frunza de pe poziția '''''K''''', urmând ca peste doi pași să se revină la frunza '''''Next'''''. Dacă prin eliminarea acestei frunze '''''K''''' s-a creat un alt zero în vectorul de apariții, tot pe o poziție '''''K’''''' mai mică decât Next, se va trece mai întâi la acea poziție, urmând ca după aceea să se revină la poziția '''''Next''''' etc.

La prima vedere, pare necesară menținerea unei stive în care să depunem numerele '''''Next, K, K’'''''... și să le scoatem din stivă pe măsură ce nodurile respective sunt eliminate. Acest lucru ar presupune în continuare un algoritm pătratic. Totuși nu este așa deoarece, odată ce am tăiat un nod și l-am marcat ca atare, putem fi siguri că nu ne vom mai intâlni cu el până la sfârșitul decodificării, deci nu mai este necesară stocarea lui. Există o pseudo-stivă care are înălțimea 2: frunza asupra căreia se operează curent și nodul care urmează, '''''Next'''''.

În acest fel, numărul total de incrementări al variabilei '''''Next''''' nu depășește '''''N''''' (iar ea nu este niciodată decrementată), deci programul este rezolvat în timp liniar. Facem observația că algoritmul <math>O(N)</math> este optim; nu poate exista unul mai bun deoarece există <math>O(N)</math> muchii care trebuie tipărite.

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 10002
typedef int Vector[NMax];

Vector V,Apar;
int N;

void ReadData(void)
{ int i;
FILE *InF=fopen("input.txt","rt");

fscanf(InF,"%d",&N);
for (i=1;i<=N+2;Apar[i++]=0);
for (i=1;i<=N;i++)
{ fscanf(InF,"%d",&V[i]);
Apar[V[i]]++;
}
fclose(InF);
}

void Decode(void)
{ int Current=0,Next,i;
FILE *OutF=fopen("output.txt","wt");

do; while (Apar[++Current]); /* Se cauta prima frunza */
Next=Current;
for (i=1;i<=N;i++)
{ fprintf(OutF,"%d %d\n",Current,V[i]);
if (Current==Next) do; while (Apar[++Next]);
/* Daca am ajuns la ultimul 0, mai caut unul */
Apar[V[i]]--;
Current=(V[i]<Next) && (Apar[V[i]]==0) ? V[i] : Next;
/* Daca exista o frunza mai mica decat Next, */
/* ea este prioritara, altfel revin la Next */
}
fprintf(OutF,"%d %d\n",Current,Next);
fclose(OutF);
}

void main(void)
{
ReadData();
Decode();
}
</syntaxhighlight>

== Problema 9 ==

Iată o problemă care necesită pentru reducerea complexității un artificiu asemănător celui din problema codului Pruffer. Ea a fost propusă în 1995 la concursul de selecție a echipelor României pentru IOI și CEOI. Deși cerința este puțin modificată pentru a nu ne izbi de dificultăți secundare, ideea generală de abordare este aceeași.

'''ENUNȚ''': Președintele companiei X dorește să organizeze o petrecere cu angajații. Această companie are o structură ierarhică în formă de arbore. Fiecare angajat are asociat un număr întreg reprezentând măsura sociabilității sale. Pentru ca petrecerea să fie agreabilă pentru toți participanții, președintele dorește să facă invitațiile astfel încât:

* el însuși să participe la petrecere;
* pentru nici un participant la petrecere să nu fie invitat și șeful lui direct;
* suma măsurilor sociabilităților invitaților să fie maximă.

Se cere să se spună care este suma maximă a sociabilităților care se poate obține.

'''''Intrarea''''' se face din fișierul <tt>INPUT.TXT</tt> care conține trei linii de forma:

<pre>
N
T(1) T(2) ... T(N)
S(1) S(2) ... S(N)
</pre>

unde '''''N''''' este numărul de angajați ai companiei, inclusiv președintele ('''''N''''' ≤ 1000), '''''T'''''('''''k''''') este numărul de ordine al șefului direct al lui '''''k''''' (dacă '''''T'''''('''''k''''') = 0, atunci '''''k''''' este președintele), iar '''''S'''''('''''k''''') este măsura sociabilității lui '''''k'''''. Valorile vectorului '''''S''''' sunt de tipul întreg.

'''Ieșirea''': Pe ecran se va tipări suma maximă a sociabilităților ce se poate obține.

'''Exemplu''': Pentru intrarea:

<pre>
7
2 5 2 5 0 4 2
2 5 3 13 8 4 3
</pre>

pe ecran se va afișa numărul 20 (fiindcă la petrecere participă 1, 3, 5, 6 și 7).

'''Timp de implementare''': 1h - 1h 15’.

'''Timp de rulare''': 2-3 secunde.

'''Complexitate cerută''': <math>O(N)</math>. De asemenea, menționăm că s-a specificat '''''N''''' ≤ 1000 numai pentru ca programul sursă de mai jos să nu se complice și să distragă atenția asupra unor lucruri neimportante. În mod normal, limita trebuia să fie '''''N''''' ≤ 10000.

'''REZOLVARE''': Vom expune mai întâi principiul de rezolvare al problemei, apoi vom aborda detaliile de implementare.

Algoritmul are la bază programarea dinamică și necesită o parcurgere de jos în sus a arborelui, decizia pentru fiecare nod depinzând de valorile tuturor fiilor lui. Ne propunem să aflăm două caracteristici pentru fiecare nod '''''k''''':

* P(k) - suma maximă a sociabilităților care se poate obține în subarborele de rădăcină '''''k''''' în cazul în care '''''k''''' participă la petrecere;
* Q(k) - suma maximă a sociabilităților care se poate obține în subarborele de rădăcină '''''k''''' în cazul în care '''''k''''' nu participă la petrecere;

Dacă reușim să determinăm aceste caracteristici, nu ne rămâne decât să-l tipărim pe '''''P'''''('''''R''''') ('''''R''''' fiind rădăcina arborelui). Într-adevăr, problema cere să se determine suma maximă a sociabilităților din întregul arbore, adică din subarborele de rădăcină '''''R'''''. În plus, se mai cere ca '''''R''''' să participe la petrecere. Rămâne de aflat cum se stabilește relația între caracteristicile unui nod și cele ale fiilor săi.

* Dacă angajatul '''''k''''' participă la petrecere, atunci automat nici unul din subordonații săi direcți nu participă, și obținem relația:
: <math>P(k) = S(k) + \sum_j Q(j)</math>, '''''j''''' fiu al lui '''''k'''''
* Dacă angajatul '''''k''''' nu participă la petrecere, atunci subordonații săi direcți pot să participe sau nu la petrecere, după cum este mai avantajos, și obținem relația:
: <math>Q(k) = \sum_j \max\{P(j), Q(j)\}</math>, '''''j''''' fiu al lui '''''k'''''

Problema care se pune acum este cum să facem parcurgerea arborelui într-un mod cât mai avantajos. Pseudocodul (recursiv) sub forma sa cea mai generală este:

<pre>
procedura Calcul(k, P, Q)
P ← S(k), Q ← 0
pentru fiecare fiu j al lui k:
Calcul(j, P1, Q1)
P ← P + Q1
Q ← Q + max (P1, Q1)
intoarce P,Q
</pre>

Soluția „de bun simț” este de a construi arborele alocat dinamic. Ar apărea însă o sumedenie de dificultăți. În primul rând, arborele este general, deci nu se cunoaște numărul maxim de fii pe care îi poate avea un nod (pe cazul cel mai defavorabil, rădăcina poate avea '''''N'''''-1 fii). Aceasta înseamnă că legătura trebuie să fie de tip tata (fiecare nod pointează la tatăl său), ceea ce complică procedura de parcurgere: nu se poate apela procedura recursiv, dintr-un nod pentru toți fiii săi, deoarece nu se cunosc fiii, ci numai tatăl! O altă modalitate de alocare a arborelui ar fi cu doi pointeri pentru fiecare nod: unul către primul său fiu și unul către fratele său din dreapta (exemplul din enunț are reprezentate grafic mai jos cele două metode de construcție).

[[File:Psycho-fig65.png]]

Probabil că veți fi de acord cu mine că e riscant să te aventurezi la o asemenea implementare în timp de concurs, deoarece lucrul cu pointeri presupune o atenție deosebită. Greșelile sunt mai greu de observat și de multe ori duc la blocarea calculatorului, care trebuie resetat mereu, pierzându-se astfel o mulțime de timp. Trebuie deci căutată o metodă de parcurgere a arborelui care să nu necesite o alocare dinamică a memoriei. Putem încerca astfel: inițial '''''P'''''('''''i''''')='''''S'''''('''''i''''') și '''''Q'''''('''''i''''')=0 pentru orice nod. Urmează acum să tratăm pe rând fiecare nod. Cum ? Știm că pentru fiecare nod '''''k''''', numerele '''''P'''''('''''k''''') și '''''Q'''''('''''k''''') intervin în expresia lui '''''P'''''('''''T'''''('''''k''''')) și '''''Q'''''('''''T'''''('''''k''''')). Uitându-ne la formulele de mai sus, observăm că tot ce avem de făcut este să incrementăm '''''P'''''('''''T'''''('''''k''''')) cu '''''Q'''''('''''k''''') și '''''Q'''''('''''T'''''('''''k''''')) cu max{'''''P'''''('''''k'''''),'''''Q'''''('''''k''''')}.

Există o singură problemă: Pentru a putea folosi numerele '''''P'''''('''''k''''') și '''''Q'''''('''''k''''') trebuie să ne asigurăm că ele au fost deja calculate corect, în funcție de caracteristicile tuturor fiilor lui '''''k'''''. În cazul frunzelor, problema este rezolvată, deoarece ele nu au fii. Pentru nodurile interne, este necesar să știm câți fii au ele și câți din aceștia au fost tratați. În momentul în care toți fiii unui nod au fost tratați, poate fi tratat și nodul în sine. În program, vectorul '''''F''''' reține numărul de fiii netratați ai fiecărui nod. La tratarea unui nod '''''k''''' se face decrementarea lui '''''F'''''('''''T'''''('''''k''''')). Un nod '''''k''''' poate fi ales spre tratare dacă F('''''k''''')=0. Se observă că formatul datelor de intrare permite cu ușurință construcția vectorului '''''F''''' (numărul de fii al lui '''''k''''' este egal cu numărul de apariții al lui '''''k''''' în vectorul T).

Un algoritm mai ușor de implementat ar fi:

<pre>
numara fiii fiecarui nod
repeta de N-1 ori:
cauta un nod k cu F(k)=0
P(T(k)) ← P(T(k))+Q(k)
Q(T(K)) ← Q(T(K))+max{P(k),Q(k)}
F(T(K)) ← F(T(K))-1
scrie P(R)
</pre>

Partea delicată a acestui algoritm este căutarea unui nod '''''k''''' cu '''''F'''''('''''k''''')=0. Dacă ea se face secvențial, pornind de fiecare dată de la primul nod și cercetând fiecare element, programul care rezultă are complexitatea <math>O(N^2)</math>. Această căutare trebuie deci optimizată, și iată cum: În principiu, putem căuta nodurile cu '''''F'''''('''''k''''')=0 mergând numai în sensul crescător al indicilor în vector. Vom folosi, ca și la problema codului lui Pruffer, două variabile: '''''K''''' și '''''Next'''''. '''''K''''' este nodul tratat în prezent, iar '''''Next''''' este nodul care urmează a fi tratat la pasul următor, așadar '''''Next''''' > '''''K'''''. După tratarea nodului '''''K''''' și decrementarea lui '''''F'''''('''''T'''''('''''k''''')), pot surveni trei situații:

# '''''F'''''('''''T'''''('''''k'''''))>0 și în vectorul '''''F''''' nu a apărut nici un alt element zero, caz în care nimic nu se schimbă, algoritmul continuând cu tratarea nodului '''''Next''''';
# '''''F'''''('''''T'''''('''''k'''''))=0 și '''''T'''''('''''k''''')>'''''Next''''', caz în care de asemenea se poate trata nodul '''''Next''''' (deoarece selectarea nodurilor cu '''''F'''''('''''k''''')=0 se face în ordine crescătoare a indicilor);
# '''''F'''''('''''T'''''('''''k'''''))=0 și '''''T'''''('''''k''''')<'''''Next''''', caz în care se va trata mai întâi nodul '''''T'''''('''''k'''''), urmând a se reveni apoi la nodul '''''Next'''''.

Pentru motivele explicate la codul lui Pruffer, acest algoritm nu necesită menținerea unei stive, iar timpul total de căutare este <math>O(N)</math>. Facem observația că nu se poate găsi un algoritm mai bun, deoarece trebuie parcurse toate cele '''''N''''' noduri ale arborelui.

Iată în încheiere cum arată arborele cu valorile P și Q atașate fiecărui nod:

[[File:Psycho-fig66.png]]

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 1000
typedef long Vector[NMax+1];

Vector T,S,P,Q,F; /* T = Vectorul de tati,
S = sociabilitatile,
P,Q = caracteristicile,
F = numarul de fii */
int N,Root;

void InitData(void)
{ int i;
FILE *InF=fopen("input.txt","rt");

fscanf(InF,"%d",&N);
for (i=1;i<=N+1;F[i++]=0);
for (i=1;i<=N;i++)
{ fscanf(InF,"%d",&T[i]);
if (T[i]) F[T[i]]++; else Root=i;
}
for (i=1;i<=N;i++) fscanf(InF,"%d",&S[i]);
fclose(InF);

for (i=1;i<=N;P[i++]=S[i]);
for (i=1;i<=N;Q[i++]=0);
}

void FindNext(int *K,int *Next)
{ F[T[*K]]--;
F[*K]=-1;
if ((F[T[*K]]>0) || (T[*K]>*Next))
{ *K=*Next;
while (F[*Next]) (*Next)++;
}
else *K=T[*K];
}

void TraverseTree(void)
{ int K=0,Next,i;

do; while (F[++K]);
Next=K; do; while (F[++Next]);
for (i=1;i<N;i++)
{ P[T[K]]+=Q[K];
Q[T[K]]+=(P[K]>Q[K]) ? P[K] : Q[K];
FindNext(&K,&Next);
}
}

void main(void)
{
InitData();
TraverseTree();
printf("%ld\n",P[Root]);
}
</syntaxhighlight>

== Problema 10 ==

Această problemă a fost dată la unul din barajele pentru selecționarea lotului restrâns al României pentru Olimpiada Internațională din 1996.

'''ENUNȚ''': Fie un număr prim '''''P'''''. Pe mulțimea {0, 1, ..., '''''P'''''-1} se definesc operațiile binare +, -, ×, / modulo '''''P''''', în felul următor:

# '''''a'''''+'''''b''''' modulo '''''P''''' este restul împărțirii lui '''''a'''''+'''''b''''' la '''''P'''''. Analog pentru '×'.
# Expresia '''''a'''''-'''''b''''' este definită ca fiind soluția ecuației <math>b+x \equiv a \pmod{P}</math>. Analog pentru '/'.

Se știe că ecuația <math>b+x=a</math> are întotdeauna soluție unică, iar <math>b \times x=a</math> are soluție unică pentru orice '''''b''''' ≠ 0. Pentru '''''b''''' = 0, operația '''''a'''''/'''''b''''' nu e definită. De exemplu, dacă '''''P'''''=11, atunci 6+7=2, 6-7=10, 6*7=9, 6/7=4. Se știe că adunarea și înmulțirea modulo '''''P''''' sunt comutative, asociative, posedă elemente neutre (pe 0, respectiv pe 1), iar adunarea este distributivă față de înmulțire. În plus, pentru orice '''''a''''' există '''''b''''' astfel încât '''''a'''''+'''''b'''''=0; notând '''''b''''' cu (-'''''a''''') avem '''''c'''''-'''''a'''''='''''c'''''+(-'''''a''''')='''''c'''''+'''''b''''' pentru orice '''''c'''''. De asemenea, pentru orice '''''a''''' ≠ 0 există '''''b''''' astfel încât '''''a''''' × '''''b'''''=1; notând '''''b''''' cu (1/'''''a''''') avem că '''''c'''''/'''''a'''''='''''c'''''(1/'''''a''''')='''''c''''' × '''''b'''''.

Dându-se un număr prim '''''P''''', un întreg '''''D''''' între 0 și '''''P'''''-1 și un șir de '''''N''''' numere, cuprinse fiecare între 0 și '''''P'''''-1, se cere să se introducă între elementele șirului operatorii +, -, ×, / și parantezele corespunzătoare, astfel încât să se obțină o expresie corectă a cărei valoare să fie '''''D''''' (lucrând în aritmetica modulo '''''P'''''). În caz că acest lucru nu este posibil, se va afișa un mesaj corespunzător.

'''Intrarea''': Fișierul <tt>INPUT.TXT</tt> conține două linii:

* pe prima linie se găsesc trei numere întregi: '''''P''''', '''''N''''' și '''''D''''', separate prin spații (2≤'''''P'''''≤ 23, '''''P''''' prim, 1 ≤ '''''N''''' ≤ 30, 0 ≤ '''''D''''' ≤ '''''P'''''-1);
* pe următoarea linie se găsește șirul de numere ce formează expresia ('''''N''''' numere întregi cuprinse între 0 și '''''P'''''-1).

'''Ieșirea''': Fișierul text <tt>OUTPUT.TXT</tt> va conține o singură linie pe care se va găsi expresia generată sau mesajul „Nu există soluție.”. Expresia va fi parantezată complet (fiecare operator va avea o pereche de paranteze atașate).

'''Exemple''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>11 3 6 4 7 9</tt>
| <tt>(4+(7/9))</tt>
|-
| <tt>11 3 7 1 1 1</tt>
| <tt>Nu exista solutie.</tt>
|}

'''Timp de execuție''' pentru un test: 1 minut.

Modificările și completările propuse de autor sunt:

* '''Timp de execuție''': 10 secunde
* '''Timp de implementare''': 1h 30 minute, maxim 1h 45 minute.
* '''Complexitate cerută''': <math>O(N^3 \times P^2)</math>.

'''REZOLVARE''': Problema în sine nu este foarte complicată. Ea face apel la programarea dinamică, dar este foarte asemănătoare cu una din problemele bine cunoscute de elevi - înmulțirea optimă a unui șir de matrice. Ceea ce o face mai „provocatoare” este timpul alocat implementării. De fapt, la respectiva probă au fost propuse trei probleme, cam de același nivel de dificultate, iar timpul total permis a fost de 4 ore. De asemenea, structurile de date impuse și modul de utilizare a lor sunt mai rar întâlnite.

Ideea de la care se pornește în rezolvarea acestei probleme este următoarea: Parantezarea și completarea cu operatori a unui șir de '''''N''''' numere, '''''V'''''=('''''V'''''(1), '''''V'''''(2), ..., '''''V'''''('''''N''''')), astfel încât să se obțină rezultatul '''''D''''' este posibilă dacă și numai dacă există două valori <math>D_1</math> și <math>D_2</math>, un număr întreg '''''K''''' cuprins între 1 și '''''N'''''-1 și un operator <math>\oplus \in \{ +, -, \times, / \}</math> astfel încât următoarele condiții să fie îndeplinite simultan:

# Este posibilă parantezarea și completarea cu operatori a șirului '''''V’'''''=('''''V'''''(1), '''''V'''''(2), ..., '''''V'''''('''''K''''')) astfel încât să se obțină rezultatul <math>D_1</math>;
# Este posibilă parantezarea și completarea cu operatori a șirului '''''V’’'''''=('''''V'''''('''''K'''''+1), '''''V'''''('''''K'''''+2), ..., '''''V'''''('''''N''''')) astfel încât să se obțină rezultatul <math>D_2</math>;
# <math>D_1 \oplus D_2 = D</math>

Cu alte cuvinte, trebuie să găsim un loc în care să „spargem” expresia noastră în așa fel încât, luând două valori care se pot obține pentru partea din stânga, respectiv din dreapta, și inserând între ele operatorul potrivit, să obținem valoarea '''''D'''''.

Pentru aflarea operatorului, a locului de împărțire a expresiei în două și a celor două valori necesare, ar fi de ajuns patru instrucțiuni repetitive for. Totuși, rămâne o singură întrebare: cum se poate verifica dacă se poate sau nu obține valoarea <math>D_1</math> pentru subexpresia din stânga, respectiv valoarea <math>D_2</math> pentru subexpresia din dreapta? Aceasta este o subproblemă similară cu problema în sine, dar redusă la dimensiuni mai mici. O abordare directă ar fi comodă: se scrie o procedură care efectuează cele patru instrucțiuni for și, pentru fiecare combinație posibilă de operatori și operanzi, se reapelează recursiv ca să afle dacă valorile operanzilor se pot obține. Totuși, este intuitiv că această variantă va avea o complexitate uriașă, care o face inutilizabilă.

Motivul principal al nerentabilității acestei implementări este că ea reface de nenumărate ori exact aceleași calcule. Spre exemplu, dacă '''''N'''''=4, programul va încerca să spargă vectorul ('''''V'''''(1), '''''V'''''(2), '''''V'''''(3), '''''V'''''(4)) în două părți. Există trei moduri posibile:

* ('''''V'''''(1)) și ('''''V'''''(2), '''''V'''''(3), '''''V'''''(4)); (a)
* ('''''V'''''(1), '''''V'''''(2)) și ('''''V'''''(3), '''''V'''''(4)); (b)
* ('''''V'''''(1), '''''V'''''(2), '''''V'''''(3)) și ('''''V'''''(4)); (c)

Pentru a studia cazul (c), expresia stângă va trebui la rândul ei ruptă în două bucăți, lucru care poate fi făcut în două moduri:

* ('''''V'''''(1)) și ('''''V'''''(2), '''''V'''''(3)); (d)
* ('''''V'''''(1), '''''V'''''(2)) și ('''''V'''''(3)); (e)

Se observă că deja secvența ('''''V'''''(1), '''''V'''''(2)) a fost studiată de două ori (în cazurile (b) și (e)), iar secvența ('''''V'''''(1)) tot de două ori (în cazurile (a) și (d)). Exemplele pot continua. Dacă însă am reuși să nu mai evaluăm de două ori aceeași secvență, complexitatea programului s-ar reduce foarte mult. Pentru aceasta, trebuie să pornim cu secvențe foarte scurte (întâi cele de un singur număr, apoi cele de două numere), și să trecem la secvențe mai lungi, bazându-ne pe faptul că secvențele mai lungi se descompun în secvențe mai scurte care au fost deja analizate. Facem mențiunea că o secvență cu un singur număr poate fi parantezată într-un singur fel (practic nu este nevoie de paranteze și operatori) și poate produce un singur rezultat, egal cu valoarea numărului. O secvență de două numere poate produce maxim patru rezultate distincte, prin folosirea pe rând a celor patru operatori disponibili.

Pentru a stoca rezultatele obținute, vom folosi o matrice tridimensională '''''A''''' de dimensiuni '''''N'''''x'''''N'''''x'''''P'''''. '''''A'''''['''''i''''','''''j''''','''''r'''''] indică dacă există vreo parantezare corespunzătoare a secvenței ('''''V'''''(i), '''''V'''''(i+1), ..., '''''V'''''(j)) astfel încât să se obțină rezultatul '''''r'''''. Dacă o asemenea parantezare există, '''''A'''''['''''i''''','''''j''''','''''r'''''] va indica punctul în care trebuie spartă în două expresia (printr-un număr între '''''i''''' și '''''j'''''-1). Dacă nu există o asemenea parantezare, '''''A'''''['''''i''''','''''j''''','''''r'''''] va lua o valoare specială (0 de exemplu).

De aici decurge modul de inițializare al matricei:

* '''''A'''''['''''i''''','''''i''''','''''V'''''('''''i''''')]='''''i''''', ∀ 1 ≤ '''''i''''' ≤ N
* '''''A'''''['''''i''''','''''j''''','''''r''''']=0, pentru orice alte valori ale lui '''''i''''', '''''j''''' și '''''r'''''

Matricea se va completa pe diagonală, începând de la diagonala principală și terminând în colțul de NE. Pentru a afla toate valorile care se pot obține prin parantezarea secvenței ('''''V'''''('''''i'''''), '''''V'''''('''''i'''''+1), ..., '''''V'''''('''''j''''')), se va împărți această expresie în două părți disjuncte, în toate modurile posibile: ('''''V'''''('''''i''''')) și ('''''V'''''('''''i'''''+1), ..., '''''V'''''('''''j''''')), apoi ('''''V'''''('''''i'''''), '''''V'''''('''''i'''''+1)) și ('''''V'''''('''''i'''''+2), ..., '''''V'''''('''''j''''')) și așa mai departe până la ('''''V'''''('''''i'''''), '''''V'''''('''''i'''''+1), ..., '''''V'''''('''''j'''''-1)) și ('''''V'''''('''''j''''')). Fiecăreia din părțile obținute îi va corespunde în matrice un element de forma '''''A'''''['''''i''''','''''k'''''] sau '''''A'''''['''''k'''''+1,'''''j'''''], cu '''''i''''' ≤ '''''k''''' < '''''j'''''. În orice caz, toate elementele de această formă se vor afla în matrice dedesubtul diagonalei din care face parte elementul '''''A'''''['''''i''''','''''j'''''], deci pentru secvențele respective se cunosc deja toate valorile pe care le pot lua prin parantezare și introducerea operatorilor. Tot ce avem de făcut este să combinăm în toate modurile aceste valori prin inserarea fiecăruia din cei patru operatori pentru a obține toate valorile posibile ale expresiei ('''''V'''''('''''i'''''), '''''V'''''('''''i'''''+1), ..., '''''V'''''('''''j''''')).

Dacă în final '''''A'''''[1,'''''N''''','''''D''''']<>0, atunci problema are soluție. Vom vedea imediat și cum se reconstituie ea. Iată modul de compunere a matricei pentru exemplul din enunț (cu deosebirea că, în figurile de mai jos, '''''A'''''['''''i''''','''''j'''''] nu mai este un vector cu '''''P''''' elemente, ci o mulțime de valori între 0 și '''''P'''''-1, această reprezentare fiind mai comodă):

<math>
A[1,1] = \{4\} \quad A[2,2] = \{7\} \quad A[3,3] = \{9\}
</math>

<math>
A =
\begin{pmatrix}
\{4\} & ? & ? \\
? & \{7\} & ? \\
? & ? & \{9\}
\end{pmatrix}
</math>

Între numerele 4 și 7 plasăm cei patru operatori și obținem:

<math>
\begin{align}
4 + 7 & \equiv 0 \pmod{11} \\
4 - 7 & \equiv 4 + 4 \equiv 8 \pmod{11} \\
4 \times 7 & \equiv 6 \pmod{11} \\
4 / 7 & \equiv 4 \times 8 \equiv 10 \pmod{11} \\
A[1,2] & = \{0, 6, 8, 10\}
\end{align}
</math>

Analog se procedează pentru numerele 7 și 9:

<math>
\begin{align}
7 + 9 & \equiv 5 \pmod{11} \\
7 - 9 & \equiv 7 + 2 \equiv 9 \pmod{11} \\
7 \times 9 & \equiv 8 \pmod{11} \\
7 / 9 & \equiv 7 \times 5 \equiv 2 \pmod{11} \\
A[2,3] & = \{2, 5, 8, 9\}
\end{align}
</math>

<math>
A =
\begin{pmatrix}
\{4\} & \{0, 6, 8, 10\} & ? \\
? & \{7\} & \{2, 5, 8, 9\} \\
? & ? & \{9\}
\end{pmatrix}
</math>

Pentru a calcula A[1,3], putem grupa termenii în două moduri: Fie primul separat și ultimii doi separat, fie primii doi separat și ultimul separat. În primul caz, ultimii doi termeni - după cum s-a văzut - pot produce patru rezultate distincte (2, 5, 8 și 9). Combinând oricare din aceste rezultate cu primul termen (4) și adăugând orice operator, vor rezulta 16 valori posibile, din care evident unele vor coincide. Analog se procedează și pentru celălalt caz:

{|class="wikitable"
! Cazul I || Cazul II
|-
| <math>
\begin{align}
4 + 2 & \equiv 6 \pmod{11} \\
4 - 2 & \equiv 2 \pmod{11} \\
4 \times 2 & \equiv 8 \pmod{11} \\
4 / 2 & \equiv 2 \pmod{11} \\
\end{align}
</math>
| <math>
\begin{align}
0 + 9 & \equiv 9 \pmod{11} \\
0 - 9 & \equiv 2 \pmod{11} \\
0 \times 9 & \equiv 0 \pmod{11} \\
0 / 9 & \equiv 0 \pmod{11} \\
\end{align}
</math>
|-
| <math>
\begin{align}
4 + 5 & \equiv 9 \pmod{11} \\
4 - 5 & \equiv 10 \pmod{11} \\
4 \times 5 & \equiv 9 \pmod{11} \\
4 / 5 & \equiv 3 \pmod{11} \\
\end{align}
</math>
| <math>
\begin{align}
6 + 9 & \equiv 4 \pmod{11} \\
6 - 9 & \equiv 8 \pmod{11} \\
6 \times 9 & \equiv 10 \pmod{11} \\
6 / 9 & \equiv 8 \pmod{11} \\
\end{align}
</math>
|-
| <math>
\begin{align}
4 + 8 & \equiv 1 \pmod{11} \\
4 - 8 & \equiv 7 \pmod{11} \\
4 \times 8 & \equiv 10 \pmod{11} \\
4 / 8 & \equiv 6 \pmod{11} \\
\end{align}
</math>
| <math>
\begin{align}
8 + 9 & \equiv 6 \pmod{11} \\
8 - 9 & \equiv 10 \pmod{11} \\
8 \times 9 & \equiv 6 \pmod{11} \\
8 / 9 & \equiv 7 \pmod{11} \\
\end{align}
</math>
|-
| <math>
\begin{align}
4 + 9 & \equiv 2 \pmod{11} \\
4 - 9 & \equiv 6 \pmod{11} \\
4 \times 9 & \equiv 3 \pmod{11} \\
4 / 9 & \equiv 9 \pmod{11} \\
\end{align}
</math>
| <math>
\begin{align}
10 + 9 & \equiv 8 \pmod{11} \\
10 - 9 & \equiv 1 \pmod{11} \\
10 \times 9 & \equiv 2 \pmod{11} \\
10 / 9 & \equiv 6 \pmod{11} \\
\end{align}
</math>
|}

<math>
A[1,3] = \{0, 1, 2, 3, 4, 6, 7, 8, 9, 10\}
</math>

<math>
A =
\begin{pmatrix}
\{4\} & \{0, 6, 8, 10\} & \{0..4, 6..10\} \\
? & \{7\} & \{2, 5, 8, 9\} \\
? & ? & \{9\}
\end{pmatrix}
</math>

Se observă că singura valoare care nu se poate obține prin parantezarea șirului (4, 7, 9) este 5. Să vedem acum și care este metoda de reconstituire a soluției. Fie '''''A'''''['''''1''''','''''N''''','''''D''''']=X. Dacă '''''X'''''=0, atunci nu există soluție. Dacă '''''X''''' ≠ 0, atunci '''''X''''' indică poziția din vector după care trebuie inserat semnul. Nu se indică însă ce semn trebuie inserat, nici care sunt valorile care trebuie obținute pentru partea stângă, respectiv dreaptă. De aceea, vom căuta o combinație oarecare de valori <math>D_1</math> și <math>D_2</math> care se pot obține și un operator oarecare astfel încât <math>D_1 \oplus D_2 = D</math>. Odată ce le găsim, vom căuta, prin aceeași metodă, o modalitate de a obține valoarea <math>D_1</math> în partea stângă a vectorului (știm sigur că această modalitate există) și o modalitate de a obține valoarea <math>D_2</math> în partea dreaptă a vectorului.

Iată în continuare câteva detalii de implementare. Pentru efectuarea operațiilor matematice modulo '''''P''''' s-a scris o funcție separată, '''''Expr''''', care primește două numere '''''X''''' și '''''Y''''' între 0 și '''''P'''''-1 și un număr '''''Op''''' între 1 și 4 reprezentând codificarea operatorului și întoarce un număr între 0 și '''''P''''', reprezentând valoarea operației ('''''X Op Y'''''). De fapt, ar trebui ca această funcție să întoarcă un număr între 0 și '''''P'''''-1 dacă operația este posibilă și să nu întoarcă nimic dacă operația este imposibilă, respectiv dacă se încearcă o împărțire la 0. Cum acest lucru nu este posibil în Pascal, am asimilat valoarea '''''P''''' cu un cod de eroare, iar funcția va întoarce această valoare (care nu poate fi atinsă prin operații obișnuite) în cazul unei împărțiri prin 0. Mai departe, pentru a nu face un test separat dacă rezultatul funcției reprezintă o adresă valabilă în cea de-a treia dimensiune a tabloului, am preferat să supradimensionăm tabloul cu o unitate și să ignorăm tot ceea ce se scrie în coloana '''''P'''''.

Să ne ocupăm acum de operațiile aritmetice. Adunarea, scăderea și înmulțirea se fac în timp constant. O problemă apare în cazul împărțirii, deoarece ea nu mai seamănă deloc cu cea învățată pe mulțimea <math>\mathbb{R}</math>. Pentru a calcula '''''X'''''/'''''Y''''', trebuie găsit acel număr '''''Z''''' care, înmulțit cu '''''Y''''', să dea '''''X'''''. Acest lucru se poate face într-o primă fază prin căutare secvențială (se încearcă valoarea 0, apoi 1, apoi 2 și așa mai departe; trebuie să existe un cât deoarece '''''P''''' este prim). Tehnica are însă influențe neplăcute asupra complexității, supărătoare asupra timpului de rulare și dezastruoase asupra punctajului obținut. De aceea, este bine ca, în măsura în care timpul o permite, să se construiască o tabelă predefinită de calculare a inverșilor. Atunci, în loc să se efectueze împărțirea '''''X'''''/'''''Y''''', se efectuează înmulțirea <math>X \times Y^{-1}</math>. Inversul unui element depinde și de modulul ales. Programul care urmează construiește un tabel care a fost importat în programul sursă ca o constantă, matricea <tt>Invers</tt> (<tt>Invers[A,B]</tt> este inversul lui '''''B''''' modulo '''''A'''''). Liniile corespunzătoare unor numere neprime au fost totuși inserate, pentru ușurința implementării.

<syntaxhighlight>
program Invert;
const NMax=30;
PMax=23;
var i,P:Integer;

function Invers(P,K:Integer):Integer;
var i:Integer;
begin
i:=0;
repeat Inc(i) until (K*i) mod P=1;
Invers:=i;
end;

begin
Assign(Output,'invers.txt');Rewrite(Output);
for P:=2 to PMax do
begin
Write('{',P:2,'} (');
for i:=1 to NMax do
begin
if (P in [2,3,5,7,11,13,17,19,23]) and (i<P)
then Write(Invers(P,i):2)
else Write(99);
if i<>NMax then Write(',');
if i=NMax div 2 then Write(#13#10' ');
end;
WriteLn('),');
end;
Close(Output);
end.
</syntaxhighlight>

Să analizăm în sfârșit complexitatea: Trebuie completată o matrice, deci <math>O(N^2)</math> elemente. Pentru fiecare element din matrice, secvența corespunzătoare din vector trebuie spartă în două în toate modurile posibile, deci încă <math>O(N)</math>. Pentru fiecare descompunere, trebuie combinate în toate felurile toate valorile disponibile pentru partea stângă, respectiv dreaptă. Cum numărul de valori este <math>O(P)</math>, rezultă o complexitate de <math>O(P^2)</math>. Înmulțind toți acești factori rezultă o complexitate totală de <math>O(N^3 \times P^2)</math>. Dacă nu am fi făcut împărțirea a două numere modulo P în timp constant, ci în <math>O(P)</math>, atunci complexitatea totală ar fi fost <math>O(N^3 \times P^3)</math>, deci timpul de rulare putea fi și de 20 de ori mai mare.

Programul de mai jos pare îngrozitor de lung, dar, dacă avem în vedere faptul că o bună bucată o reprezintă constanta <tt>Invers</tt>, care este generată, putem avea speranțe să-l scriem în timpul alocat.

<syntaxhighlight>
program ParaNT;
{$B-,I-,R-,S-}
const NMax=30;
PMax=23;
NoWay=0;
OpNames:String[4]='+-*/';
Invers:array[2..PMax,1..NMax] of Integer=
{ 2}(( 1,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 3} ( 1, 2,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 4} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 5} ( 1, 3, 2, 4,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 6} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 7} ( 1, 4, 5, 2, 3, 6,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 8} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{ 9} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{10} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{11} ( 1, 6, 4, 3, 9, 2, 8, 7, 5,10,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{12} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{13} ( 1, 7, 9,10, 8,11, 2, 5, 3, 4, 6,12,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{14} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{15} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{16} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{17} ( 1, 9, 6,13, 7, 3, 5,15, 2,12,14,10, 4,11, 8,
16,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{18} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{19} ( 1,10,13, 5, 4,16,11,12,17, 2, 7, 8, 3,15,14,
6, 9,18,99,99,99,99,99,99,99,99,99,99,99,99),
{20} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{21} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{22} (99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99),
{23} ( 1,12, 8, 6,14, 4,10, 3,18, 7,21, 2,16, 5,20,
13,19, 9,17,15,11,22,99,99,99,99,99,99,99,99));

type Matrix=array[1..NMax, 1..NMax, 0..PMax] of Integer;
{ S-a inclus si valoarea PMax, care nu poate fi
atinsa, pentru a se depozita "deseurile" }
Vector=array[1..NMax] of Integer;
var A:Matrix; { Matricea de calcul }
V:Vector; { Numerele }
N,P,D:Integer;

procedure ReadData;
var i:Integer;
begin
Assign(Input,'input.txt');Reset(Input);
ReadLn(P,N,D);
for i:=1 to N do Read(V[i]);
Close(Input);
end;

function Expr(X,Y,Op:Integer):Integer;
{ Calculeaza expresia (X Op Y) unde Op=1 ('+'),
Op=2 ('-'), Op=3 ('*'), Op=4 ('/'). Daca Op=4
si Y=0 se returneaza valoarea P (care nu poate
fi atinsa prin alte operatii corecte). }
begin
case Op of
1:Expr:=(X+Y) mod P;
2:Expr:=(X+P-Y) mod P;
3:Expr:=(X*Y) mod P;
4:if Y=0 then Expr:=P { = imposibil }
else Expr:=(X*Invers[P,Y]) mod P
{ S-a creat o tabela predefinita de inversi,
deoarece altfel impartirea se efectua numai
in O(P) }
end; {case}
end;

procedure Combine(i,j,k:Integer);
{ Urmeaza a se combina toate valorile posibile
pentru A[i,k] si A[k+1,j] pentru a se afla
toate valorile posibile pentru A[i,j] }
var p1,p2,Op:Integer;
begin
for p1:=0 to P-1 do
if A[i,k,p1]<>NoWay
then for p2:=0 to P-1 do
if A[k+1,j,p2]<>NoWay
then { Am gasit doua valori posibile
si aplicam cei patru operatori }
for Op:=1 to 4 do
A[i,j,Expr(p1,p2,Op)]:=k;
end;

procedure ComposeMatrix;
var i,j,k,l:Integer;
begin
{ Initializarea matricei }
for i:=1 to N do
for j:=1 to N do
for k:=0 to P-1 do A[i,j,P]:=NoWay;

for i:=1 to N do
A[i,i,V[i]]:=1; { sau orice <> NoWay }

for l:=2 to N do { Lungimea intervalelor }
for i:=1 to N-l+1 do
begin
j:=i+l-1; { S-au fixat [i,j] capetele intervalului }
for k:=i to j-1 do { Se alege locul de impartire }
Combine(i,j,k);
end;
end;

procedure SeekValues(Lo,Hi,Mid,Value:Integer;
var v1,v2:Integer; var Op:Char);
{ Se stie unde e "sparta" expresia in doua; se cauta
valorile care trebuie obtinute pentru partea stanga,
respectiv dreapta, si pentru operator }
var i,j,k:Integer;
begin
for i:=0 to P-1 do
if A[Lo,Mid,i]<>NoWay
then for j:=0 to P-1 do
if A[Mid+1,Hi,j]<>NoWay
then for k:=1 to 4 do
if Expr(i,j,k)=Value
then begin
v1:=i;
v2:=j;
Op:=OpNames[k];
Exit;
end;
end;

procedure WriteExpression(Lo,Hi,Value:Integer);
var v1,v2,Place:Integer;
Op:Char;
begin
if Lo=Hi
then Write(V[Lo])
else begin
Place:=A[Lo,Hi,Value];
SeekValues(Lo,Hi,Place,Value,v1,v2,Op);
Write('(');
WriteExpression(Lo,Place,v1);
Write(Op);
WriteExpression(Place+1,Hi,v2);
Write(')');
end;
end;

procedure WriteSolution;
begin
Assign(Output,'output.txt');Rewrite(Output);
if A[1,N,D]=NoWay
then Write('Nu exista solutie')
else WriteExpression(1,N,D);
WriteLn;
Close(Output);
end;

begin
ReadData;
ComposeMatrix;
WriteSolution;
end.
</syntaxhighlight>

O posibilă îmbunătățire a programului de sus ar fi să reținem în '''''A'''''['''''i''''','''''j''''','''''r'''''] nu numai locul unde se face secționarea expresiei, ci și operatorul introdus și eventual și valorile care trebuie obținute pe partea stângă, respectiv dreaptă. Totuși, volumul de date ar fi crescut corespunzător și ar fi devenit greu de manipulat. În schimb, în versiunea prezentă, programul merge puțin mai lent, dar nesesizabil. Să vedem de ce. Complexitatea reconstituirii expresiei în sine se află astfel: avem de reconstituit <math>O(N)</math> operatori. Pentru fiecare din ei, trebuie să căutăm valorile stângă și dreaptă și operatorul în sine, deci <math>O(4 \times P^2)</math>. Complexitatea totală a reconstituirii datelor este <math>O(N \times P^2)</math>, adică oricum mult mai mică față de cea a compunerii matricei. Este preferabil să nu complicăm structurile de date și codul scris, mai ales că diferența ca timp de rulare este infimă.

Propunem ca temă cititorului o versiune a acestei probleme, în care nu se va mai lucra în inelul <math>\mathbf{Z_P}</math>, ci într-un grup cu elementele '''''a''''', '''''b''''', '''''c''''', '''''d''''', ..., pentru care se cunoaște tabela de compoziție. În acest caz avem un singur operator <math>\oplus</math>, iar cerința este să se parantezeze expresia <math>x_1 \oplus x_2 \oplus \cdots \oplus x_k</math> astfel încât rezultatul să fie '''''y'''''.

== Problema 11 ==

Problema celui mai lung prefix a fost dată la a VIII-a Olimpiadă Internațională de Informatică, Veszprem 1996. Iată enunțul nemodificat al problemei:

'''ENUNȚ''': Structura unor compuși biologici este reprezentată prin succesiunea constituenților lor. Acești constituenți sunt notați cu litere mari. Biologii sunt interesați să descompună o secvență lungă în altele mai scurte, numite primitive. Spunem că o secvență '''''S''''' poate fi compusă dintr-un set de primitive '''''P''''' dacă există '''''N''''' primitive '''''p1''''', ..., '''''pN''''' în '''''P''''' astfel încât concatenarea '''''p1p2...pN''''' a primitivelor să fie egală cu '''''S'''''. Aceeași primitivă poate interveni de mai multe ori în concatenare și nu trebuie neapărat ca toate primitivele să fie prezente.

Primele '''''M''''' caractere din '''''S''''' se numesc prefixul lui '''''S''''' de lungime '''''M'''''. Scrieți un program care primește la intrare un set de primitive '''''P''''' și o secvență de constituenți '''''T'''''. Programul trebuie sa afle lungimea celui mai lung prefix al lui '''''T''''' care se poate compune din primitive din '''''P'''''.

'''Datele de intrare''' apar în două fișiere. Fișierul <tt>INPUT.TXT</tt> descrie setul de primitive '''''P''''', iar fișierul <tt>DATA.TXT</tt> conține secvența de examinat. Pe prima linie din <tt>INPUT.TXT</tt> se află '''''N''''', numărul de primitive din '''''P''''' (1 ≤ '''''N''''' ≤ 100). Fiecare primitivă se dă pe două linii consecutive: pe prima lungimea '''''L''''' a primitivei (1 ≤ '''''L''''' ≤ 20), iar pe a doua un șir de litere mari de lungime '''''L'''''. Toate cele '''''N''''' primitive sunt distincte.

Fiecare linie din fișierul DATA.TXT conține o literă mare pe prima poziție. El se termină cu o linie conținând un punct ('.'). Lungimea secvenței este cuprinsă între 1 si 500.000.

'''Ieșirea''': Pe ecran se va tipări lungimea celui mai lung prefix din '''''T''''' care poate fi compus din primitive din '''''P'''''.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>5 
1 
A 
2 
AB 
3 
BBC 
2 
CA 
2 
BA </tt>
| <tt>A 
B 
A 
B 
A 
C 
A 
B 
A 
A 
B 
C 
B 
. </tt>
|}

Pe ecran se va tipări numărul 11.

'''Timp de rulare''': 30 secunde pentru un test.

'''Timp de implementare''': 1h.

'''Complexitate cerută''': <math>O(S \times L \times N)</math>, unde S este lungimea secvenței.

'''REZOLVARE''': Menționăm de la început că datele problemei sunt supradimensionate. Nici unul din cele zece teste cu care au fost verificate programele nu a depășit în realitate 12 primitive. În schimb, fișierul <tt>DATA.TXT</tt> a fost unic pentru toate testele și a conținut o secvență de lungime 500.000.

Problema se rezolvă și în acest caz prin reducerea ei la una similară, dar cu date de intrare mai mici. Respectiv, un prefix '''''S''''' al lui '''''T''''' se poate descompune în primitive dacă există o primitivă <math>p_i</math> astfel încât <math>S=S'+p_i</math> și '''''S’''''' se poate descompune în primitive. Am redus împărțirea în primitive a lui '''''S''''' la despărțirea în primitive a lui '''''S’''''', care are o lungime mai mică decât '''''S'''''. O primă modalitate, pur teoretică, de a rezolva problema, este să reținem toate prefixele lui '''''T''''' care se pot descompune în primitive; în felul acesta, putem studia prefixe din ce în ce mai lungi, bazându-ne pe prefixe mai scurte deja studiate. Totuși, este imposibil să ținem minte toate prefixele lui '''''T''''', deoarece lungimea medie a unui prefix poate atinge 250.000 caractere.

O îmbunătățire care poate fi adusă acestui algoritm este următoarea: deoarece toate prefixele aparțin aceleiași secvențe de constituenți, '''''T''''', este suficient să reținem în întregime secvența '''''T''''' și, pentru fiecare prefix ce se poate descompune în primitive, păstrăm doar lungimea sa. Făcând abstracție de limitările de memorie, putem crea un vector '''''V''''' cu '''''S''''' variabile booleene (unde '''''S'''''≤500.000), iar '''''V'''''['''''i'''''] va indica dacă subșirul de lungime '''''i''''' din '''''T''''' se poate descompune în primitive. '''''V'''''['''''i'''''] va primi valoarea <tt>True</tt> dacă și numai dacă există o primitivă '''''p''''' în '''''P''''' de lungime '''''L''''' astfel încât să fie îndeplinite simultan condițiile:

* '''''V'''''['''''i'''''-'''''L''''']=<tt>True</tt>;
* secvența de caractere <tt>T[i-L+1]T[i-L+2]...T[i]</tt> este egală cu '''''p'''''.

Iată o primă variantă (în pseudocod) a algoritmului:

<pre>
citeste primitivele
citeste T
pentru i de la 1 la S
daca exista o primitiva p astfel incat
V[i-L] si T[i-L+1]T[i-L+2]...T[i]=p
atunci V[i]←True
altfel V[i]←False
cauta cel mai mare i pentru care V[i]=True
scrie i
</pre>

Chiar și în acest caz, apare o problemă, deoarece avem nevoie de doi vectori, unul de caractere și altul de variabile booleene, ambii de lungime maxim 500.000. Necesarul de memorie este deci cam de 1MB. Sigur, pentru calculatoarele de astăzi această sumă este ușor de alocat, dar problema admite oricum o soluție la fel de rapidă și mult mai economică. Iată care este principiul:

Pentru a vedea dacă un prefix '''''S''''' de lungime '''''L''''' se poate descompune în primitive, noi avem nevoie să cunoaștem dacă prefixele de lungime mai mică se pot descompune. Dar avem oare nevoie de toate prefixele? Nu, deoarece noi vom concatena unul din prefixele de lungime mai mică cu o primitivă pentru a obține noul prefix '''''S'''''. Însă primitivele au lungime de maxim 20 caractere. Așadar, noi nu trebuie să cunoaștem decât dacă prefixele de lungime '''''L'''''-1, '''''L'''''-2, ..., '''''L'''''-20 se pot descompune; restul nu ne interesează. În felul acesta am eliminat vectorul '''''V''''' și l-am redus la un vector de numai 20 de elemente (care în program se numește <tt>CanGet</tt>). La fiecare moment, când se prelucrează un nou caracter din secvența de constituenți '''''T''''', primul element din <tt>CanGet</tt> se pierde (deoarece informația pe care el o stochează este învechită), iar următoarele 19 elemente se deplasează spre stânga cu câte o poziție. Al 20-lea element, care acum a rămas disponibil, va fi calculat la pasul curent.

O altă modificare pornește de la observația că, datorită aceleiași limitări a lungimii primitivelor la 20 de caractere, nu avem nevoie nici măcar să reținem întregul vector '''''T''''', ci numai ultimele 20 de litere ale lui. La fiecare pas, litera cea mai „veche” din '''''T''''' (adică de indice minim) se va pierde, iar la celelalte 19 litere se va adăuga litera nou citită. Avem așadar nevoie doar de un string de 20 de caractere, pe care în program l-am numit <tt>Last</tt>. Pentru a deplasa spre stânga vectorii <tt>CanGet</tt> și <tt>Last</tt>, se pot folosi fie atribuirile succesive, fie rutinele de acces direct la memorie.

Deoarece prefixele care se pot descompune sunt identificate în ordinea crescătoare a lungimii, ultimul asemenea prefix găsit este tocmai cel de lungime maximă. Dar pentru că, în momentul în care găsim un prefix, nu putem ști dinainte că el este ultimul, trebuie să reținem într-o variabilă lungimea celui mai lung prefix găsit până la momentul respectiv, variabilă pe care o actualizăm de fiecare dată când găsim un nou prefix.

În felul acesta, am reușit să reducem memoria folosită aproape la strictul necesar, adică numai la dicționarul de primitive și la doi vectori de câte douăzeci de caractere. Se recomandă totuși să se aloce un buffer cât mai mare pentru citirea datelor din fișierul <tt>DATA.TXT</tt> pentru mărirea vitezei de citire. Repartizarea buffer-ului se face cu procedura Pascal <tt>SetTextBuf</tt>.

O optimizare care nu a fost inclusă în program, fiind lăsată ca temă cititorului, este următoarea: dacă la un moment dat, în timpul examinării secvenței de constituenți, este întâlnit un șir de cel puțin 20 de prefixe consecutive, din care nici unul nu se poate descompune în primitive, atunci nici mai departe nu vom mai întâlni vreun prefix care să se poată descompune. Explicați de ce. Această optimizare poate să nu aducă uneori nimic nou în evoluția programului, dar alteori poate să reducă la zero timpul de rulare.

Prezentăm mai jos codul sursă al programului. A fost preferat limbajul Pascal, deoarece pune la dispoziție rutine mai comode de manevrare a șirurilor de caractere.

<syntaxhighlight>
program LongestPrefix;
{$B-,D-,I-,R-,S-}
const NMax=100;
LMax=20;
type Str20=String[LMax+1];
LexType=array[1..NMax] of Str20;
BooleanVector=array[1..LMax+1] of Boolean;
BufferType=array[1..62000] of Byte;
var Lex:LexType; { Dictionarul de primitive }
N:Integer; { Numarul de primitive }
Biggest:LongInt; { Lungimea maxima }
Buf:BufferType; { Buffer de intrare }

procedure ReadPrimitives;
var i,Len:Integer;
begin
Assign(Input,'input.txt');
Reset(Input);
ReadLn(N);
for i:=1 to N do
begin
ReadLn(Len);
ReadLn(Lex[i]);
end;
Close(Input);
end;

procedure Decompose;
var Last:Str20; { Ultimele 20 de caractere citite }
CanGet:BooleanVector;
{ CanGet[i] indica daca Last[i] poate fi
ultimul caracter al unei descompuneri }
i,L:Integer;
Current:LongInt; { Lungimea curenta }
begin
Assign(Input,'data.txt');
SetTextBuf(Input,Buf,SizeOf(Buf));
Reset(Input); { Deschide fisierul cu un buffer atasat }

Biggest:=0;
Last[0]:=Chr(LMax+1);
FillChar(Last,LMax,'@');
FillChar(CanGet,LMax,True);
Current:=0; { Deocamdata nu s-a citit nimic }

ReadLn(Last[LMax+1]); { Citeste primul caracter }
repeat
Inc(Current);
i:=0;
{ Cauta o primitiva potrivita }
repeat
Inc(i);
L:=Length(Lex[i]);
CanGet[LMax+1]:=CanGet[LMax+1-L]
and (Copy(Last,LMax+2-L,L)=Lex[i]);
until CanGet[LMax+1] or (i=N);
{ Am gasit o primitiva? }
if CanGet[LMax+1]
then Biggest:=Current;
{ Deplaseaza spre stanga CanGet si Last }
Move(CanGet[2],CanGet[1],LMax);
Move(Last[2],Last[1],LMax);
{ Avanseaza la urmatorul caracter }
ReadLn(Last[LMax+1]);
until Last[LMax+1]='.';

Close(Input);
end;

procedure WriteSolution;
begin
Assign(Output,'output.txt');
Rewrite(Output);
WriteLn(Biggest);
Close(Output);
end;

begin
ReadPrimitives;
Decompose;
WriteSolution;
end.
</syntaxhighlight>

== Problema 12 ==

Această problemă a fost propusă la a IV-a Balcaniadă de Informatică, Nicosia 1996.

'''ENUNȚ''': Grupul de rock U2 va da un concert în Nicosia. Un grup de '''''N''''' ≤ 200 fani U2 așteaptă la coadă în scopul de a cumpăra bilete de la singura caserie deschisă. Fiecare persoană vrea să cumpere numai un bilet, iar casierul poate vinde unei persoane cel mult două bilete.

Casierul folosește '''''T'''''['''''i'''''] unități de timp pentru a servi al '''''i'''''-lea fan (1 ≤ '''''i''''' ≤ N). Este posibil totuși ca doi fani așezați la coadă unul după altul (de exemplu, al '''''j'''''-lea și al '''''j'''''+1-lea) să convină ca numai unul din ei să rămână la coadă, iar celălalt să plece, dacă timpul '''''R'''''['''''j'''''] (1 ≤ '''''j''''' ≤ '''''N'''''-1) în care casierul servește al '''''j'''''-lea și al '''''j'''''+1-lea fan este mai mic decât '''''T'''''['''''j''''']+'''''T'''''['''''j'''''+1]. Deci, pentru a minimiza timpul de lucru al casierului, fiecare persoană din coadă încearcă să negocieze cu predecesorul și cu succesorul său, ceea ce va duce în final la o servire mai rapidă.

Fiind date numerele întregi pozitive '''''N''''', '''''T'''''['''''i'''''] (1 ≤ '''''i''''' ≤ '''''N''''') și '''''R'''''['''''j'''''] (1 ≤ '''''j''''' ≤ '''''N'''''-1), se cere să se minimizeze timpul total al casierului. Acest lucru va fi realizat grupând într-un mod optim perechi de persoane consecutive. Atenție! Nu este necesar ca un anumit fan să se cupleze neapărat cu predecesorul sau cu succesorul său.

'''Intrarea''': În fișierul <tt>INPUT.TXT</tt>, datele de intrare sunt date pe trei linii:

* prima linie conține numărul întreg '''''N''''';
* a doua linie conține '''''N''''' întregi: valorile '''''T'''''['''''i'''''], separate prin câte un spațiu;
* a doua linie conține '''''N'''''-1 întregi: valorile '''''R'''''['''''j'''''], separate de asemenea prin câte un spațiu;

Ieșirea se va face în fișierul <tt>OUTPUT.TXT</tt>, astfel:

* prima linie conține un întreg care reprezintă timpul total (minim) al casierului;
* pe fiecare din următoarele linii se află un singur număr sau două numere separate prin caracterul '+'. Mai exact, fiecare linie conține numărul '''''i''''' dacă al '''''i'''''-lea fan este servit singur, sau '''''i'''''+('''''i'''''+1) dacă cei doi fani sunt serviți ca o pereche.

'''Exemplu''':

{|class="wikitable"
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>7 
5 4 3 2 1 4 4 
7 3 4 2 2 4</tt>
| <tt>14 
1 
2+3 
4+5 
6+7</tt>
|}

'''Timp de rulare''': 15 secunde pentru un test.

Acesta este enunțul în forma lui de la Nicosia. Iată acum și completările „din studio”:

* Numărul de fani este '''''N''''' ≤ 5000;
* '''Complexitatea cerută''' este <math>O(N)</math>;
* '''Timpul de rulare''' este de o secundă.

'''REZOLVARE''': O primă metodă de rezolvare o vom lăsa în seama cititorului, întrucât ea este foarte asemănătoare cu rezolvarea problemei înmulțirii optime a unui șir de matrice. Ideea de pornire este de a defini o matrice '''''D''''' cu '''''N''''' linii și '''''N''''' coloane, în care '''''D'''''['''''X''''','''''Y'''''] reprezintă timpul minim în care pot fi serviți fanii '''''X''''', '''''X'''''+1, ..., '''''Y'''''-1, '''''Y'''''. Scopul este de a afla valoarea '''''D'''''[1,'''''N'''''].

După cum se știe, însă, înmulțirea optimă a unui șir de matrice se poate determina în timp <math>O(N^3)</math>. Pentru condițiile inițiale ale problemei ('''''N''''' ≤ 200), metoda se încadrează în timp. Ea putea fi deci folosită la concurs, pe câtă vreme dacă se impun condițiile suplimentare, rezolvarea în timp cubic nu mai dă rezultate. Iată ideea de rezolvare a problemei în timp liniar.

Vom denumi o '''cuplare de ordin ''K''''' modul în care primii '''''K''''' fani sunt serviți câte unul sau câte doi. Fiecare cuplare are atașat un cost, respectiv timpul consumat de casier pentru a servi toți fanii. Dintre toate cuplările de ordin '''''K''''', cele pentru care costul este minim (în cazul general pot fi mai multe) se vor numi '''cuplări optime de ordinul ''K'''''. Cerința problemei exprimată cu noua terminologie este: să se găsească o cuplare optimă de ordinul '''''N'''''.

Să presupunem acum că am găsit cumva această cuplare optimă de ordinul '''''N''''', pe care o vom nota cu <math>C_N</math>. Dacă în această cuplare al '''''K'''''-lea fan este servit de unul singur, atunci modul de servire al primilor '''''K'''''-1 fani reprezintă o cuplare optimă de ordinul '''''K'''''-1, pe care o vom nota cu <math>C_{K-1}</math>. Demonstrația nu este grea: dacă fanii 1, 2, ..., '''''K'''''-1 nu ar fi cuplați în mod optim în cadrul lui <math>C_N</math>, atunci ar exista o cuplare a lor <math>C'_{K-1}</math> de cost mai mic decât <math>C_{K-1}</math>. Dar această cuplare mai bună ar putea fi folosită pentru a obține o cuplare mai bună a tuturor celor '''''N''''' fani (servind primii '''''K'''''-1 fani conform cuplării <math>C'_{K-1}</math>, iar pe ceilalți conform cuplării <math>C_N</math>). S-ar obține astfel o cuplare <math>C'_{N}</math> de cost mai mic decât <math>C_N</math>, ceea ce este absurd, deoarece am presupus <math>C_N</math> ca fiind optimă.

În mod absolut identic se poate demonstra că dacă <math>C_N</math> este o cuplare optimă de ordinul '''''N''''' în care fanii '''''K''''' și '''''K'''''+1 sunt serviți împreună, atunci modul de servire al primilor '''''K'''''-1 fani reprezintă o cuplare optimă de ordinul '''''K'''''-1. Recunoaștem în aceste afirmații principiul programării dinamice: optimul global presupune optime locale. De aici deducem că, pentru a realiza o cuplare optimă a primilor '''''K''''' fani avem nevoie de câte o cuplare optimă pentru primii '''''K'''''-1 fani, respectiv pentru primii '''''K'''''-2 fani, urmând ca apoi să aflăm care este costul minim al unei cuplări de ordin '''''K''''', atât în ipoteza că fanul al '''''K'''''-lea este servit singur, cât și în ipoteza că el este servit împreună cu al '''''K'''''-1-lea fan.

Vom crea așadar doi vectori <math>T_1</math> și <math>T_2</math>, ambii cu câte '''''N''''' elemente, în care:

* <math>T_1[K]</math> este timpul minim în care pot fi serviți fanii 1, 2, ..., '''''K''''', astfel încât fanul al '''''K'''''-lea să rămână singur;
* <math>T_2[K]</math> este timpul minim în care pot fi serviți fanii 1, 2, ..., '''''K''''', astfel încât fanii '''''K''''' și '''''K'''''-1 să fie cuplați.

Datele inițiale pe care le putem trece în cei doi vectori sunt:

* <math>T_1[1] = T[1]</math>
* <math>T_2[1] = \infty</math> (un singur fan nu poate fi cuplat cu nimeni)
* <math>T_1[2] = T[1]+T[2]</math> (dacă al doilea fan rămâne singur, atunci și primul rămâne singur)
* <math>T_2[2] = R[1]</math>

Relațiile de recurență se deduc fără prea multă bătaie de cap:

* <math>T_1[K] = T[K] + \min(T_1[K-1], T_2[K-1])</math> (dacă fanul '''''K''''' rămâne singur, atunci el este servit în timpul '''''T'''''['''''K'''''], iar fanul '''''K'''''-1 se va cupla cu '''''K'''''-2 sau va rămâne singur, după cum este mai convenabil);
* <math>T_2[K] = R[K-1] + \min(T_1[K-2], T_2[K-2])</math> (dacă fanul '''''K''''' se cuplează cu '''''K'''''-1, atunci ei sunt serviți în timpul '''''R'''''['''''K'''''-1], iar fanul '''''K'''''-2 se va cupla cu '''''K'''''-3 sau va rămâne singur, după cum este mai convenabil);

Putem deci să completăm vectorii de la stânga la dreapta. Odată ce am făcut aceasta, costul minim al cuplării de ordinul '''''N''''' este <math>\min(T_1[N], T_2[N])</math>. Pentru a reconstitui și așezarea fanilor, vom proceda recurent, astfel: dacă <math>T_2[N]<T_1[N]</math>, înseamnă că este mai avantajos ca fanii '''''N''''' și '''''N'''''-1 să fie cuplați și reluăm reconstituirea pentru fanii 1, 2, ..., '''''N'''''-2. În caz contrar, înseamnă că este mai avantajos ca fanul '''''N''''' să rămână singur și reluăm reconstituirea pentru fanii 1, 2, .., '''''N'''''-1. De exemplu, iată modul în care se completează vectorii <math>T_1</math> și <math>T_2</math> pentru exemplul din enunț:

[[File:Psycho-fig67.png]]

* <math>T_2[7]<T_1[7] \implies</math> Fanii 6 și 7 sunt cuplați. Reconstituim așezarea primilor 5 fani.
* <math>T_2[5]<T_1[5] \implies</math> Fanii 4 și 5 sunt cuplați. Reconstituim așezarea primilor 3 fani.
* <math>T_2[3]<T_1[3] \implies</math> Fanii 2 și 3 sunt cuplați, iar primul fan este singur.

<syntaxhighlight lang="c">
#include <stdio.h>
#define NMax 5001
typedef unsigned IntVector[NMax];
typedef long LongVector[NMax];

IntVector T, R;
LongVector T1, T2;
int N;
FILE *OutF;

void ReadData(void)
{ FILE *F=fopen("input.txt", "rt");
int i;

fscanf(F,"%d\n", &N);
for (i=1; i<=N;)
fscanf(F,"%d", &T[i++]);
for (i=1; i<N;)
fscanf(F,"%d", &R[i++]);
}

long Min(long X, long Y)
{
return X<Y? X : Y;
}
void Match(void)
{ int i;
T1[1]=T[1]; T2[1]=0xFFFF; /* =Infinit */
T1[2]=T[1]+T[2]; T2[2]=R[1];
for (i=3; i<=N; i++)
{
T1[i]=T[i]+Min(T1[i-1],T2[i-1]);
T2[i]=R[i-1]+Min(T1[i-2],T2[i-2]);
}
}

void GoBack(int K)
{
if (K)
if (T1[K]<T2[K])
{ GoBack(K-1);
fprintf(OutF,"%d\n",K);
}
else { GoBack(K-2);
fprintf(OutF,"%d+%d\n",K-1,K);
}
}

void WriteSolution(void)
{
OutF=fopen("output.txt", "wt");
fprintf(OutF,"%d\n",Min(T1[N],T2[N]));
GoBack(N);
fclose(OutF);
}

void main(void)
{
ReadData();
Match();
WriteSolution();
}
</syntaxhighlight>

<references/>

File:Psycho-fig67.png

2018-03-09T12:37:05Z

Cata:

File:Psycho-fig66.png

2018-03-09T12:36:54Z

Cata:

File:Psycho-fig65.png

2018-03-09T12:36:42Z

Cata:

File:Psycho-fig64.png

2018-03-09T12:36:27Z

Cata:

Psihologia concursurilor de informatică/6 Probleme de concurs 1

2018-03-09T12:32:21Z

Cata:

⇦ înapoi la [[Psihologia concursurilor de informatică]]

= Capitolul VI: Probleme de concurs (1-6) =

== Problema 1 ==

'''ENUNȚ''': Se consideră următorul joc: Pe o tablă liniară cu 2'''''N'''''+1 căsuțe sunt dispuse '''''N''''' bile albe (în primele '''''N''''' căsuțe) și '''''N''''' bile negre (în ultimele '''''N''''' căsuțe), căsuța din mijloc fiind liberă. Bilele albe se pot mișca numai spre dreapta, iar cele negre numai spre stânga. Mutările posibile sunt:

# O bilă albă se poate deplasa o căsuță spre dreapta, numai dacă aceasta este liberă;
# O bilă albă poate sări peste bila aflată imediat în dreapta ei (indiferent de culoarea acesteia), așezându-se în căsuța de dincolo de ea, numai dacă aceasta este liberă;
# O bilă neagră se poate deplasa o căsuță spre stânga, numai dacă aceasta este liberă;
# O bilă neagră poate sări peste bila aflată imediat în stânga ei (indiferent de culoarea acesteia), așezându-se în căsuța de dincolo de ea, numai dacă aceasta este liberă.

Trebuie schimbat locul bilelor albe cu cele negre. Se mai cere în plus ca prima mutare să fie făcută cu o bilă albă.

'''Intrarea''': De la tastatură se citește numărul '''''N''''' ≤ 1000.

'''Ieșirea''': În fișierul <tt>OUTPUT.TXT</tt> se vor tipări două linii terminate cu <tt><Enter></tt>. Pe prima se va tipări numărul de mutări efectuate, iar pe a doua o succesiune de cifre cuprinse între 1 și 4, nedespărțite prin spații, corespunzătoare mutărilor ce trebuie făcute.

'''Exemple''':
* '''''N'''''=1 ⇒ Ieșirea "141"
* '''''N'''''=2 ⇒ Ieșirea "14322341"

'''Complexitate cerută''': <math>O(N^2)</math>.

'''Timp de implementare''': 1h.

'''Timp de rulare''': 10 secunde pentru un test.

'''REZOLVARE''': La prima vedere, problema pare să se preteze la o rezolvare în timp exponențial, prin metoda „Branch and Bound”. Un neajuns al enunțului pare să fie faptul că nu se specifică dacă numărul de mutări efectuate trebuie sau nu să fie minim. Pentru a ne lămuri, să privim în detaliu soluțiile pentru '''''N'''''=1 și '''''N'''''=2:

* Pentru '''''N''''' = 1, toate mutările sunt forțate ((a) - se mută bila albă, (b) - se sare cu cea neagră peste ea, (c) - se mută din nou bila albă); trebuie remarcat că după mutările (a) și (b) se obțin două configurații simetrice una în raport cu cealaltă (oglindite).
* Pentru '''''N''''' = 2, se poate începe sărind cu bila albă de la margine peste cealaltă, dar această mutare ar duce la blocarea jocului. Este deci obligatoriu să se înceapă prin a împinge bila albă centrală (a). Următoarea mutare este forțată ((b) - se sare cu bila neagră peste cea albă), apoi toate mutările sunt obligate (în sensul că dacă la orice pas se face altă mutare decât cea care conduce la soluție, jocul se blochează în câteva mutări): (c) - se împinge bila neagră, (d), (e) - se sare de două ori cu bilele albe, (f) - se împinge bila neagră, (g) - se sare cu bila neagră, (h) - se împinge bila albă. Trebuie din nou remarcat că după mutările (c) și (e) se obțin două configurații simetrice.

Așadar în ambele cazuri, soluția este unică. De fapt, există două soluții asemănătoare, una dacă se începe cu o mutare a bilei albe și una dacă se începe cu o mutare a bilei negre. Fiindcă enunțul impune ca prima mutare să se facă cu o bilă albă, soluția este unică. Se mai observă și că, atât pentru '''''N'''''=1 cât și pentru '''''N'''''=2 șirul de mutări este simetric. Pentru a indica efectiv modul de determinare a soluției (care va sugera și ideea de scriere a programului) și pentru a explica observațiile de mai sus, să generalizăm observațiile făcute pentru un '''''N''''' oarecare.

* Configurația inițială este:

: [[File:Psycho-fig32.png]]

* Se împinge bila albă și se sare cu cea neagră peste ea (șirul de mutări 14):

: [[File:Psycho-fig33.png]]

* Se împinge bila neagră și se sare de două ori cu cele albe peste ea (șirul de mutări 322):

: [[File:Psycho-fig34.png]]

* Se împinge bila albă și se sare de trei ori cu cele negre peste ea (șirul de mutări 1444):

: [[File:Psycho-fig35.png]]

* Se împinge bila neagră și se sare de patru ori cu cele albe peste ea (șirul de mutări 32222):

: [[File:Psycho-fig36.png]]

: ...

* Se împinge bila albă (mutarea 1)

: [[File:Psycho-fig37.png]]

* Se sare de '''''N''''' ori cu cele negre peste ea (șirul de mutări 44..44):

: [[File:Psycho-fig38.png]]

Ultimele două configurații sunt simetrice. În acest moment șirul de mutări se inversează:

* Se împinge bila albă (mutarea 1):

: [[File:Psycho-fig39.png]]

...

* Se sare de patru ori cu bilele albe și se împinge bila neagră (șirul de mutări 22223):

: [[File:Psycho-fig40.png]]

* Se sare de trei ori cu bilele negre și se împinge bila albă (șirul de mutări 4441):

: [[File:Psycho-fig41.png]]

* Se sare de două ori cu bilele albe și se împinge bila neagră (șirul de mutări 223):

: [[File:Psycho-fig42.png]]

* Se sare cu bila neagră și se împinge bila albă (șirul de mutări 41), obținându-se configurația finală:

: [[File:Psycho-fig43.png]]

În concluzie, șirul de mutări este: o împingere - un salt - o împingere - două salturi - o împingere - trei salturi - ... - o împingere - '''''N'''''-1 salturi - o împingere - '''''N''''' salturi - o împingere - '''''N'''''-1 salturi - ... - o împingere - trei salturi - o împingere - două salturi - o împingere - un salt - o împingere, culorile alternând la fiecare pas.

Pentru a calcula numărul de mutări, putem să le numărăm pe măsură ce le efectuăm, dar deoarece se cere afișarea mai întâi a numărului de mutări și după aceea a mutărilor în sine, trebuie fie să stocăm toate mutările în memorie, fie să lucrăm cu fișiere temporare, ambele variante putând duce la complicații nedorite. Din fericire, numărul de mutări se poate calcula cu ușurință astfel: fiecare piesă albă trebuie mutată în medie cu '''''N''''' pași către dreapta și fiecare piesă neagră trebuie mutată cu '''''N''''' pași către stânga. Deci numărul total de pași este <math>2N(N+1).</math> Din secvența generală de mutări expusă mai sus se observă că nu se fac decât 2'''''N''''' împingeri de piese (mutări de un singur pas), restul fiind salturi (mutări de câte doi pași). Deci numărul de mutări este:

<math>2N + \frac{2N(N + 1) - 2N}{2} = 2N + N^2 = N(N + 2)</math>

De aici deducem că nu există un algoritm mai bun decât <math>O(N^2)</math>, deoarece numărul de mutări este <math>O(N^2)</math>. Propunem ca temă cititorului să demonstreze că nu există decât două succesiuni de mutări care rezolvă problema, din care una începe cu mutarea unei piese albe, iar cealaltă este oglindirea ei și începe cu mutarea unei piese negre, deci nu poate constitui o soluție corectă. Demonstrația începe prin a arăta că sunt necesare cel puțin 2'''''N''''' împingeri de piese. Această demonstrație explică de ce nu se cere un număr minim de mutări în enunț - cerința nu ar avea sens întrucât soluția este oricum unică. Acestea fiind zise, programul arată astfel:

<syntaxhighlight lang="c">
#include <stdio.h>
int N;
FILE *OutF;

void Jump(int Level, char A, char B)
{ int i;
putc(A,OutF);
for (i=1;i<=Level;i++) putc(B,OutF);
if (Level<N)
{
Jump(Level+1,'1'+'2'-A,'4'+'3'-B);
for (i=1;i<=Level;i++) putc(B,OutF);
}
putc(A,OutF);
}

void main(void)
{
printf("N=");scanf("%d",&N);
OutF=fopen("output.txt","wt");
fprintf(OutF,"%ld\n",(long)N*(N+2));
Jump(1,'1','4');
fprintf(OutF,"\n");
fclose(OutF);
}
</syntaxhighlight>

== Problema 2 ==

Problema următoare a fost propusă la a VI-a Olimpiadă Internațională de Informatică, Stockholm 1994. Este și ea un bun exemplu de situație în care putem cădea în plasa unei rezolvări „Branch and Bound” atunci când nu este cazul.

'''ENUNȚ''': Se dă o configurație de 3 x 3 ceasuri, fiecare având un singur indicator care poate arăta numai punctele cardinale (adică orele 3, 6, 9 și 12). Asupra acestor ceasuri se poate acționa în nouă moduri distincte, fiecare acțiune însemnând mișcarea limbilor unui anumit grup de ceasuri în sens orar cu 90°. În figura de mai jos se dă un exemplu de configurație inițială a ceasurilor și se arată care sunt cele nouă tipuri de mutări (pentru fiecare tip de mutare se mișcă numai ceasurile reprezentate hașurat).

[[File:Psycho-fig44.png]]

Se cere ca, într-un număr minim de mutări, să aducem toate indicatoarele la ora 12.

Intrarea se face din fișierul <tt>INPUT.TXT</tt>, care conține configurația inițială sub forma unei matrice 3 x 3. Pentru fiecare ceas se specifică câte o cifră: 0 = ora 12, 1 = ora 3, 2 = ora 6, 3 = ora 9.

Ieșirea se va face în fișierul <tt>OUTPUT.TXT</tt> sub forma unui șir de numere între 1 și 9, pe un singur rând, separate prin spațiu, reprezentând șirul de mutări care aduc ceasurile în starea finală. Se cere o singură soluție.

'''Exemplu''': Pentru figura de mai sus, fișierul <tt>INPUT.TXT</tt> este

<pre>
3 3 0
2 2 2
2 1 2
</pre>

iar fișierul <tt>OUTPUT.TXT</tt> ar putea fi:

<pre>
5 8 4 9
</pre>

'''Timp de implementare''': 1h - 1h 15min.

'''Timp de rulare''': o secundă.

'''Complexitate cerută''': <math>O(1)</math> (timp constant).

'''REZOLVARE''': Din câte am văzut pe la concursuri, peste jumătate din elevi s-ar apuca direct să implementeze o rezolvare Branch and Bound la această problemă, fără să-și mai bată capul prea mult. Există argumente în favoarea acestei inițiative:

* Mulți preferă să nu mai piardă timpul căutând o altă soluție, mai ales că problema seamănă mult cu „Lampa lui Dario Uri” (care de fapt este exact problema ceasurilor, dar în care ceasurile au doar două stări în loc de patru). În plus, se știe că pe cazul general al unei table '''''N''''' x '''''N''''', cele două probleme nu admit rezolvări polinomiale și atunci cea mai sigură soluție este prin tehnica Branch and Bound.
* De asemenea, se observă că numărul total de configurații posibile pentru o tablă cu 9 ceasuri este de <math>4^9</math>, adică aproximativ un sfert de milion. Un algoritm Branch and Bound ar furniza așadar o soluție în timp rezonabil. Raționamentul multor elevi este „decât să pierd timpul căutând o soluție mai bună, fără să am certitudinea că o voi găsi, mai bine folosesc timpul implementând un Branch care măcar știu sigur că merge”.
* Problema cere o soluție într-un număr minim de pași, lucru care îi cam descurajează pe cei care încă ar vrea să caute alte rezolvări. „Alte rezolvări” înseamnă de obicei un Greedy comod de implementat, iar asupra rezolvărilor Greedy se poartă întotdeauna discuții interminabile pe culoarele sălilor de concurs referitor la „cât de bune sunt” (adică în cât la sută din cazuri furnizează soluția optimă).

Se pierd însă din vedere unele lucruri esențiale. În primul rând, tabla nu este de '''''N''''' x '''''N''''', ci are dimensiuni fixate, 3 x 3. În al doilea rând, implementarea unui Branch and Bound în timp de concurs este o aventură nu tocmai ușor de dus la bun sfârșit (personal mi-a fost frică să o încerc vreodată). În sfârșit, după cum se va vedea mai jos, problema șirului minim de transformări este o pseudo-problemă, deoarece soluția simplă este oricum unică.

Ce se înțelege prin „soluție simplă”? Să remarcăm două lucruri:

# Aplicarea de patru ori a aceleiași mutări nu schimbă nimic în configurația ceasurilor. Într-adevăr, mutarea va afecta de fiecare dată același grup de ceasuri, iar aplicarea de patru ori va roti fiecare indicator cu 360°, adică îl va aduce în poziția inițială. Din acest motiv, toate afirmațiile făcute în cele ce urmează vor fi valabile în algebra modulo 4.
# Ordinea în care se aplică transformările nu contează.

În consecință, prin „soluție simplă” se înțelege un șir de mutări ordonat crescător în care nici o mutare nu apare de mai mult de trei ori. Să demonstrăm acum că soluția simplă este unică.

Fie <math>A \in M_3(\mathbb{Z}_4)</math> matricea citită de la intrare, unde <math>a_{i,j}</math> arată de câte ori a fost rotit ceasul <math>C_{i,j}</math> peste ora 12. Fie matricea <math>B \in M_3(\mathbb{Z}_4),
b_{i,j}=4 - a_{i,j}</math>. Matricea '''''B''''' arată de câte ori mai trebuie rotit fiecare ceas până la ora 12. O soluție înseamnă a efectua fiecare din cele 9 mutări de un număr de ori, <math>p_1, p_2, \dots, p_9</math>. Cum afectează aceste mutări ceasurile? Se poate deduce ușor:

{|class="wikitable"
! Ceasul || Tipurile de mutări care îl afectează
|-
| <math>C_{1,1}</math> || 1, 2, 4
|-
| <math>C_{1,2}</math> || 1, 2, 3, 5
|-
| <math>C_{1,3}</math> || 2, 3, 6
|-
| <math>C_{2,1}</math> || 1, 4, 5, 7
|-
| <math>C_{2,2}</math> || 1, 3, 5, 7, 9
|-
| <math>C_{2,3}</math> || 3, 5, 6, 9
|-
| <math>C_{3,1}</math> || 4, 7, 8
|-
| <math>C_{3,2}</math> || 5, 7, 8, 9
|-
| <math>C_{3,3}</math> || 6, 8, 9
|}

Se obține deci un sistem de 9 ecuații cu 9 necunoscute:

<math>
P =
\begin{pmatrix}
p_1 + p_2 + p_4 & p_1 + p_2 + p_3 + p_5 & p_2 + p_3 + p_6 \\
p_1 + p_4 + p_5 + p_7 & p_1 + p_3 + p_5 + p_7 + p_9 & p_3 + p_5 + p_6 + p_9 \\
p_4 + p_7 + p_8 & p_5 + p_7 + p_8 + p_9 & p_6 + p_8 + p_9 \\
\end{pmatrix}
\equiv B
</math>

Să presupunem că acest sistem admite două soluții <math>p_1, p_2, \dots, p_9</math> și <math>q_1, q_2, \dots, q_9</math>. Atunci <math>P \equiv B \pmod{4}</math> și <math>Q \equiv B \pmod{4}</math>, deci <math>P \equiv Q \pmod{4}</math> și, prin diferite combinații liniare ale celor 9 ecuații se deduce <math>p_1 \equiv q_1</math>, <math>p_2 \equiv q_2</math>, ..., <math>p_9 \equiv q_9 \pmod{4}</math>, adică cele două soluții sunt echivalente.

Odată ce am demonstrat că soluția este unică, algoritmul de găsire a ei este foarte simplu: găsim o soluție oarecare, o ordonăm crescător și eliminăm orice grup de 4 mutări identice. Pentru a găsi o soluție oarecare, avem nevoie de niște mutări predefinite care să miște un singur ceas cu o singură poziție înainte, fără a afecta celelalte ceasuri. Aceste mutări vor fi reținute sub forma unui vector cu 9 componente, fiecare componentă indicând de câte ori se efectuează fiecare din cele 9 tipuri de mutări. Deoarece avem nevoie de 9 asemenea mutări predefinite, câte una pentru fiecare ceas, rezultatul va fi o matrice predefinită. De exemplu, pentru a determina secvența de mutări care rotește ceasul <math>C_{1,1}</math> cu o poziție, trebuie rezolvat sistemul

<math>
\begin{pmatrix}
p_1 + p_2 + p_4 & p_1 + p_2 + p_3 + p_5 & p_2 + p_3 + p_6 \\
p_1 + p_4 + p_5 + p_7 & p_1 + p_3 + p_5 + p_7 + p_9 & p_3 + p_5 + p_6 + p_9 \\
p_4 + p_7 + p_8 & p_5 + p_7 + p_8 + p_9 & p_6 + p_8 + p_9 \\
\end{pmatrix}
\equiv
\begin{pmatrix}
1 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}
</math>

lucru care nu este foarte ușor, dar se poate duce la bun sfârșit în timp de concurs. Soluția este <math>p_1=3, p_2=3, p_3=3, p_4=3, p_5=3, p_6=2, p_7=3, p_8=2, p_9=0</math>, adică mutarea 1 trebuie efectuată de trei ori, mutarea 2 de trei ori ș.a.m.d. Se obține prima linie din matricea predefinită, (3, 3, 3, 3, 3, 2, 3, 2, 0). Mai trebuie rezolvate propriu-zis sistemele de ecuații pentru ceasurile <math>C_{1,2}</math> și <math>C_{2,2}</math>, soluțiile celorlalte sisteme decurgând ușor prin simetrie. Soluțiile apar în textul sursă.

Odată determinate aceste șiruri elementare de mutări, vom lua pe rând fiecare ceas, vom aplica șirul elementar corespunzător de atâtea ori cât e nevoie pentru a-l aduce la ora 12 și vom aduna modulo 4 toate mutările făcute. Vectorul sumă care rezultă este tocmai soluția noastră.

Pentru exemplul din enunț, folosind constantele din programul sursă, obținem:

<math>
B =
\begin{pmatrix}
1 & 1 & 0 \\
2 & 2 & 2 \\
2 & 3 & 2
\end{pmatrix}
</math>

și

{|
| 1 x (3,3,3,3,3,2,3,2,0) = || (3,3,3,3,3,2,3,2,0) +
|-
| 1 x (2,3,2,3,2,3,1,0,1) = || (2,3,2,3,2,3,1,0,1)
|-
| 0 x (3,3,3,2,3,3,0,2,3) = || (0,0,0,0,0,0,0,0,0)
|-
| 2 x (2,3,1,3,2,0,2,3,1) = || (0,2,2,2,0,0,0,2,2)
|-
| 2 x (2,3,2,3,1,3,2,3,2) = || (0,2,0,2,2,2,0,2,0)
|-
| 2 x (1,3,2,0,2,3,1,3,2) = || (2,2,0,0,0,2,2,2,0)
|-
| 2 x (3,2,0,3,3,2,3,3,3) = || (2,0,0,2,2,0,2,2,2)
|-
| 3 x (1,0,1,3,2,3,2,3,2) = || (3,0,3,1,2,1,2,1,2)
|-
| 2 x (0,2,3,2,3,3,3,3,3) = || (0,0,2,0,2,2,2,2,2)
|-
| || ------------------------
|-
| || (0,0,0,1,1,0,0,1,1)
|}

Prin urmare soluția simplă a exemplului este: 4 5 8 9.

<syntaxhighlight lang="c">
#include <stdio.h>
typedef int Matrix[9][9];
typedef int Vector[9];
const Matrix A=
{{3,3,3,3,3,2,3,2,0}, // Mutarile care misca ceasul C11
{2,3,2,3,2,3,1,0,1}, // .
{3,3,3,2,3,3,0,2,3}, // .
{2,3,1,3,2,0,2,3,1}, // .
{2,3,2,3,1,3,2,3,2}, // .
{1,3,2,0,2,3,1,3,2}, // .
{3,2,0,3,3,2,3,3,3}, // .
{1,0,1,3,2,3,2,3,2}, // .
{0,2,3,2,3,3,3,3,3}}; // Mutarile care misca ceasul C33

void main(void)
{ FILE *F=fopen("input.txt","rt");
Vector V={0,0,0,0,0,0,0,0,0}; // Vectorul suma
int i,j,k;

for (i=0;i<=8;i++)
{ fscanf(F,"%d",&k);
for (j=0;j<=8;j++)
V[j]=(V[j]+(4-k)*A[i][j])%4;
}
fclose(F);

F=fopen("output.txt","wt");
for(i=0;i<=8;i++)
for(j=1;j<=V[i];j++)
fprintf(F,"%d ",i+1);
fclose(F);
}
</syntaxhighlight>

== Problema 3 ==

Problema de mai jos este un exemplu de situație în care căutarea exhaustivă a soluției este cea mai bună alegere. Ea a fost propusă spre rezolvare la a VIII-a Olimpiadă Internațională de Informatică, Veszprem, Ungaria 1996.

'''ENUNȚ''': Văzând succesul cubului său magic, Rubik a inventat versiunea plană a jocului, numit „pătrate magice”. Se folosește o tablă compusă din 8 pătrate de dimensiuni egale. Cele opt pătrate au culori distincte, codificate prin numere de la 1 la 8, ca în figura următoare:

[[File:psycho-fig45.png]]

Configurația tablei se poate reprezenta într-un vector cu 8 elemente citind cele opt pătrate, începând din colțul din stânga sus și mergând în sens orar. De exemplu, configurația din figură se reprezintă prin vectorul (1, 2, 3, 4, 5, 6, 7, 8). Aceasta este configurația inițială a tablei.

Unei configurații i se pot aplica trei transformări elementare, identificate prin literele „A”, „B” și „C”:

* „A” schimbă între ele cele două linii ale tablei;
* „B” rotește circular spre dreapta întregul dreptunghi (cu o poziție);
* „C” rotește în sens orar cele patru pătrate centrale (cu o poziție);

Efectele transformărilor elementare asupra configurației inițiale sunt reprezentate în figura de mai jos:

[[File:psycho-fig46.png]]

Din configurația inițială se poate ajunge în orice configurație folosind numai combinații de tranformări elementare. Trebuie să scrieți un program care calculează o secvență de transformări elementare care să aducă tabla de la configurația inițială la o anumită configurație finală cerută.

'''Intrarea''': Fișierul <tt>INPUT.TXT</tt> conține 8 întregi pe aceeași linie, separați prin spații, descriind configurația finală.

Ieșirea se va face în fișierul <tt>OUTPUT.TXT</tt>. Pe prima linie a acestuia se va tipări lungimea '''''L''''' a secvenței de transformări, iar pe fiecare din următoarele '''''L''''' linii se va tipări câte un caracter „A”, „B” sau „C”, corespunzător mutărilor care trebuie efectuate.

'''Exemplu''':

{|class="wikitable
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>2 6 8 4 5 7 3 1</tt>
| <tt>7 B C A B C C B</tt>
|}

'''Timp limită pentru un test''': 20 secunde.

'''Timp de implementare''': 1h 30’ - 1h 45’

'''Note''':

# La concurs s-au acordat, pentru fiecare test, două puncte dacă se furniza o soluție și încă două dacă lungimea ei nu depășea 300 de mutări.
# Concurenților li s-a furnizat un program auxiliar, <tt>MTOOL.EXE</tt>, cu care se puteau verifica soluțiile furnizate.

'''REZOLVARE''': Și la această problemă se întrevăd două abordări, ca și în problema ceasurilor: una bazată pe mutări predefinite, iar cealaltă pe o căutare exhaustivă a soluției. De data aceasta însă, prima este neinspirată. Să le analizăm pe rând pe fiecare, plecând de la următoarele considerente:

* Dacă se aplică de două ori la rând mutarea A, tabla rămâne nemodificată;
* Dacă se aplică de patru ori consecutiv una din mutările B sau C, tabla rămâne nemodificată;
* Ordinea în care se efectuează mutările contează.

Soluția pe care autorul a prezentat-o la concurs avea predefinite mai multe mutări care schimbau între ele oricare două pătrate vecine de pe tablă. Mergând din aproape în aproape, fiecare pătrat era adus în poziția corespunzătoare. Spre exemplu, succesiunea de mutări predefinite care duceau la configurația din exemplu este:

[[File:psycho-fig47.png]]

Această soluție funcționează instantaneu și este relativ ușor de implementat. Ea are însă defectul că soluția furnizată este extrem de lungă, ajungând frecvent la 500 de mutări. Din cele zece teste date, numai trei s-au încadrat în limita de 300 de mutări. Iată mai jos și sursa Pascal prezentată la concurs, care a câștigat numai 26 din cele 40 de puncte acordate pentru problemă:

<syntaxhighlight>
program Magic;
{$B-,I-,R-,S-}
{ Tabla este 1 2 3 4
A B C D }
const r12='BCBBB'; { Roteste in sens orar coloanele 12 }
r23='C'; { Roteste in sens orar coloanele 23 }
r34='BBBCB'; { Roteste in sens orar coloanele 34 }
r14='BBCBB'; { Roteste in sens orar coloanele 41 }

plBCD=r12+r23+r34+r14; { Permuta patratele BCD }
PL234=plBCD+'A'+plBCD+'A'; { Permuta coloanele 234 }

{ SXY schimba intre ele coloanele X si Y }
S14='B'+PL234;
S12='BBB'+S14+'B';
S23='BB'+S14+'BB';
S34='B'+S14+'BBB';
S13=r12+r12+r23+r23+r12+r12;
S24='B'+S13+'BBB';

{ RevXY schimba intre ele patratele vecine X si Y }
RevC3=plBCD+r23+r12+r12+r34+r34+'BBB'+plBCD+'A';
RevD4='BBB'+RevC3+'B';
RevB2='B'+RevC3+'BBB';
RevA1='BB'+RevC3+'BB';

Rev23='C'+RevC3+'CCC';
Rev12='B'+Rev23+'BBB';
Rev34='BBB'+Rev23+'B';
Rev14='BB'+Rev23+'BB';

RevAB='A'+Rev12+'A';
RevBC='A'+Rev23+'A';
RevCD='A'+Rev34+'A';
RevAD='A'+Rev14+'A';

type Matrix=array[1..2,1..4] of Integer;
Vector=array[1..60000] of Char;
var A,B:Matrix;
V:Vector;
N:Integer;

procedure MakeAMatrix;
begin
A[1,1]:=1;
A[1,2]:=2;
A[1,3]:=3;
A[1,4]:=4;
A[2,1]:=8;
A[2,2]:=7;
A[2,3]:=6;
A[2,4]:=5;
end;

procedure ReadBMatrix;
begin
Assign(Input,'input.txt');
Reset(Input);
Read(B[1,1]);
Read(B[1,2]);
Read(B[1,3]);
Read(B[1,4]);
Read(B[2,4]);
Read(B[2,3]);
Read(B[2,2]);
Read(B[2,1]);
Close(Input);
end;

procedure AddString(S:String);
{ Adauga o secventa la sirul-solutie }
var i:Integer;
begin
for i:=1 to Length(S) do
begin
Inc(N);
V[N]:=S[i];
end;
end;

procedure FindElement(K:Integer;var X,Y:Integer);
{ Cauta un element intr-o permutare }
var i,j:Integer;
begin
for i:=1 to 2 do
for j:=1 to 4 do
if A[i,j]=K then begin
X:=i;
Y:=j;
Exit;
end;
end;

procedure Switch(var X,Y:Integer);
{ Schimba intre ele doua numere }
var IAux:Integer;
begin
IAux:=X;X:=Y;Y:=IAux;
end;

procedure Process;
{ Transforma pozitia in pozitia B prin schimbari
repetate ale elementelor vecine }
var i,j,k,l,m:Integer;
begin
for j:=1 to 4 do
for i:=1 to 2 do
begin
FindElement(B[i,j],k,l);
{ Gaseste elementul care trebuie adus
pe pozitia (i,j) }
if k<>i then begin
{ Il aduce pe linia corecta }
case l of
1:AddString(RevA1);
2:AddString(RevB2);
3:AddString(RevC3);
4:AddString(RevD4);
end; {case}
Switch(A[k,l],A[i,l]);
k:=i;
end;
for m:=l downto j+1 do
{ Il aduce pe coloana corecta }
begin
if k=1
then case m of
2:AddString(Rev12);
3:AddString(Rev23);
4:AddString(Rev34);
end
else case m of
2:AddString(RevAB);
3:AddString(RevBC);
4:AddString(RevCD);
end;
Switch(A[k,m],A[k,m-1]);
end;
end;
end;

procedure Cut(K,D:Integer);
{ Taie din vectorul V D pozitii incepand cu K }
var i:Integer;
begin
for i:=K to N-D do
V[i]:=V[i+D];
Dec(N,D);
end;

procedure Reduce;
{ Reduce secventele de mutari identice }
var i:Integer;
begin
i:=1;
repeat
case V[i] of
'A':if (i<=N-1) and (V[i+1]='A')
then Cut(i,2)
else Inc(i);
'B':if (i<=N-3) and (V[i+1]='B')
and (V[i+2]='B') and (V[i+3]='B')
then Cut(i,4)
else Inc(i);
'C':if (i<=N-3) and (V[i+1]='C')
and (V[i+2]='C') and (V[i+3]='C')
then Cut(i,4)
else Inc(i);
end; {case}
until i=N;
end;

procedure WriteSolution;
var i:Integer;
begin
Assign(Output,'output.txt');
Rewrite(Output);
WriteLn(N);
for i:=1 to N do WriteLn(V[i]);
Close(Output);
end;

begin
N:=0;
MakeAMatrix;
ReadBMatrix;
Process;
Reduce;
WriteSolution;
end.
</syntaxhighlight>

Singura soluție pare deci a fi una de tipul Branch and Bound, care nu este tocmai la îndemână. Cu toate acestea, numărul total de configurații posibile ale tablei este de numai 8! = 40320. Într-adevăr, fiecare poziție de pe tablă se reprezintă printr-o permutare a mulțimii {1,2,3,4,5,6,7,8}. Se poate face deci cu ușurință o căutare exhaustivă a soluției. Aceasta simplifică mult structurile de date folosite (implementarea Branch & Bound folosește structuri destul de încâlcite). În plus, practica arată că se poate ajunge în orice configurație în mai puțin de 25 de mutări.

Algoritmul de căutare este cunoscut sub numele de algoritmul lui Lee și are la bază următoarea idee: Se pornește cu configurația inițială, care este depusă într-o coadă. La fiecare pas se extrage prima configurație disponibilă din coadă, se efectuează pe rând fiecare din cele trei mutări și se obțin trei succesori. Aceștia sunt adăugați la sfârșitul cozii, dacă nu există deja în coadă. Acest pas se numește '''expandare'''. Expandarea continuă până când elementul selectat spre expandare este tocmai configurația finală.

Figura următoare indică modul de expandare a cozii, cu mențiunea că printr-o succesiune de litere ne-am referit la configurația care se obține efectuând mutările respective:

[[File:psycho-fig48.png]]

Se observă că, la pasul 2, în coadă au fost adăugate doar configurațiile „AB” și „AC”, iar configurația „AA” nu, deoarece prin efectuarea de două ori a mutării „A” se revine la configurația inițială, care a fost deja expandată. De asemenea, la pasul 3, după expandarea configurației „B” au fost adăugate în coadă numai configurațiile „BB” și „BC”, deoarece configurația „BA” este echivalentă cu configurația „AB”, aflată deja în listă.

Pseudocodul algoritmului este:

<pre>
citeste datele de intrare
initializeaza coada cu configuratia initiala
cat timp primul element al cozii nu este configuratia finala:
expandeaza primul element al cozii
pentru i=[A,B,C]
daca succesorul i nu a fost deja pus in coada atunci
adauga succesorul i in coada
sterge primul element al cozii
reconstituie sirul de mutari
</pre>

Algoritmul de mai sus garantează și găsirea soluției optime (în număr minim de mutări). Rămân de lămurit două lucruri: (1) Cum ne dăm seama dacă o configurație există deja în coadă și (2) cum se face reconstituirea soluției.

Pentru a afla dacă o configurație mai există în listă, cea mai simplă metodă ar fi o căutare secvențială a listei. Totuși, această versiune ar fi extrem de lentă, deoarece coada atinge rapid dimensiuni respectabile (de ordinul miilor de elemente). În plus, un element al listei ar reține configurația propriu-zisă (un vector cu opt elemente), ceea ce ar duce la un consum ridicat de memorie. Testul de egalitate a doi vectori ar fi și el costisitor din punct de vedere al timpului.

Există însă o altă metodă mai simplă. Am demonstrat că numărul de configurații posibile ale tablei este 8! = 40320. Dacă am putea găsi o funcție bijectivă <math>H: \mathbf{P_8} \to \{0, 1, \dots, 40319\}</math>, unde <math>\mathbf{P_8}</math> este mulțimea permutărilor de 8 elemente, atunci ar fi suficient un vector caracteristic cu 40320 elemente. De îndată ce introducem în coadă o nouă configurație '''''K''''', nu avem decât să bifăm elementul corespunzător din vectorul caracteristic. Înainte de a adăuga o configurație în coadă, testăm dacă nu cumva elementul corespunzător ei a fost deja bifat, semn că nodul a mai fost vizitat.

Cum se construiește funcția '''''H'''''? Pentru orice permutare <math>p \in \mathbf{P_8}</math>, <math>H(p)</math> este poziția lui '''''p''''' în ordonarea lexicografică a lui <math>\mathbf{P_8}</math> (începând de la 0):

: H(1, 2, 3, 4, 5, 6, 7, 8) = 0 
: H(1, 2, 3, 4, 5, 6, 8, 7) = 1 
: H(1, 2, 3, 4, 5, 7, 6, 8) = 2 
: .................................... 
: H(8, 7, 6, 5, 4, 3, 1, 2) = 40318 
: H(8, 7, 6, 5, 4, 3, 2, 1) = 40319 

Se observă că primele 7! = 5040 elemente din ordonare au pe prima poziție un 1, următoarele 5040 au pe prima poziție un 2 etc. De asemenea, dintre elementele care au pe prima poziție un 1, primele 6! = 720 au pe a doua poziție un 2, următoarele 720 au pe a doua poziție un 3 etc.

Să calculăm de exemplu '''''H'''''(2, 6, 8, 4, 5, 7, 3, 1). Prima cifră a permutării este 2, deci se adaugă 7! = 5040. Rămân cifrele 1, 3, 4, 5, 6, 7 și 8. A doua cifră a permutării este 6, a cincea ca valoare dintre cifrele rămase, deci se adaugă 4 x 6! = 2880. Rămân cifrele 1, 3, 4, 5, 7 și 8 etc. Se aplică procedeul până la ultima cifră și rezultă:

{|class="wikitable"
! Cifre rămase || Permutarea || Valoarea adăugată
|-
| 1, 2, 3, 4, 5, 6, 7, 8
| 2
| 1 x 7! = 5040
|-
| 1, 3, 4, 5, 6, 7, 8
| 6
| 4 x 6! = 2880
|-
| 1, 3, 4, 5, 7, 8
| 8
| 5 x 5! = 600
|-
| 1, 3, 4, 5, 7
| 4
| 2 x 4! = 48
|-
| 1, 3, 5, 7
| 5
| 2 x 3! = 12
|-
| 1, 3, 7
| 7
| 2 x 2! = 4
|-
| 1, 3
| 3
| 1 x 1! = 1
|-
| 1
| 1
| 0 x 0! = 0
|-
|
|
| '''''H'''''('''''p''''') = 8585
|}

Reciproc se construiește permutarea când i se cunoaște valoarea atașată:

{|class="wikitable"
! Cifre nefolosite || H('''''p''''') || || Cifra selectată ||
|-
| 1, 2, 3, 4, 5, 6, 7, 8
| 8585
| 8585 div 7! = 1
| 2
| 8585 mod 7! = 3545
|-
| 1, 3, 4, 5, 6, 7, 8
| 3545
| 3545 div 6! = 4
| 6
| 3545 mod 6! = 665
|-
| 1, 3, 4, 5, 7, 8
| 665
| 665 div 5! = 5
| 8
| 665 mod 5! = 65
|-
| 1, 3, 4, 5, 7
| 65
| 65 div 4! =2
| 4
| 65 mod 4! = 17
|-
| 1, 3, 5, 7
| 17
| 17 div 3! = 2
| 5
| 17 mod 3! = 5
|-
| 1, 3, 7
| 5
| 5 div 2! = 2
| 7
| 5 div 2! = 1
|-
| 1, 3
| 1
| 1 div 1!=1
| 3
| 1 mod 1! = 0
|-
| 1
| 0
| 0 div 0!=0
| 1
|
|}

Rezultă '''''p'''''=(2, 6, 8, 4, 5, 7, 3, 1).

Această metodă de căutare are și avantajul că în listă se va ține un singur număr pe doi octeți, făcându-se economie de memorie. Expandarea unui nod constă din trei pași:

# Se extrage primul număr din listă și se reconstituie configurația atașată;
# Se fac cele trei mutări, obținându-se trei succesori;
# Pentru fiecare succesor se calculează funcția '''''H''''' și dacă configurația nu este găsită în listă, este adăugată.

Pentru a face reconstituirea soluției avem nevoie de date suplimentare. Respectiv, vectorul caracteristic atașat permutărilor nu va mai reține doar dacă o poziție a fost „văzută” sau nu, ci și poziția din care ea provine (prin valoarea funcției '''''H'''''). Trebuie de asemenea reținut tipul mutării (A, B sau C) prin care s-a ajuns în acea configurație. Cei doi vectori se numesc <tt>Father</tt> și <tt>MoveKind</tt>. Inițial, toate elementele vectorului <tt>Father</tt> au eticheta „Unknown”, semnificând că nodurile nu au fost încă vizitate, cu excepția elementului atașat configurației inițiale, care poartă eticheta specială „Root” (rădăcină).

Pseudocodul pentru expandarea unui nod arată cam așa:

<pre>
K ← primul numar din coada
P ← H-1(K)
afla cei trei succesori QA, QB, QC
pentru i=A,B,C
daca Father[H(Qi)]=Unknown atunci
Father[H(Qi)] ← K
MoveKind[H(Qi)] ← i
adauga H(Qi) in coada
sterge K din coada
</pre>

Reconstituirea soluției se face recursiv: se pornește de la configurația finală și se merge înapoi (folosind informația din vectorul <tt>Father</tt>) până la configurația inițială, măsurându-se astfel numărul de mutări. La revenire se tipăresc toate mutările efectuate (folosind informația din vectorul <tt>MoveKind</tt>).

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#define Unknown 0xFFFF
#define Root 0xFFFE

typedef huge unsigned Vector[40320];
typedef char CharVector[40320];
typedef int Perm[8];
typedef struct list { unsigned X; struct list * Next; } List;

Perm StartPerm={1,2,3,4,5,6,7,8}, EndPerm;
const Perm Moves[3]=
{{7,6,5,4,3,2,1,0},
{3,0,1,2,5,6,7,4},
{0,6,1,3,4,2,5,7}};
/* Cele trei tipuri de mutari */
Vector Father; /* Legaturile de tip tata */
CharVector MoveKind;
unsigned StartValue,EndValue;
/* Valorile atasate configuratiilor initiala si finala */
List *Head, *Tail; /* Coada de expandat */

/**** Bijectia care asociaza un numar unei permutari ****/

unsigned Perm2Int(Perm P)
{ int i,j,k,Fact=5040;
unsigned Sum=0;

for (i=0;i<=6;i++)
{ k=P[i]-1;
for (j=0;j<i;j++)
if (P[j]<P[i]) k--;
Sum+=k*Fact;
Fact/=(7-i);
}
return Sum;
}

void Int2Perm(unsigned Sum, Perm P)
{ int i,j,k,Order,Fact=5040;
Perm Used={0,0,0,0,0,0,0,0};

for (i=0;i<=7;i++)
{ Order=Sum/Fact;
j=-1;
for (k=0;k<=Order;k++)
do j++; while (Used[j]);
Used[j]=1;
P[i]=j+1;
Sum%=Fact;
if (i!=7) Fact/=(7-i);
}
}

/**** Lucrul cu liste ****/

void InitList(void)
{
Head=Tail=malloc(sizeof(List));
Tail->X=StartValue;
Tail->Next=NULL;
}

void AddToTail(unsigned K)
{
Tail->Next=malloc(sizeof(List));
Tail=Tail->Next;
Tail->X=K;
Tail->Next=NULL;
}

void Behead(void)
/* Sterge capul listei */
{ List *LCor=Head;

Head=Head->Next;
free(LCor);
}

/**** Cautarea propriu-zisa ****/

void MakeMove(Perm P,Perm Q,int Kind)
/* Kind = 0, 1 sau 2 */
{ int i;
for (i=0;i<=7;i++)
Q[i]=P[Moves[Kind][i]];
}

void Expand(void)
{ List *LCor;
Perm P1,P2;
unsigned i,XSon,Done;

InitList();
do {
Int2Perm(Head->X,P1);
for(i=0;i<=2;i++)
{ MakeMove(P1,P2,i);
XSon=Perm2Int(P2);
if (Father[XSon]==Unknown)
{ Father[XSon]=Head->X;
MoveKind[XSon]=i+65;
AddToTail(XSon);
}
}
Done=(Head->X==EndValue);
Behead(); }
while (!Done);
}

/* Intrarea si iesirea */

void InitData(void)
{ FILE *F=fopen("input.txt","rt");
unsigned i;

for (i=0;i<=7;i++) fscanf(F,"%d",&EndPerm[i]);
fclose(F);
StartValue=Perm2Int(StartPerm);
EndValue=Perm2Int(EndPerm);
for (i=0;i<40320;) Father[i++]=Unknown;
Father[StartValue]=Root;
}

void WriteMove(FILE *F,unsigned K,int Len)
{
if (K!=StartValue)
{ WriteMove(F,Father[K],Len+1);
fprintf(F,"%c\n",MoveKind[K]);
}
else fprintf(F,"%d\n",Len);
}

void Restore(void)
{ FILE *F=fopen("output.txt","wt");

WriteMove(F,EndValue,0);
fclose(F);
}

void main(void)
{
InitData();
Expand();
Restore();
}
</syntaxhighlight>

== Problema 4 ==

Continuăm cu o problemă care a fost de asemenea dată spre rezolvare la a VIII-a Olimpiadă Internațională de Informatică, Veszprem 1996. Problema în sine nu a fost foarte grea și mulți elevi au luat punctaj maxim. Totuși, enunțul permite unele modificări interesante care practic schimbă cu totul problema.

'''ENUNȚ''': Să considerăm următorul joc de două persoane. Tabla de joc constă într-o secvență de întregi pozitivi. Cei doi jucători mută pe rând. Mutarea fiecărui jucător constă în alegerea unui număr de la unul din cele două capete ale secvenței. Numărul ales este șters de pe tablă. Jocul se termină când toate numerele au fost selectate. Primul jucător câștigă dacă suma numerelor alese de el este mai mare sau egală cu cea a numerelor alese de cel de-al doilea jucător. În caz contrar, câștigă al doilea jucător.

Dacă tabla conține inițial un număr par de elemente, atunci primul jucător are o strategie de câștig. Trebuie să scrieți un program care implementează strategia cu care primul jucător câștigă jocul. Răspunsurile celui de-al doilea jucător sunt date de un program rezident. Cei doi jucători comunică prin trei proceduri ale modulului <tt>Play</tt> care v-a fost pus la dispoziție. Procedurile sunt <tt>StartGame</tt>, <tt>MyMove</tt> și <tt>YourMove</tt>. Primul jucător începe jocul apelând procedura fără parametri <tt>StartGame</tt>. Dacă alege numărul de la capătul din stânga, el va apela procedura <tt>MyMove('L')</tt>. Analog, apelul de procedură <tt>MyMove('R')</tt> trimite un mesaj celui de-al doilea jucător prin care îl informează că a ales numărul de la capătul din dreapta. Cel de-al doilea jucător, deci computerul, mută imediat, iar primul jucător poate afla mutarea acestuia executând procedura <tt>YourMove(C)</tt>, unde <tt>C</tt> este o variabilă de tip <tt>Char</tt> (în C/C++ apelul este <tt>YourMove(&C)</tt>). Valoarea lui <tt>C</tt> este <tt>'L'</tt> sau <tt>'R'</tt>, după cum numărul ales este de la capătul din stânga sau din dreapta.

'''Intrarea''': Prima linie din fișierul <tt>INPUT.TXT</tt> conține dimensiunea inițială '''''N''''' a tablei. '''''N''''' este par și 2 ≤ '''''N''''' ≤ 100. Următoarele '''''N''''' linii conțin fiecare câte un număr, reprezentând conținutul tablei de la stânga la dreapta. Fiecare număr este cel mult 200.

'''Ieșirea''': Când jocul se termină, programul trebuie să scrie rezultatul final în fișierul <tt>OUTPUT.TXT</tt>. Fișierul conține două numere pe prima linie, reprezentând suma numerelor alese de primul, respectiv de cel de-al doilea jucător. Programul trebuie să joace un joc corect și ieșirea trebuie să corespundă jocului jucat.

'''Exemplu''':

{|class="wikitable
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>6 4 7 2 9 5 2</tt>
| <tt>15 14</tt>
|}

'''Timp limită de execuție''': 20 secunde pentru un test.

Acesta a fost enunțul original, la care va trebui să facem câteva modificări, în parte deoarece nu putem folosi modulul <tt>Play</tt>, în parte pentru a face problema mai restrictivă:

* Mutările vor fi anunțate pe ecran prin tipărirea unui caracter <tt>'L'</tt> sau <tt>'R'</tt>;
* Mutările celui de-al doilea jucător vor fi comunicate de un partener uman, prin introducerea de la tastatură a unui caracter <tt>'L'</tt> sau <tt>'R'</tt>;
* Rezultatul final se va tipări pe ecran, sub aceeași formă (pereche de numere).
* Timpul de gândire pentru fiecare mutare trebuie să fie cât mai mic (practic răspunsul să fie instantaneu);
* '''Complexitatea totală''' a calculelor efectuate să fie <math>O(N)</math>.
* '''Timpul de implementare''' a fost cam de 1h 40 min. Propunem reducerea lui la 30 minute.

'''REZOLVARE''': Este ușor de demonstrat că o rezolvare „greedy” a problemei (la fiecare mutare jucătorul 1 alege numărul mai mare) nu atrage întotdeauna câștigul. Iată un contraexemplu:

[[File:Psycho-fig49.png]]

La prima mutare, jucătorul 1 poate să aleagă fie numărul 7, fie numărul 2. Dacă se va „lăcomi” la 7, jucătorul 2 va lua numărul 10 și inevitabil va câștiga. Soluția pentru primul jucător este să ia numărul 2, apoi, indiferent de ce va juca partenerul său, va putea lua numărul 10 și va câștiga.

Iată o soluție izbitor de simplă de complexitate <math>O(N)</math>: La citirea datelor se face suma elementelor aflate pe poziții pare și a celor aflate pe poziții impare. Să presupunem că suma elementelor de ordin par este mai mare sau egală cu cea a elementelor de ordin impar (cazul invers se tratează analog). Atunci, dacă primul jucător ar putea să aleagă toate elementele de ordin par (care sunt într-adevăr '''''N'''''/2, adică atâtea câte are el dreptul să aleagă), ar câștiga jocul. Jucătorul 1 poate începe jocul prin a lua primul sau ultimul element din secvență, deci îl va alege pe ultimul, care are număr de ordine par. Al doilea jucător are de ales între primul și al '''''N'''''-1-lea element, ambele având număr de ordine impar. Indiferent ce variantă o va adopta, primul jucător va avea din nou acces la un element de pe o poziție pară. Dacă jucătorul 2 alege elementul din stânga (primul), atunci jucătorul 1 va putea lua elementul de după el (al doilea), iar dacă jucătorul 2 alege elementul din dreapta (al '''''N'''''-1-lea), atunci jucătorul 1 va putea lua elementul dinaintea el (al '''''N'''''-2-lea). Deci primul jucător nu are altceva de făcut decât să repete mutările făcute de cel de-al doilea. Să privim de exemplu desfășurarea jocului pe tabla dată în enunț:

[[File:Psycho-fig50.png]]

Programul în sine nici nu are nevoie să mai rețină vectorul de numere în memorie, din moment ce primul jucător nu are altceva de făcut decât să imite mutările celui de-al doilea. Un calcul al sumelor la citirea datelor este suficient. Complexitatea <math>O(N)</math> este optimă, deoarece vectorul trebuie parcurs cel puțin o dată pentru citirea configurației inițiale a tablei.

<syntaxhighlight lang="c">
#include <stdio.h>

void main(void)
{ FILE *F=fopen("input.txt","rt");
int SEven,SOdd,N,i,K;

fscanf(F,"%d\n",&N);
for (i=1, SEven=SOdd=0; i<=N; i++)
{ fscanf(F, "%d\n", &K);
if (i&1) SOdd+=K;
else SEven+=K;
}
fclose(F);

printf("Mutarea mea: %c\n", SEven>=SOdd ? 'R' : 'L');
for (i=1; i<N/2; i++)
{ printf("Mutarea dvs. (L/R) ? ");
printf("Mutarea mea: %c\n", getchar());
getchar(); /* Caracterul newline */
}
printf("Mutarea dvs. (L/R) ? ");
getchar();

if (SEven>=SOdd)
printf("%d %d\n", SEven, SOdd);
else printf("%d %d\n", SOdd, SEven);
}
</syntaxhighlight>

O a doua variantă a enunțului aduce unele condiții suplimentare:

* Se cere să se tipărească numai diferența maximă de scor pe care o poate obține primul jucător, considerând că ambii parteneri joacă perfect;
* '''Complexitatea cerută''' este <math>O(N^2)</math>.
* '''Timpul de implementare''' este de 45 minute, maxim 1h.

'''REZOLVARE''': Trebuie mai întâi să lămurim ce se înțelege prin „joc perfect”. Jucătorul 1 are întotdeauna victoria la îndemână (metoda este arătată mai sus), dar nu la orice scor. Jucătorul 2 urmărește să minimizeze diferența de scor. Fie '''''D''''' diferența de scor cu care se termină un joc. '''''D''''' poate lua diferite valori pentru aceeași configurație inițială a tablei, în funcție de mutările făcute de cei doi jucători. Fie <math>D_{MAX}</math> diferența maximă de scor pe care o poate obține primul jucător indiferent de mutările celui de-al doilea. Exact această valoare trebuie aflată. <math>D_{MAX}</math> nu este propriu-zis o diferență maximă. Jucătorul 1 poate să câștige și la diferențe mai mari decât <math>D_{MAX}</math>, dar trebuie ca jucătorul 2 să-l „ajute”. Să reluăm exemplul cu 4 numere:

[[File:Psycho-fig51.png]]

În acest caz, primul jucător are asigurat scorul 12-8 (deci diferența 4). Pentru aceasta, el începe prin a lua numărul 2, apoi, orice ar replica celălalt, va lua numărul 10, jucătorului 2 revenindu-i așadar numerele 1 și 7. El poate obține și scorul 17-3 (jucătorul 1 ia numărul 7, celălalt ia 2, jucătorul 1 ia 10, iar celălalt ia 1), dar aceasta se întâmplă numai dacă jucătorul 2 face o greșeală. După cum am arătat mai sus, dacă primul jucător începe luând numărul 7, el pierde în mod normal partida. Iată deci că în acest caz <math>D_{MAX}=4</math>.

Pentru a putea afla diferența maximă de scor, este bine să privim mereu în adâncime. Există patru variante în care ambii parteneri pot face câte o mutare:

# Ambii jucători aleg numere din partea stângă;
# Ambii aleg numere din partea dreaptă;
# Primul jucător alege numărul din stânga, iar celălalt pe cel din dreapta;
# Primul jucător alege numărul din dreapta, iar celălalt pe cel din stânga;

În urma oricărei variante de mutare, secvența se scurtează cu două elemente. Dacă am putea cunoaște dinainte care este rezultatul jocului pentru fiecare din secvențele scurte, am putea să decidem care variantă de joc este cea mai convenabilă pentru secvența inițială, ținând cont și de modul de joc al jucătorului al doilea. Tocmai de aici vine și ideea de rezolvare. Să notăm cu '''''A'''''[1], '''''A'''''[2], ..., '''''A'''''['''''N'''''] secvența citită la intrare. Vom construi o matrice '''''D''''' cu '''''N''''' linii și '''''N''''' coloane, unde '''''D'''''['''''i''''','''''j'''''] este diferența maximă pe care o poate obține jucătorul 1 pentru secvența '''''A'''''['''''i'''''], '''''A'''''['''''i'''''+1], ..., '''''A'''''['''''j''''']. Bineînțeles, sunt luate în considerare numai secvențele de lungime pară. Scopul nostru este să-l aflăm pe '''''D'''''[1,'''''N'''''].

Elementele matricei pe care le putem afla fără multă bătaie de cap sunt '''''D'''''[1,2], '''''D'''''[2,3], ..., '''''D'''''['''''N'''''-1,'''''N''''']. Într-adevăr, dintr-o secvență de numai două numere, primului jucător îi revine cel mai mare, iar celui de-al doilea - cel mai mic. Așadar

<math>D[i,i + 1] = |A[i] - A[i + 1]|</math>

Cum calculăm '''''D'''''['''''i''''','''''j'''''] dacă cunoaștem valorile matricei '''''D''''' pentru toate subsecvențele incluse în secvența '''''A'''''['''''i'''''], '''''A'''''['''''i'''''+1], ..., '''''A'''''['''''j'''''] ? După cum am mai spus, avem patru variante:

[[File:Psycho-fig52.png]]

Trebuie să ținem minte că, dacă primul jucător optează să-l aleagă pe A[i] (una din primele două variante), atunci jucătorul 2 va juca în așa fel încât pierderea să fie minimă, iar scorul final va fi <math>\min(R_1,R_2)</math>. Dacă jucătorul 1 alege varianta 3 sau 4, scorul final va fi <math>\min(R_3,R_4)</math>. Dar jucătorul 1 este primul la mutare, deci va alege varianta care îi maximizează profitul. Rezultatul este

<math>D[i,j] = \max(\min(R_1, R_2), \min(R_3, R_4))</math>

adică

<math>
\begin{align}
D[i,j] = \max( & A[i] + \min(D[i + 2, j] - A[i + 1], D[i + 1, j - 1] - A[j]), \\
& A[j] + \min(D[i + 1, j - 1] - A[i], D[i, j - 2] - A[j - 1]))
\end{align}
</math>

Matricea D se completează pe diagonală, pornind de la diagonala principală și mergând până în colțul de N-E. Iată cum arată matricea atașată datelor de intrare din enunț:

<math>
D =
\begin{pmatrix}
X & 3 & X & 10 & X & 7 \\
X & X & 5 & X & 9 & X \\
X & X & X & 7 & X & 4 \\
X & X & X & X & 4 & X \\
X & X & X & X & X & 3 \\
X & X & X & X & X & X
\end{pmatrix}
</math>

Pentru exemplul din enunț, răspunsul este deci <math>D_{MAX}=7</math>. Cum elementele matricei sunt parcurse cel mult o dată, rezultă o complexitate de <math>O(N^2)</math>.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#define NMax 101

int D[NMax][NMax], A[NMax], N;

void ReadData(void)
{ FILE *F=fopen("input.txt","rt");
int i;

fscanf(F,"%d\n",&N);
for (i=1; i<=N;)
fscanf(F, "%d\n", &A[i++]);
fclose(F);
}

int Min(int A, int B)
{
return AB ? A : B;
}

void FindMax(void)
{ int i,j,k;

for (i=1;i<N;i++)
D[i][i+1]=abs(A[i]-A[i+1]);
for (k=3;k<=N-1;k++)
for (i=1;i+k<=N;i++)
{ j=i+k;
D[i][j]=Max(A[i]+Min(D[i+2][j]-A[i+1],
D[i+1][j-1]-A[j]),
A[j]+Min(D[i+1][j-1]-A[i],
D[i][j-2]-A[j-1]));
}
printf("Diferenta maxima este %d\n",D[1][N]);
}

void main(void)
{
ReadData();
FindMax();
}
</syntaxhighlight>

Programul prezentat mai sus poate fi optimizat, dacă timpul o permite și dacă acest lucru este necesar. Lăsăm cititorul să încerce să rezolve aceeași problemă folosind o cantitatate de memorie direct proporțională cu '''''N'''''.

== Problema 5 ==

Această problemă a fost propusă la Olimpiada Națională de Informatică, Slatina 1995, la clasa a XI-a. Pe atunci programarea dinamică era o tehnică de programare destul de puțin cunoscută de către majoritatea elevilor.

'''ENUNȚ''': O regiune deșertică este reprezentată printr-un tablou de dimensiuni '''''M'''''x'''''N''''' (1 ≤ '''''M''''' ≤ 100, 1 ≤ '''''N''''' ≤ 100). Elementele tabloului sunt numere naturale mai mici ca 255, reprezentând diferențele de altitudine față de nivelul mării (cota 0). Să se stabilească:

a) Un traseu pentru a traversa deșertul de la nord la sud (de la linia 1 la linia '''''M'''''), astfel:

* Se pornește dintr-un punct al liniei 1;
* Deplasarea se poate face în una din direcțiile: E, SE, S, SV, V;
* Suma diferențelor de nivel (la urcare și la coborâre) trebuie să fie minimă.

b) Un traseu pentru a traversa deșertul de la nord la sud în condițiile punctului (a), la care se adaugă condiția:

* Lungimea traseului să fie minimă.

'''Intrarea''': Fișierul de intrare <tt>INPUT.TXT</tt> conține un singur set de date cu următoarea structură:

{|class="wikitable"
| linia 1: || '''''M N'''''
|-
| linia 2 ... linia '''''M'''''+1: || elementele tabloului (pe linii) separate prin spații
|}

'''Ieșirea''': Fișerul de ieșire <tt>OUTPUT.TXT</tt> va conține rezultatele în următorul format:

(a) 
<suma diferențelor de nivel> 
TRASEU: <math>(i_1,j_1)\to(i_2,j_2)\to\cdots\to(i_k,j_k)</math> 
(b) 
<suma diferențelor de nivel> <lungime traseu> 
TRASEU: <math>(i_1,j_1)\to(i_2,j_2)\to\cdots\to(i_p,j_p)</math>

unde <math>i_x</math> și <math>j_x</math> sunt linia și coloana fiecărei celule vizitate.

'''Exemplu''':

{|class="wikitable
! <tt>INPUT.TXT</tt> || <tt>OUTPUT.TXT</tt>
|-
| <tt>4 4 
10 7 2 5 
13 20 25 3 
2 4 2 20 
5 10 9 11 </tt>
| <tt>(a) 
5 
TRASEU: (1,3)->(2,4)->(3,3)->(3,2)->(4,1) 
(b) 
9 3 
TRASEU: (1,3)->(2,4)->(3,3)->(4,2) </tt>
|}

Acesta a fost enunțul original. Iată acum completările propuse și o precizare importantă:

* '''Timpul de implementare''': 45 minute - 1h (la concurs a fost cam 1h 30 min);
* '''Timpul de rulare''': 2-3 secunde;
* '''Complexitatea cerută''': <math>O(N^2)</math>;
* La punctul (b), condiția nou adăugată este mai puternică decât cea de la punctul (a). Cu alte cuvinte, în primul rând contează lungimea drumului și abia apoi, dintre toate drumurile de lungime minimă, trebuie ales cel pentru care suma denivelărilor este minimă. Pentru a vă convinge că ordinea în care sunt impuse condițiile este importantă, să privim exemplul de mai sus. Dacă este mai importantă minimizarea sumei denivelărilor, atunci minimul este 5, iar drumul este soluția de la punctul (a). Dacă este mai importantă minimizarea lungimii drumului, atunci lungimea minimă este 3, iar din toate drumurile de lungime 3, cel mai puțin costisitor este cel indicat la punctul (b).

'''REZOLVARE''': Vom lăsa punctul (b) al acestei probleme în seama cititorului, întrucât el nu este altceva decât o simplificare a punctului (a). Să ne ocupăm acum de punctul (a). Vom numi efort diferența de altitudine (în modul) la deplasarea cu un pas. Scopul este deci găsirea unor drumuri de efort total minim. Matricea de altitudini o vom nota cu <tt>Alt</tt>.

O primă posibilitate de abordare a problemei este „greedy”, dar aceasta nu e cea mai fericită alegere, chiar dacă este una comodă. Ideea de bază este următoarea: Încercăm să pornim din colțul de NV și să ne deplasăm la fiecare pas pe acea direcție pentru care efortul este minim, până ajungem la ultima linie. Apoi pornim din a doua coloană a primei linii și aplicăm aceeași tactică, apoi din a treia coloană și așa mai departe până la colțul de NE. În final tipărim soluția cea mai bună găsită. Iată însă un exemplu pe care această metodă dă greș:

<math>
Alt=
\begin{pmatrix}
2 & 1 & 2 \\
10 & 1 & 10 \\
10 & 10 & 10
\end{pmatrix}
</math>

Pe această matrice, algoritmul greedy va găsi traseele (1,1) → (2,2) → (3,2) de efort total 10, (1,2) → (2,2) → (3,2) de efort total 9 și (3,1) → (2,2) → (3,2) de efort total 10. Așadar, rezultatul optim ar fi 9, ceea ce este fals deoarece alegerea traseului (1,1) → (2,1) → (3,1) ar duce la un efort total de 8, deci mai mic.

Motivul pentru care acest algoritm nu funcționează cum trebuie este că el nu privește în perspectivă. În cazul de mai sus, coborârea în „văile” de altitudine 1 era o primă mutare tentantă, dar fără nici un rezultat, deoarece până la urmă tot era necesară suirea la altitudinea 10. Soluția corectă este ca, pentru a afla efortul minim cu care se poate ajunge la o locație oarecare, să analizăm toate drumurile care duc la acea locație. Dacă am cunoaște efortul minim cu care se poate ajunge la fiecare din vecinii din E, NE, N, NV, și V ai unei celule, atunci putem cu ușurință, pe baza unor comparații, să deducem din ce parte este cel mai avantajos să venim în respectiva celulă și cu ce efort minim.

Mai concret, vom construi o matrice cu aceleași dimensiuni ca și matricea <tt>Alt</tt>, pe care o vom denumi <tt>Eff</tt>. În această matrice, <tt>Eff[i,j]</tt> reprezintă efortul minim necesar pentru a ajunge de pe un punct oarecare de pe linia 1 în celula ('''''i''''','''''j'''''). Deducem că <tt>Eff[1,j]</tt>=0, ∀ 1 ≤ '''''j''''' ≤ '''''N'''''. Noi trebuie să completăm matricea <tt>Eff</tt>, apoi să căutăm minimul dintre toate elementele de pe linia '''''M''''' (care este chiar efortul minim căutat) și să reconstituim traseul de urmat.

Ca să vedem cum anume se face completarea matricei, facem mai întâi observația că, odată ce am ajuns pe o linie, putem fie să coborâm direct pe linia imediat inferioară, fie să ne deplasăm câțiva pași numai spre stânga sau numai spre dreapta, apoi să coborâm pe linia următoare. În orice locație ('''''X''''','''''Y''''') a matricei putem veni dinspre E, NE, N, NV, sau V. Pentru acești cinci vecini presupunem deja calculate eforturile minime necesare, respectiv <tt>Eff[X,Y+1], Eff[X-1,Y+1], Eff[X-1,Y], Eff[X-1,Y-1], Eff[X,Y-1]</tt>. Atunci, în funcție de direcția din care venim, efortul depus până la punctul ('''''X''''','''''Y''''') va fi:

{|
| dinspre est: || <tt>Eff[X,Y+1]+ |Alt[X,Y+1] - Alt[X,Y]|</tt>; || (1)
|-
| dinspre nord-est: || <tt>Eff[X-1,Y+1]+ |Alt[X-1,Y+1] - Alt[X,Y]|</tt>; || (2)
|-
| dinspre nord: || <tt>Eff[X-1,Y]+ |Alt[X-1,Y] - Alt[X,Y]|</tt>; || (3)
|-
| dinspre nord-vest: || <tt>Eff[X-1,Y-1]+ |Alt[X-1,Y-1] - Alt[X,Y]|</tt>; || (4)
|-
| dinspre vest: || <tt>Eff[X,Y-1]+ |Alt[X,Y-1] - Alt[X,Y]|;</tt> || (5)
|}

În principiu, nu avem decât să calculăm minimul dintre aceste expresii ca să aflăm valoarea lui <tt>Eff[X,Y]</tt>. În felul acesta, matricea <tt>Eff</tt> se va completa pe linie, de sus în jos. Totuși, apare o problemă: pentru a-l afla pe </tt>Eff[X,Y]</tt> avem nevoie de <tt>Eff[X,Y-1]</tt> (dacă ne deplasăm spre est), iar pentru a-l afla pe <tt>Eff[X,Y-1]</tt> avem nevoie de <tt>Eff[X,Y]</tt> (dacă ne deplasăm spre vest)! Bineînțeles, avem sentimentul că ne învârtim după propria coadă. Totuși, dezlegarea nu e complicată, ținând cont de observația făcută mai sus, că pe aceeași linie deplasarea se face într-o singură direcție. Este suficient să parcurgem fiecare linie de două ori: prima oară o parcurgem de la stânga la dreapta, în ipoteza că deplasarea pe linia respectivă se face spre est, apoi încă o dată de la dreapta la stânga, în ipoteza că deplasarea pe linia respectivă se face spre vest. La prima parcurgere, vom minimiza efortul pentru fiecare căsuță cu expresia (5), iar la a doua - cu expresia (1). Minimizarea cu expresiile (2), (3) și (4) se poate face la oricare din parcurgeri, deoarece elementele liniei superioare nu se mai modifică.

După cum am spus, efortul minim se obține căutând minimul de pe ultima linie a matricei <tt>Eff</tt> (aceasta deoarece nu contează în ce punct de pe ultima linie este sosirea). Punctul în care se atinge acest minim este tocmai punctul de sosire. Reconstituirea efectivă a drumului se face în sens invers: se pleacă din punctul de sosire <math>(i_k,j_k)</math> și se caută un punct vecin lui pe una din cele cinci direcții permise, <math>(i_{k-1},j_{k-1})</math> astfel încât

<math>
\mathit{Eff}[i_k,j_k] = \mathit{Eff}[i_{k-1},j_{k-1}] + |Alt[i_k,j_k] - Alt[i_{k-1},j_{k-1}]|
</math>

Cu alte cuvinte, se testează pentru care din expresiile (1) - (5) se verifică egalitatea. Se reia, recursiv, același procedeu pentru locația <math>(i_{k-1},j_{k-1})</math>.

Iată cum se completează matricea <tt>Eff</tt> pentru exemplul dat și cum se reconstituie drumul:

<math>
Alt =
\begin{pmatrix}
10 & 7 & 2 & 5 \\
13 & 20 & 25 & 3 \\
2 & 4 & 2 & 20 \\
5 & 10 & 9 & 11
\end{pmatrix}
</math>

<math>
\mathit{Eff} =
\begin{pmatrix}
0 & 0 & 0 & 0 \\
3 & 10 & 15 & 1 \\
6 & 4 & 2 & 18 \\
5 & 10 & 9 & 11
\end{pmatrix}
</math>

Minimul de pe linia a 4-a a matricei <tt>Eff</tt> este <tt>Eff[4,1]=5</tt>, deci sosirea se face în colțul de SV. Din ce parte am ajuns aici ? Se testează toți vecinii și se constată că <tt>Eff[4,1] = Eff[3,2] + |Alt[4,1] - Alt[3,2]|</tt>, deci s-a venit de la locația (3,2). Apoi se constată că:

* <tt>Eff[3,2] = Eff[3,3] + |Alt[3,2] - Alt[3,3]|</tt>;
* <tt>Eff[3,3] = Eff[2,4] + |Alt[3,3] - Alt[2,4]|</tt>;
* <tt>Eff[2,4] = Eff[1,3] + |Alt[2,4] - Alt[1,3]|</tt>;

Din aceste relații rezultă că traseul urmat este (1,3) → (2,4) → (3,3) → (3,2) → (4,1).

Pentru o mai mare ușurință a implementării, se vor adăuga două coloane fictive la matricea <tt>Alt</tt>: coloanele 0 și '''''N'''''+1. Facem acest lucru pentru a ne putea referi la celula ('''''X''''','''''Y'''''-1) atunci când ('''''X''''','''''Y''''') este o celulă din prima coloană (respectiv la celula ('''''X''''','''''Y'''''+1) atunci când ('''''X''''','''''Y''''') este o celulă de pe ultima coloană) fără a primi un mesaj de eroare. Trebuie însă să fim atenți ca nu cumva noile coloane adăugate să perturbe datele de ieșire și să rezulte că traseul optim trece prin coloana 0 sau '''''N'''''+1. Pentru a scăpa de grija celulelor de pe aceste două coloane și a ne asigura că ele nu vor putea fi selectate pentru traseul optim, le vom atribui altitudini foarte mari. Deoarece diferența maximă de nivel la fiecare pas este 255, rezultă că efortul total maxim ce se poate obține este 255 x 99 = 25.245. Așadar, o altitudine a coloanelor laterale de 30.000 este suficientă.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <math.h>
#define NMax 101
#define Infinity 30000
typedef int Matrix[NMax][NMax+1];

Matrix Alt, Eff;
int M, N;
FILE *OutF;

void ReadData(void)
{ FILE *F=fopen("input.txt", "rt");
int i,j;

fscanf(F, "%d %d\n", &M, &N);
for (i=1; i<=M; i++)
for (j=1; j<=N; j++)
fscanf(F, "%d", &Alt[i][j]);
fclose(F);
}

void Optimize(int X1, int Y1, int X2, int Y2)
/* Testeaza daca in (X1,Y1) se poate ajunge
cu efort mai mic dinspre (X2,Y2) */
{
if (Eff[X2][Y2]+abs(Alt[X1][Y1]-Alt[X2][Y2])<Eff[X1][Y1])
Eff[X1][Y1]=Eff[X2][Y2]+abs(Alt[X1][Y1]-Alt[X2][Y2]);
}

void Traverse(void)
{ int i,j;

for (j=1; j<=N;) Eff[1][j++]=0;
for (i=1; i<=M; i++)
Eff[i][0]=Eff[i][N+1]=Infinity; /* Bordeaza matricea */
for (i=2; i<=M; i++)
{
for (j=1; j<=N; j++)
{
Eff[i][j]=Infinity;
Optimize(i, j, i-1, j); /* De la N */
Optimize(i, j, i-1, j-1); /* De la NV */
Optimize(i, j, i-1, j+1); /* De la NE */
Optimize(i, j, i, j-1); /* De la V */
}
for (j=N; j; j--)
Optimize(i, j, i, j+1); /* De la E */
}
}

void GoBack(int X, int Y)
/* Reconstituie drumul */
{
if (X>1)
if (Eff[X][Y]==Eff[X][Y-1]
+abs(Alt[X][Y-1]-Alt[X][Y]))
GoBack(X, Y-1);
else if (Eff[X][Y]==Eff[X-1][Y-1]
+abs(Alt[X-1][Y-1]-Alt[X][Y]))
GoBack(X-1, Y-1);
else if (Eff[X][Y]==Eff[X-1][Y]
+abs(Alt[X-1][Y]-Alt[X][Y]))
GoBack(X-1, Y);
else if (Eff[X][Y]==Eff[X-1][Y+1]
+abs(Alt[X-1][Y+1]-Alt[X][Y]))
GoBack(X-1, Y+1);
else if (Eff[X][Y]==Eff[X][Y+1]
+abs(Alt[X][Y+1]-Alt[X][Y]))
GoBack(X, Y+1);
if (X>1) fprintf(OutF, "->");
fprintf(OutF,"(%d,%d)", X, Y);
}

void WriteSolution(void)
{ int j,k;

OutF=fopen("output.txt", "wt");
/* Cauta punctul de sosire */
fputs("(a)\n",OutF);
for (j=2, k=1; j<=N; j++)
if (Eff[M][j]<Eff[M][k]) k=j;
fprintf(OutF, "%d\n", Eff[M][k]);
fputs("TRASEU: ",OutF);
GoBack(M, k);
fprintf(OutF,"\n");
fclose(OutF);
}

void main(void)
{
ReadData();
Traverse();
WriteSolution();
}
</syntaxhighlight>

== Problema 6 ==

Propunem în continuare o problemă care s-a dat la Olimpiada Națională de Informatică, Suceava 1996, la clasa a XII-a. Menționăm că un singur concurent a reușit să o ducă la bun sfârșit în timpul concursului. Problema se numește „Cartierul Enicbo”.

'''ENUNȚ''': În orașul Acopan s-a construit un nou cartier. Noul cartier are patru bulevarde paralele și un număr de '''''N''''' străzi perpendiculare pe ele. Există deci în total 4'''''N''''' intersecții. Furgoneta oficiului poștal trebuie să distribuie poșta în fiecare zi; în acest scop, furgoneta pleacă de la oficiul poștal aflat la intersecția bulevardului 1 cu strada 1 și, urmând rețeaua stradală, trece exact o dată prin fiecare intersecție astfel încât să încheie traseul în punctul de plecare.

Conducerea oficiului poștal roagă participanții la olimpiadă să o ajute să afle în câte moduri distincte se poate stabili traseul furgonetei.

'''Intrarea''': Programul va citi de la tastatură valoarea lui '''''N''''' (2 ≤ '''''N''''' ≤ 200).

'''Ieșirea''': Pe ecran se va afișa soluția (numărul de trasee distincte pentru valoarea respectivă a lui '''''N''''').

'''Exemplu''': Pentru '''''N'''''=3 există 4 soluții (se citește de la tastatură numărul 3 și se afișează pe ecran numărul 4). Iată soluțiile efective:

[[File:Psycho-fig53.png]]

'''Timp de execuție''': 30 secunde pentru un text

'''Timp de implementare''': 1h 30 min.

'''Complexitate cerută''': <math>O(N^2)</math>

'''REZOLVARE''': Primul lucru care ne vine în gând este „se cere numărul de cicluri hamiltoniene într-un graf, deci problema e exponențială”. Rezolvarea backtracking nu e deloc greu de implementat, dar nu are nici o șansă să meargă pentru valori mari ale lui '''''N'''''. Afirmația de mai sus este corectă, dar incompletă; din această cauză concluzia este falsă. Se scapă din vedere faptul că graful nu este oarecare, ci are un aspect foarte particular.

Și în această problemă vom încerca să utilizăm soluțiile locale (pentru valori mici ale lui '''''N''''') pentru aflarea soluției globale. Respectiv, vom rezolva problema pentru '''''N'''''=2, apoi o vom extinde pentru '''''N'''''=3, 4 și așa mai departe. Pentru început, însă, încercăm să simplificăm enunțul, reducând problema la una echivalentă, dar mai simplă.

Să considerăm o posibilă soluție pentru '''''N'''''=5:

[[File:Psycho-fig54.png]]

În loc să lucrăm cu segmente în această rețea, vom lucra cu ochiuri. Furgoneta parcurge un ciclu, deci închide în circuitul ei un număr de ochiuri. Am marcat aceste ochiuri cu un „X” în figura de mai sus. Așadar, oricărui drum al furgonetei i se poate atașa o matrice cu 3 linii și '''''N'''''-1 coloane, în care unele celule sunt bifate cu „X”, iar altele nu. Să vedem în primul rând care este corespondența între numărul de circuite hamiltoniene și numărul de matrice de acest tip.

Se observă că pentru orice circuit există un altul căruia îi este atașată aceeași matrice. Circuitul pereche este tocmai circuitul parcurs în sens invers, care închide în interior aceleași ochiuri de rețea:

[[File:Psycho-fig55.png]]

Acest lucru se întâmplă deoarece transformarea graf-matrice ignoră sensul de parcurgere a circuitului hamiltonian. De aici rezultă că pentru a calcula numărul de circuite hamiltoniene trebuie să calculăm numărul de matrice și să-l înmulțim cu 2.

În continuare, să analizăm câteva proprietăți ale matricelor în discuție.

'''1.''' Elementele bifate cu „X” în matrice formează o singură figură conexă.

Demonstrație: dacă figura nu ar fi conexă, adică dacă ar exista mai multe figuri, ele nu ar putea fi înconjurate de furgonetă într-un singur drum. De remarcat că toate pătratele înconjurate de furgonetă trebuie bifate cu X, deci furgoneta nu poate înconjura pătrate nebifate. De aceea, traseul de mai jos (care prezintă o porțiune oarecare de circuit) este imposibil.

[[File:Psycho-fig56.png]]

Conexitatea se referă numai la vecinătatea pe latură, nu și pe colț. Spre exemplu, figura de mai jos este incorectă, deoarece, pentru a o înconjura, furgoneta trebuie să treacă de două ori prin punctul încercuit:

[[File:Psycho-fig57.png]]

'''2.''' Elementele bifate cu „X” formează o structură aciclică.

Demonstrație: dacă structura ar fi ciclică, ar rezulta că elementele bifate cu „X” închid între ele elemente nebifate, pe care furgoneta însă nu poate să le ocolească. Iată un exemplu de ciclicitate:

[[File:Psycho-fig58.png]]

Practic, situația de mai sus obligă furgoneta să facă două drumuri: unul pe exterior și unul în jurul ochiului marcat cu „?”.

'''3.''' Nici un nod interior al rețelei nu poate avea toate cele patru ochiuri vecine marcate cu „X”.

Demonstrație: dacă ar exista un asemenea nod, el nu ar putea fi parcurs de furgonetă, deci ciclul nu ar mai fi hamiltonian. Este cazul nodului încercuit în figura următoare:

[[File:Psycho-fig59.png]]

'''4.''' Structura elementelor bifate cu „X” în cadrul matricei este arborescentă.

Demonstrația rezultă imediat din punctele anterioare: figura este conexă și aciclică.

'''5.''' Numărul de celule bifate este P = 2'''''N'''''-1.

Demonstrația se face prin inducție matematică. Să presupunem că structura noastră ar avea un singur pătrat bifat. Atunci structura ar avea patru laturi „la vedere”. Traseul furgonetei care ocolește structura ar avea patru laturi. O structură de două pătrate (desigur lipite) va avea șase laturi la vedere:

[[File:Psycho-fig60.png]]

Să ne imaginăm acum că orice structură cu '''''k''''' pătrate are <math>S_k</math> laturi la vedere. Trebuie să demonstrăm că toate structurile cu '''''k'''''+1 pătrate au același număr de laturi la vedere și să aflăm efectiv acest număr, <math>S_{k+1}</math>. Cel de-al '''''k'''''+1-lea pătrat trebuie alipit la structura deja existentă în așa fel încât să nu se închidă nici un ciclu. El se va lipi deci de o latură la vedere a unui pătrat din structură. În acest fel, va dispărea o latură la vedere, dar vor apărea trei în loc. Numărul de laturi la vedere va crește prin urmare cu 2. Această cifră nu depinde de locul în care este alipit al k+1-lea pătrat, nici de forma structurii deja existente, deci am demonstrat că toate structurile arborescente cu k pătrate au același număr de laturi la vedere. Pentru a afla efectiv acest număr, pornim de la relațiile recurente stabilite prin inducție și eliminăm recurența:

<math>
\begin{align}
S_{k + 1} & = S_k + 2 \\
S_1 & = 4
\end{align}
\Biggr\}
\implies S_k = 2k + 2
</math>

Deoarece numărul total de noduri al rețelei este de 4'''''N''''', rezultă că structura noastră trebuie să aibă 4'''''N''''' laturi la vedere. Notând cu '''''P''''' numărul de pătrate bifate din matrice și rezolvând ecuația de mai jos, rezultă valoarea lui '''''P''''':

<math>
2P + 2 = 4N \implies P = 2N - 1 = 2(N - 1) + 1
</math>

Cum numărul de coloane al matricei este '''''N'''''-1, deducem că în medie pe fiecare coloană se vor afla două pătrate bifate, cu excepția uneia pe care se vor afla trei pătrate bifate. La nivel local, proprietatea este de asemenea respectată: numărul de pătrate bifate din primele '''''k''''' coloane ale matricei este 2'''''k''''', existând posibilitatea să mai fie un pătrat suplimentar. De exemplu, în figura dată mai sus pentru '''''N'''''=5, în primele două coloane se află patru elemente „X”, deci o medie de două pătrate pe fiecare coloană. În primele trei coloane există șapte elemente „X”, adică o medie de două pătrate pe coloană și un surplus de un pătrat. Lăsăm ca temă cititorului să demonstreze că, în primele '''''k''''' coloane există întotdeauna fie 2'''''k''''', fie 2'''''k'''''+1 pătrate. Orice număr mai mare duce la ciclicitatea figurii, orice număr mai mic duce la neconexitatea ei.

Pe fiecare coloană există opt combinații posibile de elemente bifate și nebifate, pe care le vom codifica cu numere de la 0 la 7, conform unei numărători binare:

[[File:Psycho-fig61.png]]

Să vedem acum care dintre aceste combinații rămân valabile. O coloană de tipul 0 nu poate exista, deoarece ea ar „rupe” matricea în două bucăți separate, deci proprietatea de conexitate nu ar fi respectată.

Dacă pe coloana '''''k''''' se află o combinație de tipul 3, ce s-ar putea afla pe coloana '''''k'''''+1 ?

[[File:Psycho-fig62.png]]

Pentru ca punctul A să se afle pe traseul furgonetei, este obligatoriu să bifăm pătratul de sub el. Pentru a menține conexitatea figurii apărute, trebuie bifat și pătratul din centrul coloanei '''''k'''''+1. Cea de-a treia celulă a coloanei '''''k'''''+1 nu poate fi bifată, deoarece punctul B ar fi înconjurat din patru părți de celule bifate, lucru care s-a stabilit că este imposibil. Se vede că singura combinație posibilă pentru coloana '''''k'''''+1 este 6. Ce combinație putem pune pe coloana k+2 ? Printr-un raționament analog, deducem că numai combinația 3:

[[File:Psycho-fig63.png]]

Iată că, pentru a putea respecta condițiile de corectitudine a matricei, am fi nevoiți să continuăm la nesfârșit cu coloane cu combinațiile 3-6-3-6 etc. Deci niciuna din aceste combinații nu poate apărea în matrice.

În continuare, vom defini mai multe șiruri de forma <math>S_k(i,t)</math>, unde:

* '''''k''''' este numărul unei coloane;
* '''''i''''' este un număr de combinație (respectiv 1, 2, 4, 5 sau 7);
* '''''t''''' este un număr care poate avea valoarea 0 sau 1.

<math>S_k(i,t)</math> semnifică „numărul de matrice (corecte) cu k coloane astfel încât pe coloana cu numărul '''''k''''' să se afle combinația '''''i''''', iar surplusul de pătrate bifate peste media de două pătrate pe fiecare coloană să fie '''''t'''''”. De exemplu, <math>S_7(5,1)</math> reprezintă numărul de matrice corecte (care respectă regulile de construcție) cu 7 coloane, astfel încât pe ultima coloană să se afle combinația 5 și să existe un surplus de 1 pătrat (adică numărul total de pătrate să fie 2 x 7 + 1 = 15).

Facem observația că pe a '''''N'''''-1-a coloană se pot afla doar combinațiile 5 sau 7 (pentru a acoperi colțurile de NE și SE ale grafului), iar surplusul de pătrate trebuie să fie 1 (deoarece în '''''N'''''-1 coloane trebuie să se afle '''''P'''''=2('''''N'''''-1)+1 pătrate bifate). Deci scopul nostru este să calculăm suma <math>S_{N-1}(5,1) + S_{N-1}(7,1)</math> și să o înmulțim cu 2 ca să aflăm numărul de cicluri hamiltoniene.

De asemenea, remarcăm că șirurile <math>S_k(1,1)</math>, <math>S_k(2,1)</math> și <math>S_k(4,1)</math> nu sunt definite. Aceasta deoarece combinațiile 1, 2 și 4 au un singur pătrat bifat pe coloană, adică mai puțin decât media de două pătrate. Este imposibil ca după adăugarea unei asemenea coloane să mai existe un surplus. (deoarece ar rezulta că în primele '''''k'''''-1 coloane exista un surplus de două pătrate). La polul opus, șirul <math>S_k(7,0)</math> nu este definit, deoarece combinația 7 are toată coloana bifată, adică peste medie, deci nu se poate să nu apară un surplus de pătrate bifate.

Mai trebuie stabilite formulele de recurență între șirurile <math>S_k(1,0)</math>, <math>S_k(2,0)</math>, <math>S_k(4,0)</math>, <math>S_k(5,0)</math>, <math>S_k(5,1)</math> și <math>S_k(7,1)</math>. Termenii inițiali ai recurenței sunt:

* <math>S_1(1,0)=0</math> deoarece matricea nu poate începe cu combinația 1
* <math>S_1(2,0)=0</math> deoarece matricea nu poate începe cu combinația 2
* <math>S_1(4,0)=0</math> deoarece matricea nu poate începe cu combinația 4
* <math>S_1(5,0)=1</math> deoarece există o singură matrice de o coloană cu combinația 5
* <math>S_1(5,1)=0</math> deoarece combinația 5 are două pătrate, deci nu există surplus
* <math>S_1(7,1)=1</math> deoarece există o singură matrice de o coloană cu combinația 7

Pentru a stabili relația de recurență pentru șirul <math>S_k(1,0)</math>, ne întrebăm: cărei coloane îi poate urma coloana '''''k''''' de tip 1 astfel încât să nu mai existe surplus ? Dacă observăm că pe coloana '''''k''''' avem un singur element bifat (deci sub medie), rezultă că pe coloana '''''k'''''-1 exista un surplus de un pătrat. Deci coloana '''''k'''''-1 putea fi de tipul 5 sau 7, acestea fiind singurele tipuri de coloană după care poate exista un surplus. Rezultă formula:

<math>
S_k(1,0)=S_{k-1}(5,1)+S_{k-1}(7,1)
</math>

Printr-o simetrie perfectă se calculează aceeași formulă și pentru șirul <math>S_k(4,0)</math>:

<math>
S_k(4,0)=S_{k-1}(5,1)+S_{k-1}(7,1)
</math>

La șirul S_k(2,0), mai trebuie făcută observația că o coloană de tip 2 nu poate urma unei coloane de tip 5, deoarece se strică conexitatea figurii. Rezultă:

<math>
S_k(2,0)=S_{k-1}(7,1)
</math>

Șirul <math>S_k(5,0)</math> provine din adăugarea unei coloane de tipul 5 după o coloană de tipul 1, 4 sau 5. Coloana '''''k'''''-1 nu poate fi de tipul 2 deoarece figura rezultată nu este conexă, nici de tipul 7 deoarece ar rezulta că în primele '''''k'''''-2 coloane media de celule bifate este mai mică decât 2.

<math>
S_k(5,0)=S_{k-1}(1,0)+S_{k-1}(4,0)+S_{k-1}(5,0)
</math>

Șirul <math>S_k(5,1)</math> provine din adăugarea unei coloane de tipul 5 după o coloană de tipul 5 sau 7, deoarece tipul de coloană 5 are două pătrate bifate, deci conservă surplusul:

<math>
S_k(5,1)=S_{k-1}(5,1)+S_{k-1}(7,1)
</math>

În sfârșit, o coloană de tip 7 poate urma oricărui tip de coloană pentru care surplusul este 0, adică:

<math>
S_k(7,1)=S_{k-1}(1,0)+S_{k-1}(2,0)+S_{k-1}(4,0)+S_{k-1}(5,0)
</math>

Acestea sunt formulele de recurență. Rezultatul care trebuie afișat pe ecran este <math>2[S_{N-1}(5,1)+S_{N-1}(7,1)]</math>, deoarece după '''''N'''''-1 coloane surplusul trebuie să fie 1, iar colțurile matricii trebuie să fie bifate. Se observă că <math>S_k(1,0)=S_k(4,0)=S_k(5,1)</math>. Practic, problema se reduce la trei șiruri. Notăm:

<math>
\begin{align}
A_k & = S_k(5,0) \\
B_k & = S_k(1,0) = S_k(4,0) = S_k(5,1) \\
C_k & = S_k(7,1) \implies S_k(2,0)=C_{k-1}
\end{align}
</math>

De aici rezultă grupul de relații:

<math>
\begin{cases}
A_k & = A_{k - 1} + 2B_{k - 1} \\
B_k & = B_{k - 1} + C_{k - 1} \\
C_k & = A_{k - 1} + 2B_{k - 1} + C_{k - 2} = A_k + C_{k - 2}
\end{cases}
</math>

și

<math>
\begin{cases}
A_1 & = 1 \\
B_1 & = 0 \\
C_1 & = 1
\end{cases}
</math>

Noi avem nevoie de valoarea

<math>
2(B_{N-1} + C_{N-1}) = 2B_N
</math>

Programul de mai jos nu face decât să implementeze calculul acestor șiruri recurente. Trebuie avut grijă însă cu reprezentarea internă a numerelor, deoarece pentru '''''N'''''=200 valorile ajung la 81 de cifre. Este deci necesară reprezentarea numerelor ca șiruri de cifre.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <mem.h>

typedef int Huge[85];
Huge A,B,C,C2,HTemp;
int N,k;

void Atrib(Huge H, int V)
/* H <- V */
{
memset(H,0,sizeof(Huge));
H[0]=1;
H[1]=V;
}

void Add(Huge A, Huge B)
/* A <- A+B */
{ int i,T=0;

if (B[0]>A[0])
{ for (i=A[0]+1;i<=B[0];) A[i++]=0;
A[0]=B[0];
}
else for (i=B[0]+1;i<=A[0];) B[i++]=0;
for (i=1;i<=A[0];i++)
{ A[i]+=B[i]+T;
T=A[i]/10;
A[i]%=10;
}
if (T) A[++A[0]]=T;
}

void WriteHuge(Huge H)
{ int i;

for (i=H[0];i;printf("%d",H[i--]));
printf("\n");
}

void main(void)
{
printf("N=");scanf("%d",&N);
Atrib(A,1);
Atrib(B,0);
Atrib(C,1);
Atrib(C2,0);
for (k=2;k<=N;k++)
{ memmove(HTemp,C,sizeof(Huge));
Add(A,B);Add(A,B); /* A(k) = A(k-1) + 2*B(k-1) */
Add(B,C); /* B(k) = B(k-1) + C(k-1) */
memmove(C,A,sizeof(Huge));
Add(C,C2); /* C(k) = A(k) + C(k-2) */
memmove(C2,HTemp,sizeof(Huge)); /* noul C(K-2) */
}
Add(B,B); /* Rezultatul este 2*B(n) */
WriteHuge(B);
}
</syntaxhighlight>

File:Psycho-fig63.png

2018-03-07T13:28:11Z

Cata:

File:Psycho-fig62.png

2018-03-07T13:27:59Z

Cata:

File:Psycho-fig61.png

2018-03-07T13:27:47Z

Cata:

File:Psycho-fig60.png

2018-03-07T13:27:11Z

Cata:

File:Psycho-fig59.png

2018-03-07T13:27:00Z

Cata:

File:Psycho-fig58.png

2018-03-07T13:26:17Z

Cata:

File:Psycho-fig57.png

2018-03-07T13:26:03Z

Cata:

File:Psycho-fig56.png

2018-03-07T13:25:55Z

Cata:

File:Psycho-fig55.png

2018-03-07T13:25:43Z

Cata:

File:Psycho-fig54.png

2018-03-07T13:25:32Z

Cata:

File:Psycho-fig53.png

2018-03-07T13:25:23Z

Cata:

File:Psycho-fig52.png

2018-03-07T13:25:11Z

Cata:

File:Psycho-fig51.png

2018-03-07T13:24:59Z

Cata:

File:Psycho-fig50.png

2018-03-07T13:24:16Z

Cata:

File:Psycho-fig49.png

2018-03-07T13:24:05Z

Cata:

File:Psycho-fig48.png

2018-03-07T13:23:53Z

Cata:

File:Psycho-fig47.png

2018-03-07T13:23:44Z

Cata: