Algopedia - User contributions [en]

Clasa a 8-a lecția 8 - 11 nov 2015

2017-04-13T08:11:11Z

Dan: /* Unghiuri */

= Reprezentarea unui punct în memoria calculatorului =

== Coordonate carteziene ==
Fie un punct O, numit origine și două drepte perpendiculare (Ox și Oy), orientate. Acestea formează un sistem cartezian de coordonate.

Putem calcula coordonatele unui punct P într-un sistem cartezian astfel: Ducem proiecțiile Px și Py punctului P pe dreptele Ox respectiv Oy și măsurăm distanțele de la origine la proiecții. În plus, ținând cont de orientarea dreptelor Ox și Oy, atribuim un semn celor două distanțe. Acestea formează coordonatele carteziene ale punctului P.

Putem stoca în memoria calculatorului un punct în coordonate carteziene astfel:
<syntaxhighlight>
struct Punct {
double x;
double y;
};
</syntaxhighlight>

== Coordonate polare ==
Fie un punct O, numit origine și o dreaptă orientată Ox. Acestea formează un sistem polar de coordonate.

Putem calcula coordonatele unui punct P într-un sistem polar astfel: Calculăm distanța r de la punctul O la punctul P. Calculăm unghiul (măsurat în radiani) dintre dreapta Ox și dreapta OP, ținând cont de semiplan și admițând și unghiuri obtuze. Astfel, unghiul poate varia între -PI și PI.

Putem stoca în memoria calculatorului un punct în coordonate polare astfel:
<syntaxhighlight>
struct PunctPolar {
double r;
double alpha;
};
</syntaxhighlight>

Pentru o ilustrare grafică: [http://flockdraw.com/gallery/view/2123128]

== Conversia de la coordonate carteziene la coordonate polare ==
Cunoscând coordonatele carteziene (x, y) ale unui punct P putem calcula coorodnatele sale polare (r, alpha) astfel: Pentru calcularea distanței r se poate folosi teorema lui Pitagora.
<pre>
r = sqrt(x * x + y * y)
</pre>

Pentru calcularea unghiului alpha vom folosi un funcție predefinită în limbajul de programare C (atan2), care calculează arctangena (inversa tangentei) pantei dreptei OP, ținând cont de cadranul în care se află punctul P.

Putem implementa transformarea din coordonate carteziene în coordonate polare astfel:
<syntaxhighlight>
PunctPolar convertesteLaPolare(Punct c) {
PunctPolar p;
p.r = sqrt(c.x * c.x + c.y * c.y);
p.alpha = atan2(c.y, c.x);
return p;
}
</syntaxhighlight>

== Conversia de la coordonate polare la coordonate carteziene ==
Cunoscând coordonatele polare (r, alpha) ale unui punct P putem calcula coorodnatele sale carteziene (x, y) folosindu-ne de definițiile funcțiilor trigonometrice într-un dreptunghi de ipotenuză r. Astfel:
<pre>
x = r * cos(alpha)
y = r * sin(alpha)
</pre>

Putem implementa transformarea din coordonate polare în coordonate carteziene astfel:
<syntaxhighlight>
Punct convertesteLaCarteziene(PunctPolar p) {
Punct c;
c.x = p.r * cos(p.alpha);
c.y = p.r * sin(p.alpha);
return c;
}
</syntaxhighlight>

= Unghiuri =

== Măsurarea unghiurilor ==
Unghiurile se pot măsura în grade sau în radiani. Cele două măsurători sunt direct proporționale și, prin definiție:
<pre>
0 grade = 0 radiani
180 de grade = PI radiani
</pre>

Astfel, putem converti gradele în radiani și radianii în grade astfel:
<pre>
grade = radiani / PI * 180
radiani = grade / 180 * PI
</pre>

Putem face conversii între grade și radiani astfel:
<syntaxhighlight>
double convertesteLaGrade(double radiani) {
return radiani / M_PI * 180;
}

double convertesteLaRadiani(double grade) {
return grade / 180 * M_PI;
}
</syntaxhighlight>

== Unghiul format de 3 puncte ==
Fie 3 puncte A, O și B. Pentru a calcula unghiul u(AOB) format de acestea, ne vom baza de unghiurile alfaA și alfaB formate de dreptele OA respectiv OB cu dreapta Ox.
<pre>
dif = |alpha(A) - alpha(B)|
u(AOB) = dif, dacă 0 <= dif <= PI
= 2 * PI - dif, dacă PI < dif <= 2 * PI
</pre>

Putem calcula unghiul format de 3 puncte astfel:
<syntaxhighlight>
double unghi(Punct A, Punct O, Punct B) {
double alphaA = atan2(A.y - O.y, A.x - O.x);
double alphaB = atan2(B.y - O.y, B.x - O.x);
double dif = fabs(alphaA - alphaB);
if (dif > M_PI)
dif = 2 * M_PI - dif;
return dif;
}
</syntaxhighlight>

== Unghiul format de 2 drepte ==
Fie două drepte d1 și d2 cu coeficienții a1, b1 și c1 respectiv a2, b2 și c2. Ducem dreptele e1 și e2 paralele cu d1 respectiv d2 prin punctul de origine O. Unghiul dintre d1 și d2 este congruent cu unghiul dintre e1 și e2. Unghiul dintre e1 și e2 este congruent cu unghiul dintre perpendicularele f1 și f2 pe e1 respectiv e2 care trec prin punctul de origine O. Considerăm două puncte p1 și p2 ce aparțin perpendicularelor f1 și f2. Unghiul format de punctele p1, O și p2 este congruent cu unghiul dintre perpendicularele f1 și f2. Punctele p1 și p2 pot fi alese (ușor) de coordonate (a1, b1) și (a2, b2).

Putem calcula unghiul format de 2 drepte astfel:
<syntaxhighlight>
double unghi(Dreapta d1, Dreapta d2) {
double u = unghi({d1.a, d1.b}, {0, 0}, {d2.a, d2.b});
if (u > M_PI / 2)
u = M_PI - dif;
return u;
}
</syntaxhighlight>

= Testare =
Pentru a testa codul de mai sus am scris următoarea funcție main():
<syntaxhighlight>
int main(void) {
Punct p11 = {1, 1}, p12 = {1, 2}, p13 = {1, 3};
Punct p21 = {2, 1}, p22 = {2, 2}, p23 = {2, 3};
Punct p31 = {3, 1}, p32 = {3, 2}, p33 = {3, 3};
assert(egale(distanta(p11, p22), sqrt(2)));
Dreapta d1 = obtineDreapta(p11, p22);
assert(punctApartineDreptei(d1, p33));
assert(!punctApartineDreptei(d1, p23));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
DreaptaCanonica d1prim = obtineFormaCanonica(d1);
assert(egale(d1prim.a * d1prim.a + d1prim.b * d1prim.b, 1));
assert(coincid(d1, d1prim));
Dreapta d2 = obtineDreapta(p21, p32);
assert(suntParalele(d1, d2));
Dreapta d3 = obtineDreapta(p11, p31);
assert(!suntParalele(d1, d3));
assert(egale(distanta(d1prim, p21), sqrt(2) / 2));
Dreapta d4 = paralelaPrin(d1, p21);
assert(punctApartineDreptei(d4, p32));
assert(!punctApartineDreptei(d4, p33));
Dreapta d5 = obtineDreapta(p12, p21);
assert(suntPerpendiculare(d1, d5));
assert(!suntPerpendiculare(d1, d2));
Dreapta d6 = perpendicularaPrin(d1, p21);
assert(punctApartineDreptei(d6, p12));
assert(!punctApartineDreptei(d6, p22));
assert(!punctApartineDreptei(d6, p13));
Punct pi = intersectia(d1, d6);
assert(egale(pi.x, 1.5));
assert(egale(pi.y, 1.5));

Triunghi t1 = {p11, p23, p32};
assert(egale(ariaHeron(t1), ariaDeterminant(t1)));
assert(egale(ariaHeron(t1), ariaInaltime(t1)));
Triunghi t2 = {p11, p32, p23};
assert(sensTriunghi(t1) == -sensTriunghi(t2));
Punct poligon1[] = {p11, p13, p33, p31};
assert(egale(ariaPoligonConvex(poligon1, poligon1 + 4), 4));
Punct poligon2[] = {p11, p13, p33, p31, p22};
assert(egale(ariaPoligon(poligon2, poligon2 + 5), 3));
Punct puncte[] = {p11, p12, p21, p22, p23, p32, p33};
MultimePuncte multime = {7, puncte};
multime = infasuratoareConvexa(multime);
assert(multime.n == 6);
for (int i = 0; i < multime.n; i++) {
//printf("%.0lf %.0lf\n", multime.puncte[i].x, multime.puncte[i].y);
assert(sensTriunghi({multime.puncte[i],
multime.puncte[(i + 1) % multime.n],
multime.puncte[(i + 2) % multime.n]}) > 0);
Dreapta d = obtineDreapta(multime.puncte[i],
multime.puncte[(i + 1) % multime.n]);
for (int j = 0; j < 7; j++) {
assert(semiplan(d, puncte[j]) <= 0);
}
}

PunctPolar polar12 = convertesteLaPolare(p12);
assert(egale(polar12.r, sqrt(5)));
assert(egale(polar12.alpha, acos(1 / sqrt(5))));
assert(egale(convertesteLaCarteziene(polar12).x, p12.x));
assert(egale(convertesteLaCarteziene(polar12).y, p12.y));
assert(egale(convertesteLaRadiani(convertesteLaGrade(1)), 1));
assert(egale(convertesteLaGrade(convertesteLaRadiani(1)), 1));
assert(egale(unghi(p32, p22, p23), PI / 2));
assert(egale(unghi(obtineDreapta(p11, p22), obtineDreapta(p21, p32)), 0));

return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1258 1258 - Pool (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1111 1111 - Squares (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1246 1246 - Tethered Dog (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1185 1185 - Wall (Timus)].

Clasa a 7-a lecția 26 - 07 apr 2016

2016-04-14T12:31:42Z

Dan: /* Lectie */

= Temă Rezolvari=
* [http://varena.ro/runda/2015-02-10-clasa-78-tema-18 Tema 25 clasa a 7 -a]
** Problema [http://varena.ro/problema/drept dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie''': cei de clasa a 7a pot pica teste cu TLE, este în regulă.
** Problema [http://varena.ro/problema/ssm subșirul de sumă maximă]
** Problema [http://varena.ro/problema/cmlsc subsecvența comună maximală]
** Cel mai lung subșir comun ( subsir comun de lungime maxima ): [http://www.pbinfo.ro/?pagina=probleme&id=396 SCLM]
* '''Opţional''' pentru clasa a 7a,
** Problema [http://varena.ro/problema/siruri2 şiruri 2] pentru distanța edit
** Problema [http://varena.ro/problema/pdm pdm] pentru înmulțirea optimală a unui șir de matrice
** Problema [http://varena.ro/problema/rucsac1 rucsac 1] pentru problema rucsacului 0-1
Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_18_-_10_feb_2015]

= Lectie =
Am rezolvat impreuna problema [http://acm.timus.ru/problem.aspx?num=1225 Flags]

Versiunea 1: Backtracking - am încercat toate posibilitățile de colorare ale steagurilor și le-am numărat. Am folosit o implementare recursivă pentru backtracking. Funcția recursivă returnează numărul de configurații de sufixe de steaguri valide.
<syntaxhighlight>
#include <cstdio>

const int MAX_N = 45;
const int WHITE = 0;
const int RED = 1;
const int BLUE = 2;

int N;
int v[MAX_N];

int backtracking(int i) {
// i = pozitia curenta (pe care o competam)
// N = numarul de fasii ale steagului
// returneaza numarul de steaguri
int answer = 0;
if (i == 0) {
v[i] = WHITE;
answer += backtracking(1);
v[i] = RED;
answer += backtracking(1);
} else if (i == N) {
if (v[N - 1] != BLUE)
answer++;
} else { // if (i <= N) {
if (v[i - 1] == WHITE) {
v[i] = BLUE;
answer += backtracking(i + 1);//nr de feluri in care putem
// completa steagul curent (de la poz. i + 1 la N)
v[i] = RED;
answer += backtracking(i + 1);//nr de feluri in care putem
// completa steagul curent (de la poz. i + 1 la N)
} else if (v[i - 1] == RED) {
v[i] = WHITE;
answer += backtracking(i + 1);
v[i] = BLUE;
answer += backtracking(i + 1);
} else if (v[i - 1] == BLUE && v[i - 2] == RED) {
v[i] = WHITE;
answer += backtracking(i + 1);
} else { //if (v[i - 1] == BLUE && v[i - 2] == WHITE) {
v[i] = RED;
answer += backtracking(i + 1);
}
}
return answer;
}

int main(void) {
int answer;

// citirea datelor
scanf("%d", &N);

// calcularea solutiei
answer = backtracking(0);

// afisarea solutiei
printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

Versiunea 2: Am simplificat foarte mult funcția recursivă.
<syntaxhighlight>
#include <cstdio>

const int MAX_N = 45;
const int WHITE = 0;
const int RED = 1;
const int BLUE = 2;

int N;

int backtracking(int last, int i) {
// i = pozitia curenta (pe care o competam)
// N = numarul de fasii ale steagului
// returneaza numarul de steaguri
int answer = 0;
if (i == N) {
answer++;
} else if (i < N) {
if (last == WHITE) {
answer += backtracking(RED, i + 2);
answer += backtracking(RED, i + 1);
} else { // if (last == RED) {
answer += backtracking(WHITE, i + 1);
answer += backtracking(WHITE, i + 2);
}
}
return answer;
}

int main(void) {
int answer;

// citirea datelor
scanf("%d", &N);

// calcularea solutiei
answer = backtracking(RED, 1) +
backtracking(WHITE, 1);

// afisarea solutiei
printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

Versiunea 3: Am simplificat și mai mult programul și se constată că acesta calculează șirul lui Fibonacci.
<syntaxhighlight>
#include <cstdio>

int backtracking(int N) {
if (N == 0)
return 0;
else if (N == 1)
return 1;
else // if (N > 0)
return backtracking(N - 2) + backtracking(N - 1);
}

int main(void) {
int N;
int answer;
// citirea datelor
scanf("%d", &N);
// calcularea solutiei
answer = 2 * backtracking(N);
// afisarea solutiei
printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

Versiunea 4: Am aplicat memoizare peste calculea șirului lui Fibonacci și am redus complexitatea timp de la exponențial la liniar.
<syntaxhighlight>
#include <cstdio>

const int MAX_N = 45;

unsigned int Fibo[1 + MAX_N];

unsigned int fibo(int N) {
if (Fibo[N] == 0) {
if (N == 0)
Fibo[N] = 0;
else if (N == 1)
Fibo[N] = 2;
else // if (N > 0)
Fibo[N] = fibo(N - 2) + fibo(N - 1);
}
return Fibo[N];
}

int main(void) {
int N;
unsigned int answer;
// citirea datelor
scanf("%d", &N);
// calcularea solutiei
answer = fibo(N);
// afisarea solutiei
printf("%u\n", answer);
return 0;
}
</syntaxhighlight>

= Tema =
* [http://varena.ro/runda/2016-04-07-clasa-7-tema-26 Tema 26 clasa a 7a]
** [http://varena.ro/problema/metro metro]
** [http://varena.ro/problema/maximumsum maximumsum]

Clasa a 7-a lecția 15 - 17 dec 2015

2016-01-27T12:16:46Z

Dan: /* Gramatica */

= Tema - rezolvări =

[http://varena.ro/runda/2015-12-10-clasa-7-tema-13 Tema 13 clasa a 7-a]
* [http://varena.ro/problema/paranteze3 Paranteze 3]
* [http://varena.ro/problema/expr Expr]
* [http://varena.ro/problema/expr Agenda]

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_lec%C8%9Bia_15_-_17_dec_2015]
== Paranteze 3 ==
Problema [http://varena.ro/problema/paranteze3 paranteze 3] este una introductivă în analiza sintactică. Aceasta nu înseamnă că este uşoară! Analiza sintactică necesită stăpînirea bună a recursivităţii şi gramaticilor, ambele materii avansate.

Precum am menţionat data trecută o gramatică simplă pentru acest limbaj este:

''E ⇾ ('('E')'|'{'E'}')*''

Programul care rezultă este destul de direct. Vom face o singură modificare analizorului recursiv cu proceduri şi anume convenim ca ''E()'' să returneze factorul maxim de imbricare din subexpresia recunoscută de ''E()''.

<syntaxhighlight>#include <stdio.h>

FILE *fin, *fout;
int first;

int E() {
int imb, maximb = 0;

while ( first == '(' || first == '{' ) {
imb = 0;
switch ( first ) {
case '{': // expresie { E }
first = fgetc( fin );
imb = E() + 1;
if ( imb <= 0 || first != '}' )
return -1;
first = fgetc( fin );
break;
case '(': // expresie ( E )
first = fgetc( fin );
imb = E() + 1;
if ( imb <= 0 || first != ')' )
return -1;
first = fgetc( fin );
break;
}
if ( imb > maximb )
maximb = imb;
}
return maximb;
}

int main() {
int i;

fin = fopen( "paranteze3.in", "r" );
first = fgetc( fin );
i = E();
if ( first != '\n' )
i = -1;
fclose( fin );

fout = fopen( "paranteze3.out", "w" );
fprintf( fout, "%d\n", i );
fclose( fout );

return 0;
}</syntaxhighlight>

== Expr ==
Problema [http://varena.ro/problema/expr expr] cere să evaluăm o expresie. Pentru aceasta să găsim mai întîi gramatica care descrie limbajul expresiilor aritmetice din problemă. Pentru aceasta să definim următorii termeni:

* '''Termen''': Un termen este o subexpresie care nu conţine adunări sau scăderi. Astfel, o expresie este formată dintr-o înşiruire de termeni care sînt despărţiţi de operatori plus sau minus. Un termen va fi format din factori care se înmulţesc sau împart.
* '''Factor''': Un factor este o subexpresie care nu conţine adunări, scăderi, înmulţiri sau împărţiri. El este, în principiu, un număr, în faţa căruia putem avea semne, operatori unari plus sau minus. Tot un factor este şi o expresie între paranteze.

Putem acum introduce gramatica:

''Expr ⇾ Term (('+'|'-')Term)*''
''Term ⇾ Fact (('*'|'/')Fact)*''
''Fact ⇾ Int | ('+'|'-')Fact|'('Expr')' ''
''Int ⇾ ('0'|'1'|'2'|...|'9')+''

Să generăm de exemplu expresia ''2+3*4'':

''Expr ⇾ Term + Term ⇾ Fact + Term ⇾ Int + Term ⇾ 2 + Term ⇾ 2 + Fact * Fact ⇾''
''⇾ 2 + Int * Fact ⇾ 2 + Int * Int ⇾ 2 + 3 * Int ⇾ 2 + 3 * 4''

În continuare vom scrie analizorul recursiv cu proceduri, cu o mică adăugire: fiecare funcţie asociată lui ''Expr'', ''Term'' şi ''Fact'' va returna valoarea subexpresiei analizate de acel neterminal. Astfel, în final, vom avea valoarea întregii expresii.

Iată programul care rezultă:

<syntaxhighlight>#include <stdio.h>

char f;
FILE *fin;

int expr();

int fact() {
char first;
int e;
switch ( f ) {
case '+':
case '-':
first = f;
f = fgetc( fin );
e = fact() * ((first == '+') ? 1 : -1);
break;
case '(':
f = fgetc( fin );
e = expr();
f = fgetc( fin );
break;
default:
e = 0;
do {
e = e * 10 + f - '0';
f = fgetc( fin );
} while ( f >= '0' && f <= '9' );
}
return e;
}

int term() {
char first;
int p = fact();
while ( f == '*' || f == '/' ) {
first = f;
f = fgetc( fin );
if ( first == '*' )
p *= fact();
else
p /= fact();
}
return p;
}

int expr() {
char first;
int s = term();
while ( f == '+' || f == '-' ) {
first = f;
f = fgetc( fin );
s += term() * ((first == '+') ? 1 : -1);
}
return s;
}

int main() {
FILE *fout;

fin = fopen( "expr.in", "r" );
f = fgetc( fin );
fout = fopen( "expr.out", "w" );
fprintf( fout, "%d\n", expr() );
fclose( fout );
fclose( fin );

return 0;
}</syntaxhighlight>

== Problema agenda ==
Problema [http://varena.ro/problema/agenda agenda] a fost dată la ONI 2014 baraj gimnaziu.

Tradusă în limbaj informatic problema este una clasică: date ''n'' intervale pe o dreapta, intervale ce se pot suprapune, să se găsească numarul maxim de suprapuneri, precum si cel mai mare interval pe dreapta unde nu se suprapune nici unul din intervalele originale.

Greutatea problemei constă în analiza intrării şi extragerea datelor. Acest gen de problemă este clasic în teoria compilării şi poartă numele de ''parsing''. În general nu este genul de problemă de rezolvat într-o oră şi 20 de minute. În continuare vom descrie, pe rînd, soluţiile la cele două părţi ale problemei.

=== Calcul ===
Să presupunem că pentru fiecare linie am reuşit să extragem cele două date sub forma ''Z L H M''. Desigur că pentru fiecare dată vom calcula un număr de minute echivalent, care reprezintă numărul de minute scurse de la începutul anului. Acum problema devine clasică şi avem două soluţii posibile:

==== Sortare şi scanare ====
Putem sorta capetele de intervale, ţinînd minte tipul capului, început sau sfîrşit de interval. Apoi vom parcurge în ordine aceste capete adunînd unu cînd începe un interval, sau scăzînd unu cînd se termină. Valoarea maximă a acestui număr de-a lungul parcurgerii ne va da maximul de intersecţii, adică punctul b. De asemenea, lungimea maximă pentru care acest număr este zero ne va da intervalul cerut la punctul c. Această soluţie este ''O(n log n)'' pentru sortare şi ''O(n)'' pentru scanare. Necesarul de memorie este ''O(n)'', mai exact vom avea nevoie de patru vectori, doi care ţin minte capetele şi doi care ţin minte tipul de capăt.

==== Calcul sume intervale ====
Care este scara de valori în care se încadrează capetele de interval? Ele sînt maxim numărul de minute într-un an, -adică ''365 * 24 * 60 = 525600''. Precum ştim deja, în situaţiile cînd valorile capetelor de interval sînt rezonabil de mici putem folosi precalcularea pentru a calcula suma acestor intervale în fiecare punct pe axă, sau, aşa cum îi spuneţi voi, ''şmenul lui Mars''. Vom folosi un singur vector de ''525600'' elemente, iniţial zero. Pentru fiecare interval vom marca pe vector elementul de la care vom aduna ''1'' pîna la finalul vectorului, adică începînd cu capătul din stînga. Totodată vom marca şi elementul de la care vom scădea 1 pînă la finalul vectorului, adică începînd cu capătul din dreapta. După ce am "aşezat" astfel toate intervalele pe vector vom calcula pur şi simplu sumele parţiale de la 0 la ''i'', pentru fiecare element <tt>v[i]</tt>. Pentru aceasta vom folosi acelaşi vector. După această prelucrare vom şti pentru fiecare minut al anului cîte activităţi de petrec în acel minut.

Punctul b se rezolvă găsind maximul în acest vector. Punctul c se rezolvă găsind cea mai lungă secvenţă de zerouri încadrată de elemente diferite de zero.

Această soluţie are avantajul simplităţii, neavînd nevoie de sortare. Complexitatea ei este ''O(n + m)'' unde ''m'' este valoarea maximă a capătului de interval. Memoria ocupată este de asemenea ''O(n + m)''. Deoarece avem maxim 1000 de activităţi rezultă nu putem avea mai mult de 1000 de intervale suprapuse într-un punct. De aceea vom declara un vector de elemente <tt>short</tt> folosind circa 1MB de memorie.

=== Parsing ===
Cum spuneam, această problemă este clasică în compilare. Pentru rezolvare vom folosi, deci, metode clasice. Din pacate acestea se predau abia în facultate. Să vedem.

==== Observaţii ====
* Putem ignora spaţiile. De aceea o funcţie necesară este cea care ne dă următorul caracter diferit de spaţiu. O vom denumi <tt>nextChar()</tt>;
* Pentru a delimita cuvintele (numere, luni) vom avea nevoie să ne oprim cînd dăm de un caracter care nu se potriveşte (non-cifra sau non-litera). Dar, acel caracter va trebui folosit pentru cuvîntul următor, de exemplu după lună urmează ora. De aceea vom memora primul caracter citit dar nefolosit într-o variabilă globală <tt>first</tt>. Funcţia <tt>nextChar()</tt> va citi din fişier primul caracter non-spaţiu şi-l va depozita în <tt>first</tt>.
* Vom scrie funcţii pentru a parsa un întreg, un cuvînt format numai din litere, o dată completă, precum şi o întreagă linie.
* Traducerea de la numele unei luni la numărul ei se poate face eficient astfel: observăm că primele trei litere identifică unic luna. Deoarece avem numai ''26·26·26'' combinaţii putem folosi un vector de frecvenţă pentru a stoca numărul de lună pentru fiecare din combinaţii. Sau, şi mai bine, o matrice tridimensională de frecvenţă:

:<tt>ind_luna[luna[0]-'a'][luna[1]-'a'][luna[2]-'a']</tt>

:este chiar numărul lunii din variabila <tt>luna[]</tt>.

==== Gramatica ====
Putem scrie o gramatică pentru fiecare linie, de exemplu:

:''Dates -> Date '-' Date Any*''
:''Date -> Int Word Int '.' Int''
:''Word -> Alpha+''
:''Alpha -> ['a'..'z'] | ['A'..'Z']''
:''Int -> ['0'..'9']+''

==== Implementare 1 ====
Vă recomand să citiţi cu atenţie soluţia prezentată mai jos. Ea urmează toate aceste idei, clasice şi este comentată pentru a fi înţeleasă uşor. Din această problemă învăţăm ceva foarte general şi anume cum se face parsing. Această metodă se foloseşte în multe alte situaţii, cum ar fi analiza expresiilor numerice.

<syntaxhighlight>
#include <stdio.h>
#include <ctype.h> // pentru isdigit() si isalpha()

#define NR_LUNI 12
#define MIN_PER_AN (365*24*60)
#define NL 26

short minute[MIN_PER_AN+2];
int zile_pina[NR_LUNI] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 };
char nume[NR_LUNI][4] = { "ian", "feb", "mar", "apr", "mai", "iun", "iul",
"aug", "sep", "oct", "noi", "dec" };
char ind_luna[NL][NL][NL]; // folosit pentru calcul numar luna din numele ei
int first; // primul caracter ne-spatiu din fisierul de la intrare
FILE *fin, *fout;

// Initializeaza tabelul de indici ai unei luni. Data o luna calculam
// rapid indicele ei uitindu-ne la primele trei litere, cu care mergem
// intr-un tabel de 26*26*26 elemente
void calcTabelIndiciLuni() {
int i;
for ( i = 1; i < NR_LUNI; i++ )
ind_luna[nume[i][0] - 'a'][nume[i][1] - 'a'][nume[i][2] - 'a'] = i;
}

// Dat numele unei luni returneaza numarul ei
inline int indice( char *luna ) {
return ind_luna[luna[0] - 'a'][luna[1] - 'a'][luna[2] - 'a'];
}

// Citeste un singur caracter non-whitespace de la intrare
inline void nextChar() {
while ( (first = fgetc( fin )) == ' ' ); // sari peste spatii
}

// Citeste un intreg de la intrare
int getInt() {
int n = 0;
while ( isdigit( first ) ) {
n = n * 10 + first - '0';
nextChar();
}
return n;
}

// Citeste un cuvint format numai din litere de la intrare
void getWord( char *cuv ) {
int i = 0;
while( isalpha( first ) ) {
cuv[i++] = tolower( first );
nextChar();
}
cuv[i] = 0;
}

// Citeste o data calendaristica si returneaza numarul de minute scurse de la
// inceputul anului pina la aceasta data
int getDate() {
int zi, ora, min;
char luna[11];

zi = getInt(); // ziua
getWord( luna ); // luna
ora = getInt(); // ora
nextChar(); // ignora punctul
min = getInt(); // minutul

return (zile_pina[indice( luna )] + (zi-1)) * 24 * 60 + ora * 60 + min;
}

// Citeste o linie si calculeaza numarul de minute a primei date si al ultimei
// date.
void getDates( int *pprimul, int *pultimul ) {
(*pprimul) = getDate(); // prima data a liniei
nextChar(); // ignora caracterul '-'
(*pultimul) = getDate(); // a doua data a liniei
while ( (first = fgetc( fin )) != '\n' ); // cauta finalul de linie
nextChar(); // treci la primul caracter pe linia urmatoare (sau EOF)
}

int main() {
int cerinta, i, lun_max, max_simultan, pauza, pauza_max, primul, ultimul,
final_min, inceput_max;

for ( i = 1; i < NR_LUNI; i++ ) // calculeaza nr. zile pina la luna curenta
zile_pina[i] += zile_pina[i-1];

calcTabelIndiciLuni(); // initializeaza tabelul conversie nume luna -> numar

fin = fopen( "agenda.in", "r" );
fscanf( fin, "%d ", &cerinta );
nextChar(); // avanseaza pe primul caracter diferit de spatiu
inceput_max = lun_max = 0;
final_min = MIN_PER_AN;
while ( first != EOF ) { // cita vreme nu e final de fisier
getDates( &primul, &ultimul ); // citeste o linie
if ( ultimul < final_min ) // cel mai mic final de activitate
final_min = ultimul;
if ( primul > inceput_max ) // cel mai mare inceput de activitate
inceput_max = primul;
if ( ultimul - primul > lun_max ) // cerinta 1, lungimea maxima
lun_max = ultimul - primul;
minute[primul]++;
minute[ultimul]--;
}
fclose( fin );

fout = fopen( "agenda.out", "w" );
switch ( cerinta ) {
case 1:
fprintf( fout, "%d %d %d\n", lun_max/(24*60), lun_max/60%24, lun_max%60 );
break;
case 2:
// calcul sume intervale suprapuse
// cerinta 2, numarul maxim de activitati simultane
max_simultan = 0;
for ( i = 1; i <= MIN_PER_AN; i++ )
if ( (minute[i] += minute[i-1]) > max_simultan )
max_simultan = minute[i];
fprintf( fout, "%d\n", max_simultan );
break;
case 3:
// cerinta 3, pauza maxima fara nici o activitate
for ( i = 1; i <= MIN_PER_AN; i++ )
minute[i] += minute[i-1];
pauza_max = pauza = 0;
for ( i = final_min; i < inceput_max; i++ )
if ( minute[i] == 0 ) {
if( ++pauza > pauza_max )
pauza_max = pauza;
} else
pauza = 0;
fprintf( fout, "%d %d %d\n", pauza_max/(24*60), pauza_max/60%24, pauza_max%60 );
}
fclose( fout );

return 0;
}
</syntaxhighlight>

==== Implementare 2 ====
O altă implementare găsiți și mai jos:

<syntaxhighlight>
#include <stdio.h>
#include <string.h>

int zileLuna[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
char mat[][11] = {
"ianuarie",
"februarie",
"martie",
"aprilie",
"mai",
"iunie",
"iulie",
"august",
"septembrie",
"octombrie",
"noiembrie",
"decembrie",
};

FILE *fin,*fout;

char c;

int n;
struct Date {
int in, sf;
} v[1001];

#define SHM_MAX (365 * 24 * 60)
short int shm[SHM_MAX];

void advance() {
do {
c = fgetc(fin);
} while(c == ' ');
}

int numar() {
int nr = 0;
while ('0' <= c && c <= '9') {
nr = nr * 10 + (c - '0');
advance();
}
return nr;
}

int luna() {
char s[11];
int i=0;
while((c>='a' && c<='z') || (c>='A' && c<='Z')){
if(c>='A' && c<='Z')
c=c-'A'+'a';
s[i++]=c;
advance();
}
s[i] = 0;
i = 0;
while (strcmp(s, mat[i]) != 0)
i++;
return i;
}

int data() {
int zi = numar();
int lun = luna();
int ora = numar();
advance(); // '.'
int minut = numar();
//printf("%d %d %d %d\n", zi, lun + 1, ora, minut);
return ((zileLuna[lun] + (zi - 1)) * 24 + ora) * 60 + minut;
}

Date inregistrare() {
Date raspuns;
raspuns.in = data();
advance(); // '-'
raspuns.sf = data();
while(c != '\n' && c != EOF) {
advance();
}
while(c == '\n') {
advance();
}
return raspuns;
}

void afisare(int minute) {
fprintf(fout, "%d %d %d", minute / 1440, minute % 1440 / 60, minute % 60);
}

int main() {
fin = fopen("agenda.in", "r");
fout = fopen("agenda.out", "w");

int i;
int cer;
fscanf(fin, "%d\n", &cer);
n = 0;
advance();
while (c != EOF) {
v[n++] = inregistrare();
}

int max;
if (cer == 1) {
max = 0;
for (i = 0; i < n; i++)
if (v[i].sf - v[i].in > max)
max = v[i].sf - v[i].in;
afisare(max);
} else { // if (cer == 2 || cer == 3) {
int simultane;
for (i = 0; i < n; i++) {
shm[v[i].in]++;
shm[v[i].sf]--;
}
simultane = shm[0];
for (i = 1; i < SHM_MAX; i++) {
shm[i] += shm[i - 1];
if (shm[i] > simultane)
simultane = shm[i];
}
if (cer == 2) {
fprintf(fout, "%d", simultane);
} else { // if (cer == 3) {
int inceput, sfarsit, degeaba;
degeaba = 0;
inceput = SHM_MAX;
for (i = 1; i < SHM_MAX; i++) {
if (shm[i] == 0 && shm[i - 1] > 0) {
inceput = i;
} else if (shm[i] > 0 && shm[i - 1] == 0) {
sfarsit = i;
if (sfarsit - inceput > degeaba) {
degeaba = sfarsit - inceput;
}
}
}
afisare(degeaba);
}
}
return 0;
}
</syntaxhighlight>

= Lecție =
== Precalculare ==
Precalcularea este un termen general pentru folosirea unor structuri auxiliare de date, fără o legătură directă cu problema de rezolvat, care ne ajută în rezolvarea problemei. Aceste structuri de date sînt calculate la început, ceea ce duce la denumire: precalculare.

În continuare vom vorbi despre cîteva exemple clasice de precalculare.

=== Ciurul lui Eratostene ===
V-aţi gîndit vreodată că ciurul lui Eratostene este de fapt o precalculare a unui vector de frecvenţă <tt>f[]</tt>, care, pentru fiecare număr <tt>p</tt>, calculează <tt><nowiki>f[p]</nowiki></tt> care ne spune dacă p este prim? Avem cele doua variante, cea originală:

<syntaxhighlight>for ( d = 2; d < n; d++ )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d + d; i <= n; i = i + d ) // vom marca numerele din d in d
ciur[i] = 1;</syntaxhighlight>

Există desigur şi varianta cu două optimizări:

# În a doua buclă <tt>for</tt> variabila <tt>i</tt> ia valorile <tt>2∙d, 3∙d, 4∙d, ..., k∙d</tt>. Pentru <tt><nowiki>k < d</nowiki></tt> toate valorile de forma <tt>k∙d</tt> au fost deja tăiate de valorile <tt>k</tt> anterioare, drept pentru care nu are rost să le mai parcurgem. Putem să pornim cu <tt>i</tt> de la <tt>d∙d</tt>.
# Conform observației anterioare <tt>i</tt> pornește de la <tt>d∙d</tt>. De aceea nu are rost să mergem cu <tt>d</tt> mai departe de <tt>sqrt(n)</tt>, deoarece nu vom mai găsi <tt>i</tt> astfel încît <tt>i ≤ n</tt>.

Implementarea optimizată:

<syntaxhighlight>
for ( d = 2; d * d <= n; d++ )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d * d; i <= n; i = i + d ) // vom marca numerele din d in d
ciur[i] = 1;</syntaxhighlight>

Şi acum surpriza: complexitatea ciurului lui Eratostene este O(n log log n) '''în ambele variante'''. '''Optimizările nu schimbă complexitatea''' algoritmului. Desigur că ele schimbă constanta, motiv pentru care le şi facem.

=== Numărul de divizori primi ai numerelor pînă la ''n'' ===

Ciurul lui Eratostene poate fi extins să calculeze numărul de divizori primi ai fiecărui număr din vectorul de frecvență. Modificarea este uşoară: vom folosi prima variantă, neoptimizată, şi în loc să marcăm cu 1 numerele neprime, vom aduna 1, marcînd faptul că acel număr prim divide numărul neprim.

=== Suma între i şi j ===
În multe probleme apare următoarea subproblemă: avem un vector de n elemente întregi, să se răspundă la multe întrebări de forma '''care este suma elementelor vectorului între poziţiile i şi j?'''. În acest caz vom precalcula o structură de date auxiliară, şi anume un vector <tt>s</tt>, astfel încît <tt><nowiki>s[i]</nowiki></tt> este suma elementelor de la <tt>0</tt> pînă la <tt>i</tt>. El se mai numeşte şi vectorul sumei prefixelor lui <tt>v</tt>. Construcția acestui vector se poate face liniar deoarece avem relaţia <tt><nowiki>s[i] = s[i-1] + v[i]</nowiki></tt>.

Odată calculat acest vector putem răspunde în timp constant la întrebări. Suma elementelor între <tt>i</tt> şi <tt>j</tt> este <tt><nowiki>s[j] - s[i-1]</nowiki></tt>. Memoria folosită este ''O(n)''.

=== Suma între (i, j) şi (ii, jj) ===
Este problema anterioară extinsă la matrice: avem o matrice de numere întregi şi întrebări de forma: '''care este suma elementelor matricei în dreptunghiul care are drept colţuri opuse (i1, j1) şi (i2, j2)?'''. Această problemă apare în problema [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1451 puncte5] dată la barajul de gimnaziu în 2012. În mod similar vom precalcula o matrice auxiliară cu suma elementelor matricei originale între <tt>(0, 0)</tt> şi <tt>(i, j)</tt>. Ea poate fi calculată în timp constant per element, astfel:

[[Image:matrice-numar-1.gif|frame|none|Calcul matrice sume parțiale în dreptunghiuri care pornesc în origine]]

<nowiki>s[i][j] = s[i][j-1] + s[i-1][j] - s[i-1][j-1] + m[i][j]</nowiki>

Odată calculată matricea s putem răspunde în timp constant la întrebări. Suma elementelor între <tt>(i, j)</tt> şi <tt>(ii, jj)</tt> este:

<nowiki>S = s[ii][jj] - s[ii][j-1] - s[i-1][jj] + s[i-1][j-1]</nowiki>

[[Image:matrice-numar-1-dreptunghi.gif|frame|none|Calcul suma numerelor în orice dreptunghi]]

=== Numărul de biţi 1 într-un întreg ===
Cum putem calcula numărul de cifre <tt>1</tt> din reprezentarea în baza <tt>2</tt> a unui număr?

* Direct: shift and mask.
* Folosind expresia <tt>x & (x - 1)</tt>.
* Cu precalculare: ţinem un vector în care elementul <tt><nowiki>v[x]</nowiki></tt> este numărul de biţi <tt>1</tt> din reprezentarea în baza <tt>2</tt> a lui <tt>x</tt>.
* Gîndiţi-vă la un algoritm fără vectori, dar mai rapid decît ''O(nr. biţi)'' (algoritmii discutaţi anteriori sînt ''O(nr. biţi)''.

=== Sume de intervale ===
Se dă un vector cu ''n'' elemente, iniţial zero. O operaţiune pe acest vector constă în incrementarea fiecărui element între indicii ''i'' şi ''j''. Se dau, de asemenea, ''m'' operaţiuni de executat. Să se afişeze valorile finale ale vectorului.

Soluţia forţă brută implică execuţia celor ''m'' operaţiuni. O operaţiune constă în incrementarea a maxim ''n'' elemente din vector, deci avem ''n x m'' operaţii, plus afişarea elementelor finale. Complexitatea totală este ''O(mn)''.

Se poate mai bine? Putem optimiza timpul unei operaţiuni. Ideea este următoarea: în loc să incrementăm pe rînd elementele vectorului, am putea să le grupăm. Pentru aceasta vom întîrzia incrementarea, marcînd doar locurile unde trebuie să adunăm.

Cu alte cuvinte: am putea considera intervalele ca pe nişte paranteze aşezate pe o dreaptă. O paranteză deschisă înseamnă că de acum înainte trebuie să adunăm 1 la toate elementele care urmează. O paranteză închisă înseamnă că ne putem opri din adunat 1. Să presupunem că nu avem capete de interval suprapuse. Atunci am putea memora parantezele într-un vector separat. Vom memora 1 pentru o paranteză deschisă, -1 pentru o paranteză închisă şi 0 în caz că nu avem nici un capăt de interval în acel element.

'''Ipoteză''': vectorul de sume parţiale ale acestui vector constituie chiar rezolvarea problemei. Să observăm ce se întîmplă atunci cînd adunăm <tt>s[i] = s[i] + s[i-1]</tt>: la început avem elemente zero. Cînd deschidem o paranteză acel element devine 1. Următoarele sume parţiale vor fi şi ele tot 1, pînă dăm de un alt capăt de interval. Să presupunem că mai deschidem o paranteză. Atunci suma va deveni 2 şi ea se va propaga în continuare pe elemente zero. Apoi să presupunem că se închide o paranteză. Adunînd -1 suma devine iarăşi 1, care se va propaga în continuare.

Funcţionează acest algoritm dacă avem capete de interval suprapuse? Da, cu condiţia ca elementul în care se suprapun capete să fie '''suma''' acelor capete, adică o sumă de 1 şi -1. Aceasta înseamnă că atunci cînd generăm vectorul de paranteze nu vom scrie <tt>s[i] = 1</tt> ci <tt>s[i]++</tt> (la fel şi pentru -1, vom decrementa).

'''Generalizare 1''': putem generaliza această metodă pentru problema în care intervalele nu adună 1, ci orice număr, constant pe parcursul intervalului. Cum generalizăm? O paranteză deschisă nu va aduna 1 ci constanta respectivă.

'''Generalizare 2''': dar dacă vectorul iniţial are valori diferite de zero? În acest caz vom calcula un vector separat, iniţializat cu zero, pe care facem calculul sumelor parţiale. Acest vector ne va spune cu cît s-a mărit fiecare element zero. În final vom aduna acest vector de sume parţiale la vectorul iniţial.

Acesta exemplu de precalculare, este cunoscut printre unii din voi drept "șmenul lui Mars", denumire care îmi displace deoarece sugerează că informatica este o colecție de șmenuri.

Cînd nu funcţionează această soluţie? Atunci cînd nu avem vector iniţial (elementele sînt toate zero), iar coordonatele intervalelor sînt prea mari pentru ca vectorul de sume parţiale să încapă în memorie. Să presupunem că ni se cere numărul maxim din vectorul de sume parţiale. În acest caz există o soluţie alternativă, mai generală (în sensul în care rezolvă o clasă mai mare de probleme cu intervale), care nu folosește precalculare: putem memora capetele de intervale, pe care apoi le ordonăm crescător, ţinînd minte de ce tip sînt, închis sau deschis. Apoi le parcurgem în ordine, calculînd sumele parţiale fără să le stocăm. Suma parţială maximă este răspunsul cerut.

Desigur că atunci cînd vectorul încape în memorie, e mai uşoară precalcularea. Acest tip de precalculare se poate extinde în două dimensiuni, pe matrice: se dau ''m'' dreptunghiuri care adună 1 la toate elementele respective dintr-o matrice. Această precalculare necesită ''O(n2)'' memorie. Ea nu se justifică decît în măsura în care este facil de programat, deoarece avem o soluție de aceeași complexitate care folosește varianta pe vector, folosind doar ''O(n)'' memorie.

=== Exemple de probleme cu precalculare ===
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1371 paisprezece]: necesită precalcularea unui vector al primelor 17 numere prime, precum şi a ciurului lui Eratostene.
* [http://varena.ro/problema/intervale intervale]: necesită precalcularea ciurului lui Eratostene precum şi a sumelor parţiale ale numărului de divizori primi.
* [http://varena.ro/problema/reginald reginald], o extindere a problemei anterioare.
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1451 puncte5]: necesită precalcularea sumelor parţiale ale unei matrice.
* [http://varena.ro/problema/extraterestri extraterestri] precalculare vector sume prefixe parțiale (a.k.a. șmenul lui Mars)
* [http://varena.ro/problema/extraterestri1 extraterestri1] Mars + normalizare coordonate
* [http://varena.ro/problema/flori flori] precalculare matrice sume prefixe parţiale (a.k.a. şmenul lui Mars 2D)
* [http://varena.ro/problema/flori1 flori1] exemplu de problemă nerezolvabilă cu precalculare 2D din lipsă de memorie

Alte probleme:

* [http://varena.ro/problema/el el] necesită precalcularea sumelor parţiale pe liniile si coloanele unei matrice.

=== Concluzii ===
* Precalcularea foloseşte atunci cînd avem de răspuns la mai multe întrebări costisitoare. Aceste întrebări pot fi explicite, cerute de enunţ, sau implicite, decurgînd din metoda de rezolvare, ca la problema [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1451 puncte5].
* Precalcularea poate folosi şi atunci cînd numărul de întrebări este mult mai mare decît numărul de răspunsuri posibile, caz în care putem precalcula toate răspunsurile într-un tabel înainte de a răspunde la întrebări.
* Precalcularea foloseşte o structură de date adiţională şi memorie suplimentară. Uneori putem economisi memorie folosindu-ne chiar de structura de date iniţială.

= Tema =

[http://varena.ro/runda/2015-12-17-clasa-7-tema-14 Tema 14 clasele 7/8]
* [http://varena.ro/problema/expresie Expresie] dată la OJI 2009 clasa a 9a
* [http://varena.ro/problema/adun Adun] dată la ONI 2006 clasa a 8a

Incercati sa rezolvati in vacanta si cateva din problemele cu precalculare. Vom reveni asupra temei, dupa vacanta.

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_14_-_6_ian_2015]

Clasa a 8-a lecția 7 - 4 nov 2015

2016-01-18T09:21:44Z

Dan: /* Înfășurătoarea convexă a unei mulțimi de puncte */

= Triunghiul =

== Reprezentarea în memoria calculatorului ==
Vom stoca un triunghi prin cele trei puncte care îl determină:
<syntaxhighlight>
struct Triunghi {
Punct A;
Punct B;
Punct C;
};
</syntaxhighlight>

== Calculul ariei (cu formula lui Heron) ==
Formula lui Heron pentru calculul ariei unui triunghi cu vârfurile A, B și C este:
<pre>
a = BC
b = AC
c = AB
p = (a + b + c) / 2
Aria = sqrt((p - a) * (p - b) * (p - c) * p)
</pre>

Putem calcula aria folosind formula lui Heron astfel:
<syntaxhighlight>
double ariaHeron(Triunghi t) {
double a = distanta(t.B, t.C);
double b = distanta(t.A, t.C);
double c = distanta(t.A, t.B);
double p = (a + b + c) / 2;
return sqrt((p - a) * (p - b) * (p - c) * p);
}
</syntaxhighlight>

== Calculul ariei (cu determinant) ==
Formula de calcul a ariei unui triunghi cu vârfurile A, B și C cu ajutorul unui determinant este:
<pre>
| A.x A.y 1 |
D = | B.x B.y 1 |
| C.x C.y 1 |
Aria = |D| / 2
</pre>

Putem calcula aria cu ajutorul determinantului astfel:
<syntaxhighlight>
double determinant(Triunghi t) {
return t.A.x * t.B.y
+ t.B.x * t.C.y
+ t.C.x * t.A.y
- t.C.x * t.B.y
- t.A.x * t.C.y
- t.B.x * t.A.y;
}

double ariaDeterminant(Triunghi t) {
return fabs(determinant(t)) / 2;
}
</syntaxhighlight>

== Calculul ariei (cu înălțimea) ==
Formula pentru calculul ariei unui triunghi cu vârfurile A, B și C cu ajutorul înălțimii este:
<pre>
Aria = AB * dist(C, AB) / 2
</pre>

Putem calcula aria cu ajutorul înățimii astfel:
<syntaxhighlight>
double ariaInaltime(Triunghi t) {
return distanta(t.A, t.B) * distanta(obtineFormaCanonica(obtineDreapta(t.A, t.B)), t.C) / 2;
}
</syntaxhighlight>

== Sensul punctelor unui triunghi ==
Cele trei puncte ale unui triunghi pot fi date în sens trigonometric sau în sensul acelor de ceasornic.

Putem determina sensul în care sunt date în două feluri:
* cu semnul determinantului;
* cu semnul semiplanului mărginit de dreapta formată de primele două puncte și care îl conține pe al treilea.

Putem afla sensul punctelor unui triunghi astefel:
<syntaxhighlight>
int sensTriunghi(Triunghi t) {
if (determinant(t) < 0) {
return -1;
} else {
return 1;
}
}
</syntaxhighlight>

= Poligonul =
== Reprezentarea în memoria calculatorului ==
Vom stoca un poligon prin lista punctelor care îl determină.

== Calculul ariei unui poligon convex ==
Un poligon convex cu N vârfuri poate fi partiționat în N-2 triunghiuri astfel:
<pre>
(1,2,3), (1,3,4), (1,4,5), ..., (1,i,i+1), ..., (1, N-1, N)
</pre>

Folosindu-ne de această triangulare (sau de o alta) putem calcula aria poligonului adunând ariile triunghiurilor din triangulare.

Putem implementa aria unui poligon convex astfel:
<syntaxhighlight>
double ariaPoligonConvex(Punct* primul, Punct* dupaUltimul) {
double aria = 0;
Punct p1 = *primul;
Punct *pi;
for (pi = primul + 1; pi + 1 != dupaUltimul; pi++) {
aria += ariaDeterminant({p1, *pi, *(pi + 1)});
}
return aria;
}
</syntaxhighlight>

== Calculul ariei unui poligon oarecare ==
Pentru calculul ariei unui poligon concav ne vom folosi de aceeași triangulare dar vom observa că suma ariilor triunghiurilor va fi mai mare decât aria poligonului, deoarece va conține suprafețe exterioare poligonului.

Totuși, uitându-ne cu atenție, vom vedea că dacă vom ține cont de sensul triunghiurilor și vom aduna ariile triunghiurilor care au același sens cu sensul poligonului și vom scădea ariile triunghiurilor care au sens contrar cu sensul poligonuli vom obține exact aria poligonului.

Mai mult, această abordare funcționează și pentru poligoanele convexe.

Putem implementa aria unui poligon oarecare astfel:
<syntaxhighlight>
double ariaPoligon(Punct* primul, Punct* dupaUltimul) {
double aria = 0;
Punct p1 = *primul;
Punct *pi;
for (pi = primul + 1; pi + 1 != dupaUltimul; pi++) {
aria += determinant({p1, *pi, *(pi + 1)});
}
return fabs(aria) / 2;
}
</syntaxhighlight>

= Înfășurătoarea convexă a unei mulțimi de puncte =
Dându-se o mulțime de puncte în plan, să se determine un poligon convex de arie minimă care conține toate punctele din mulțime în interior, pe laturi sau în vârfuri.

Se observă că, în plus, acest poligon convex are și perimetrul minim.

Devine evident că, pentru a minimiza aria, unele dintre punctele din mulțimea inițială vor ajunge să definească vârfurile poligonului-înfășurătoare.

Algoritmul de calcul al înfășurătorii convexe este următorul:
<pre>
1. În vectorul P, se sortează toate punctele Pi crescător, după coorodonata X.
2. Fie o stivă S, inițial vidă.
3. Se adaugă în stivă primele două puncte din vectorul P.
4. Pentru fiecare punct Pi (3 <= i <= N):
5. Se adaugă în stivă punctul Pi
6. Cât timp în stivă se află cel puțin 3 puncte iar sensul triunghiului determinat de acestea este unul anume
7. Se scoate penutimul punct din stivă
8. În stivă avem jumătate din punctele de pe înfășurătoare (cele de deasupra sau de dedesupt în funcție de sensul ales)
9. Se inversează vectorul P
10.Se repetă pașii 2-7 pentru a determina și a doua jumătate a punctelor de pe înfășurătoare.
</pre>

Putem implementa înfășurătoarea convexă a unei mulțimi de puncte astfel:
<syntaxhighlight>
struct MultimePuncte {
int n;
Punct* puncte;
};

int compararePuncte(const void* arg1, const void* arg2) {
if (((Punct*)arg1)->x == ((Punct*)arg2)->x &&
((Punct*)arg1)->y == ((Punct*)arg2)->y) {
return 0;
} else if (((Punct*)arg1)->x < ((Punct*)arg2)->x ||
(((Punct*)arg1)->x == ((Punct*)arg2)->x &&
((Punct*)arg1)->y < ((Punct*)arg2)->y)) {
return -1;
} else {
return 1;
}
}

MultimePuncte deal(MultimePuncte in) {
int i;
int dimStiva = 0;
Punct* stiva = (Punct*)malloc(sizeof(Punct) * in.n);
stiva[dimStiva++] = in.puncte[0];
stiva[dimStiva++] = in.puncte[1];
for (i = 2; i < in.n; i++) {
stiva[dimStiva++] = in.puncte[i];
while (dimStiva >= 3 &&
sensTriunghi(Triunghi{stiva[dimStiva - 3],
stiva[dimStiva - 2], stiva[dimStiva - 1]}) <= 0) {
dimStiva--;
stiva[dimStiva - 1] = stiva[dimStiva];
}
}
return MultimePuncte{dimStiva, stiva};
}

MultimePuncte inverseaza(MultimePuncte in) {
int i;
for (i = 0; i < in.n - i - 1; i++) {
Punct tmp = in.puncte[i];
in.puncte[i] = in.puncte[in.n - i - 1];
in.puncte[in.n - i - 1] = tmp;
}
return in;
}

MultimePuncte infasuratoareConvexa(MultimePuncte in) {
if (in.n >= 3) {
int i;
Punct* outPuncte = (Punct*)malloc(sizeof(Punct) * in.n);
for (i = 0; i < in.n; i++) {
outPuncte[i] = in.puncte[i];
}
MultimePuncte out = MultimePuncte{in.n, outPuncte};
qsort(outPuncte, in.n, sizeof(Punct), compararePuncte);
MultimePuncte jos = deal(out);
out = inverseaza(out);
MultimePuncte sus = deal(out);
out.n = 0;
for (i = 0; i < jos.n - 1; out.n++, i++) {
out.puncte[out.n] = jos.puncte[i];
}
for (i = 0; i < sus.n - 1; out.n++, i++) {
out.puncte[out.n] = sus.puncte[i];
}
free(jos.puncte);
free(sus.puncte);
return out;
} else {
return in;
}
}
</syntaxhighlight>

= Testare =
Pentru a testa codul de mai sus am scris următoarea funcție main():
<syntaxhighlight>
int main(void) {
Punct p11 = {1, 1}, p12 = {1, 2}, p13 = {1, 3};
Punct p21 = {2, 1}, p22 = {2, 2}, p23 = {2, 3};
Punct p31 = {3, 1}, p32 = {3, 2}, p33 = {3, 3};
assert(egale(distanta(p11, p22), sqrt(2)));
Dreapta d1 = obtineDreapta(p11, p22);
assert(punctApartineDreptei(d1, p33));
assert(!punctApartineDreptei(d1, p23));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
DreaptaCanonica d1prim = obtineFormaCanonica(d1);
assert(egale(d1prim.a * d1prim.a + d1prim.b * d1prim.b, 1));
assert(coincid(d1, d1prim));
Dreapta d2 = obtineDreapta(p21, p32);
assert(suntParalele(d1, d2));
Dreapta d3 = obtineDreapta(p11, p31);
assert(!suntParalele(d1, d3));
assert(egale(distanta(d1prim, p21), sqrt(2) / 2));
Dreapta d4 = paralelaPrin(d1, p21);
assert(punctApartineDreptei(d4, p32));
assert(!punctApartineDreptei(d4, p33));
Dreapta d5 = obtineDreapta(p12, p21);
assert(suntPerpendiculare(d1, d5));
assert(!suntPerpendiculare(d1, d2));
Dreapta d6 = perpendicularaPrin(d1, p21);
assert(punctApartineDreptei(d6, p12));
assert(!punctApartineDreptei(d6, p22));
assert(!punctApartineDreptei(d6, p13));
Punct pi = intersectia(d1, d6);
assert(egale(pi.x, 1.5));
assert(egale(pi.y, 1.5));

Triunghi t1 = {p11, p23, p32};
assert(egale(ariaHeron(t1), ariaDeterminant(t1)));
assert(egale(ariaHeron(t1), ariaInaltime(t1)));
Triunghi t2 = {p11, p32, p23};
assert(sensTriunghi(t1) == -sensTriunghi(t2));
Punct poligon1[] = {p11, p13, p33, p31};
assert(egale(ariaPoligonConvex(poligon1, poligon1 + 4), 4));
Punct poligon2[] = {p11, p13, p33, p31, p22};
assert(egale(ariaPoligon(poligon2, poligon2 + 5), 3));
Punct puncte[] = {p11, p12, p21, p22, p23, p32, p33};
MultimePuncte multime = {7, puncte};
multime = infasuratoareConvexa(multime);
assert(multime.n == 6);
for (int i = 0; i < multime.n; i++) {
//printf("%.0lf %.0lf\n", multime.puncte[i].x, multime.puncte[i].y);
assert(sensTriunghi({multime.puncte[i],
multime.puncte[(i + 1) % multime.n],
multime.puncte[(i + 2) % multime.n]}) > 0);
Dreapta d = obtineDreapta(multime.puncte[i],
multime.puncte[(i + 1) % multime.n]);
for (int j = 0; j < 7; j++) {
assert(semiplan(d, puncte[j]) <= 0);
}
}
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1753 1753 - Bookshelf (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1333 1333 - Genie Bomber 2 (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1052 1052 - Rabbit Hunt (Timus)].

Clasa a 8-a lecția 6 - 28 oct 2015

2016-01-11T10:01:57Z

Dan: /* Perpendiculara unei drepte care trece printr-un punct */

= Punctul =
== Reprezentare în memoria calculatorului ==
Vom stoca coordonatele carteziene ale punctului (ordonata - x și abscisa - y).
<syntaxhighlight>
struct Punct {
double x;
double y;
};
</syntaxhighlight>

== Distanța dintre două puncte ==
Vom folosi teorema lui Pitagora și vom obține formula:
<syntaxhighlight>
double distanta(Punct p1, Punct p2) {
return sqrt((p1.x - p2.x) * (p1.x - p2.x) +
(p1.y - p2.y) * (p1.y - p2.y));
}
</syntaxhighlight>

= Dreapta =

O dreaptă este unic determinată de două puncte distincte. Pe baza coordonatelor celor două puncte putem determina ecuația dreptei.

== Ecuația dreptei ==
Ecuația dreptei este o egalitate în care apar două necunoscute (x și y) cu proprietatea că mulțimea soluțiilor perechilor de numere (x, y) coincide cu coordonatele tuturor punctelor de pe dreaptă.

== Ecuația dreptei determinată de două puncte ==

Se dau două puncte p1 și p2 de coorodonate (x1, y1) și (x2, y2). Fie (x, y) un punct de pe dreapta determinată în mod unic de punctele p1 și p2. Atunci, folosind asemănarea triunghiurilor (ca în desenul [http://flockdraw.com/gallery/view/2120564]) obținem ecuația:

<pre>
(x - x1) / (x2 - x1) = (y - y1) / (y2 - y1)

(x - x1) * (y2 - y1) = (y - y1) * (x2 - x1)

x * y2 - x * y1 - x1 * y2 + x1 * y1 = y * x2 - y * x1 - y1 * x2 + y1 * x1

x * y2 - x * y1 - x1 * y2 + x1 * y1 - y * x2 + y * x1 + y1 * x2 - y1 * x1 = 0

x * (y2 - y1) + y * (x1 - x2) + y1 * x2 - x1 * y2 = 0
</pre>

Introducând substituțiile:
<pre>
a = y2 - y1
b = x1 - x2
c = y1 * x2 - x1 * y2
</pre>

ajungem la forma generală a ecuației dreptei:
<pre>
a*x + b*y + c = 0
</pre>

== Reprezentarea în memoria calculatorului ==
Vom stoca o dreaptă prin valorile coeficienților a, b și c ale ecuației sale:
<syntaxhighlight>
struct Dreapta {
double a;
double b;
double c;
};
</syntaxhighlight>

Pe care le vom calcula astfel:

<syntaxhighlight>
Dreapta obtineDreapta(Punct p1, Punct p2) {
Dreapta d;
d.a = p2.y - p1.y;
d.b = p1.x - p2.x;
d.c = p1.y * p2.x - p1.x * p2.y;
return d;
}
</syntaxhighlight>

== Interpretarea ecuației dreptei ==
Pentru a testa dacă un punct p aparține unei drepte d, înlocuim x și y din ecuația dreptei cu coordonatele punctului p.

<syntaxhighlight>
bool egale(double a, double b) {
if (a > 0)
return (1 - 1e-8) * b <= a && a <= (1 + 1e-8) * b;
else
return (1 - 1e-8) * b >= a && a >= (1 + 1e-8) * b;
}

bool punctApartineDreptei(Dreapta d, Punct p) {
return egale(d.a * p.x + d.b * p.y + d.c, 0);
}
</syntaxhighlight>

== Semiplanele determinate de o dreaptă ==
Orice dreaptă d (cu ceficienții a, b și c) împarte planul în două semiplane. Vom distinge între ele numindu-le semiplanul pozitiv și semiplanul negativ.

Putem determina dacă un punct p (de coordonate x și y) se află în semiplanul pozitiv sau în semiplanul negativ calculând semnul expresiei:
<pre>
a*x + b*y + c
</pre>

astfel:
<syntaxhighlight>
int semiplan(Dreapta d, Punct p) {
if (egale(d.a * p.x + d.b * p.y + d.c, 0)) {
return 0;
} else if (d.a * p.x + d.b * p.y + d.c < 0) {
return -1;
} else {
return 1;
}
}
</syntaxhighlight>

== Panta unei drepte ==
Fie două puncte p1 și p2 de coordonate x1 și y1 respectiv x2 și y2 aparținând unei drepte d. Spunem că panta m dreptei d este:
<pre>
m = (y2 - y1) / (x2 - x1)
</pre>

Folosind formulele de calcul ale coeficienților a și b:
<pre>
a = y2 - y1
b = x1 - x2
</pre>
putem deduce că:
<pre>
m = -a / b
</pre>

Putem calcula panta unei drepte astfel:
<syntaxhighlight>
double panta(Dreapta d) {
return -d.a / d.b;
}
</syntaxhighlight>

== Paralelismul a două drepte ==
Două drepte d1 și d2 cu coeficieții a1, b1 și c1 respectiv a2, b2 și c2 sunt paralele dacă au aceeași pantă, adică:
<pre>
-a1 / b1 = -a2 / b2

a1 / b1 = a2 / b2

a1 * b2 = a2 * b1
</pre>

Putem verifica dacă două drepte sunt paralele astfel:
<syntaxhighlight>
bool suntParalele(Dreapta d1, Dreapta d2) {
return egale(d1.a * d2.b, d2.a * d1.b);
}
</syntaxhighlight>

== Coincidența a două drepte ==
Două drepte coincid dacă și numai dacă conțin aceleași puncte. Două drepte conțin aceleași puncte dacă și numai dacă soluțiile ecuațiilor lor coincid. Soluțiile a două ecuații coincid dacă și numai dacă sunt echivalente. Două ecuații sunt echivalente dacă și numai dacă înmulțind una dintre ele cu un număr real r o obținem pe cealaltă.

Astfel, pentru a verifica dacă două drepte d1 și d2 cu coeficienții a1, b1, c1 respectiv a2, b2, și c2 coincid este suficient să verificăm dacă:
<pre>
a1 / a2 = b1 / b2 = c1 / c2
</pre>
Mai mult, dacă cele două ecuații sunt în formă canonică atunci:
<pre>
a1 / a2 = b1 / b2 = c1 / c2 = 1 sau -1
</pre>
iar semnul raportului dă "sensul" dreptei, care determină semnele semiplanelor.

Putem verifica dacă două drepte coincid astfel:
<syntaxhighlight>
bool coincid(Dreapta d1, Dreapta d2) {
return egale(d1.a * d2.b, d1.b * d2.a) &&
egale(d1.a * d2.c, d1.c * d2.a);
}
</syntaxhighlight>

== Forma canonică a ecuației dreptei ==
Ecuația unei drepte d poate fi înmulțită cu orice număr real r diferit de 0 și astfel obținem o altă ecuație cu aceeași mulțime a soluțiilor. Altfel spus, înmulțind coeficienții ecuației dreptei (a, b și c) cu același număr real r obținem coeficienții unei ecuații ce desemnează aceeași dreaptă d.

De aceea, dacă pentru coeficienții a, b și c ai unei drepte d alegem r astfel:
<pre>
r = 1 / sqrt(a * a + b * b)
</pre>
și îi înmulțim prin r, aceștia vor respecta condiția suplimentară:
<pre>
a * a + b * b = 1
</pre>

Putem aduce o dreaptă la forma sa canonică astfel:
<syntaxhighlight>
struct DreaptaCanonica : public Dreapta {};

DreaptaCanonica obtineFormaCanonica(Dreapta d) {
double r = 1 / sqrt(d.a * d.a + d.b * d.b);
DreaptaCanonica dPrim;
dPrim.a = d.a * r;
dPrim.b = d.b * r;
dPrim.c = d.c * r;
return dPrim;
}
</syntaxhighlight>

== Distanța de la un punct la o dreaptă ==
Fie d o dreaptă cu coeficienții ecuației în '''formă canonică''' a, b și c și p un punct de coordonate x și y.

Distanța de la punctul p la dreapta d este dată de formula:
<pre>
|a*x + b*y + c|
</pre>

Putem calcula distanța de la un punct la o dreaptă astfel:
<syntaxhighlight>
double distanta(DreaptaCanonica d, Punct p) {
return fabs(d.a * p.x + d.b * p.y + d.c);
}
</syntaxhighlight>

== Paralela unei drepte care trece printr-un punct ==
Fie d o dreaptă cu coeficienții ecuației a, b și c și p un punct de coordonate x și y.

Dreapta d' paralelă cu d care trece prin punctul p are coeficienții:
<pre>
a' = a
b' = b
c' = - a*x - b*y
</pre>

Putem calcula dreapta d' astfel:
<syntaxhighlight>
Dreapta paralelaPrin(Dreapta d, Punct p) {
d.c = -d.a * p.x - d.b * p.y;
return d;
}
</syntaxhighlight>

== Perpendicularitatea a două drepte ==
Fie d1 și d2 două drepte cu coeficienții a1, b1, c1 și a2, b2 și c3. Spunem că d1 și d2 sunt perpendiculare dacă și numai dacă:

<pre>
m1 * m2 = -1

-a1 / b1 * -a2 / b2 = -1

a1 / b1 * a2 / b2 = -1

a1 / b1 = -b2 / a2

a1 * a2 = -b1 * b2
</pre>

Putem calcula dacă două drepte d1 și d2 sunt paralele astfel:
<syntaxhighlight>
bool suntPerpendiculare(Dreapta d1, Dreapta d2) {
return egale(d1.a * d2.a, -d1.b * d2.b);
}
</syntaxhighlight>

== Perpendiculara unei drepte care trece printr-un punct ==
Fie d o dreaptă cu coeficienții ecuației a, b și c și p un punct de coordonate x și y.

Dreapta d' perpendiculară pe d care trece prin punctul p are coeficienții:
<pre>
a' = -b
b' = a
c' = -a'*x - b'*y
</pre>

Deoarece perpendicularitatea este satisfăcută de primele două relații:
<pre>
a' = -b
b' = a

a' = -b
a = b'
------ (*)
a * a' = -b * b'
</pre>

Iar a teria relație garantează că punctul p aparține dreptei d':
<pre>
c' = -a'*x - b'*y

a'*x + b'*y + c' = 0
</pre>

Putem calcula dreapta d' astfel:
<syntaxhighlight>
Dreapta perpendicularaPrin(Dreapta d, Punct p) {
Dreapta dPrim;
dPrim.a = -d.b;
dPrim.b = d.a;
dPrim.c = -dPrim.a * p.x - dPrim.b * p.y;
return dPrim;
}
</syntaxhighlight>

== Intersecția a două drepte ==
Fie d1 și d2 două drepte cu coeficienții a1, b1, c1 și a2, b2 și c3. Spunem că d1 și d2 nu se intersecteză dacă sunt paralele. Spunem că d1 și d2 se intersectează într-o infinitate de puncte dacă coincid. Spunem că d1 și d2 se intersectează într-un singur punct p de coorodonate x și y. Perechea de valori x și y reprezintă soluția sistemului liniar determinat cu două ecuații și două necunoscute:
<pre>
a1*x + b1*y + c1 = 0 | * b2
a2*x + b2*y + c2 = 0 | * b1

b2*a1*x + b2*b1*y + b2*c1 = 0
b1*a2*x + b1*b2*y + b1*c2 = 0
-----------------------------(-)
(b2*a1 - b1*a2)*x + (b2*c1 - b1*c2) = 0

x = -(b2*c1 - b1*c2) / (b2*a1 - b1*a2)
x = (b1*c2 - b2*c1) / (b2*a1 - b1*a2)

Similar:
a1*x + b1*y + c1 = 0 | * a2
a2*x + b2*y + c2 = 0 | * a1

a2*a1*x + a2*b1*y + a2*c1 = 0
a1*a2*x + a1*b2*y + a1*c2 = 0
-----------------------------(-)
(a2*b1 - a1*b2)*y + (a2*c1 - a1*c2) = 0

y = -(a2*c1 - a1*c2) / (a2*b1 - a1*b2)
y = (a2*c1 - a1*c2) / (b2*a1 - b1*a2)
</pre>

Putem calcula punctul p astfel:
<syntaxhighlight>
Punct intersectia(Dreapta d1, Dreapta d2) {
Punct p;
p.x = (d1.b * d2.c - d2.b * d1.c) / (d2.b * d1.a - d1.b * d2.a);
p.y = (d2.a * d1.c - d1.a * d2.c) / (d2.b * d1.a - d1.b * d2.a);
return p;
}
</syntaxhighlight>

= Testare =
Pentru a testa codul de mai sus am scris următoarea funcție main():
<syntaxhighlight>
int main(void) {
Punct p11 = {1, 1}, p12 = {1, 2}, p13 = {1, 3};
Punct p21 = {2, 1}, p22 = {2, 2}, p23 = {2, 3};
Punct p31 = {3, 1}, p32 = {3, 2}, p33 = {3, 3};
assert(egale(distanta(p11, p22), sqrt(2)));
Dreapta d1 = obtineDreapta(p11, p22);
assert(punctApartineDreptei(d1, p33));
assert(!punctApartineDreptei(d1, p23));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
assert(semiplan(d1, p23) == -semiplan(d1, p32));
DreaptaCanonica d1prim = obtineFormaCanonica(d1);
assert(egale(d1prim.a * d1prim.a + d1prim.b * d1prim.b, 1));
assert(coincid(d1, d1prim));
Dreapta d2 = obtineDreapta(p21, p32);
assert(suntParalele(d1, d2));
Dreapta d3 = obtineDreapta(p11, p31);
assert(!suntParalele(d1, d3));
assert(egale(distanta(d1prim, p21), sqrt(2) / 2));
Dreapta d4 = paralelaPrin(d1, p21);
assert(punctApartineDreptei(d4, p32));
assert(!punctApartineDreptei(d4, p33));
Dreapta d5 = obtineDreapta(p12, p21);
assert(suntPerpendiculare(d1, d5));
assert(!suntPerpendiculare(d1, d2));
Dreapta d6 = perpendicularaPrin(d1, p21);
assert(punctApartineDreptei(d6, p12));
assert(!punctApartineDreptei(d6, p22));
assert(!punctApartineDreptei(d6, p13));
Punct pi = intersectia(d1, d6);
assert(egale(pi.x, 1.5));
assert(egale(pi.y, 1.5));

return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1020 1020 - Rope (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1572 1572 - Yekaterinozavodsk Great Well (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1640 1640 - Circle of Winter (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1207 1207 - Median on the Plane (Timus)].

Cercul de informatică, liceul Tudor Vianu, clasa XI/XII, anul 2015-2016

2015-12-22T12:08:15Z

Dan:

== Note de curs ==

* [[Clasele 11-12 lecția 1 - 18 sep 2015]] -- Introducere în geometrie computațională
* [[Clasele 11-12 lecția 2 - 25 sep 2015]] -- Radixsort, bubblesort / Programare dinamică pe submulțimi
* [[Clasele 11-12 lecția 3 - 2 oct 2015]] -- Teoria jocurilor / Programare dinamică pe stări exponențiale
* [[Clasele 11-12 lecția 4 - 23 oct 2015]] -- Aho-Corasick
* [[Clasele 11-12 lecția 5 - 30 oct 2015]] -- Arbori binari de cautare; Heapuri
* [[Clasele 11-12 lecția 6 - 6 nov 2015]] -- Treapuri; Persistență
* [[Clasele 11-12 lecția 7 - 13 nov 2015]] -- Arbori binari echilibrați augmentați
* [[Clasele 11-12 lecția 8 - 27 nov 2015]] -- Rezolvare probleme baraj Schumen
* [[Clasele 11-12 lecția 9 - 4 dec 2015]] -- Flux maxim si cuplaj maxim (de cost minim)
* [[Clasele 11-12 lecția 10 - 11 dec 2015]] -- Flux maxim: Push-Relabel
* [[Clasele 11-12 lecția 10 - 15 ian 2016]] -- ...

== Altele ==

* [http://varena.ro/teme-2015-2016-clasele-11-12 Clasamentul temelor]

Cercul de informatică, liceul Tudor Vianu, clasa IX/X, anul 2015-2016

2015-12-22T12:06:45Z

Dan:

== Note de curs ==

* [[Clasele 9-10 lecția 1 - 18 sep 2015]] -- Analiză amortizată
* [[Clasele 9-10 lecția 2 - 25 sep 2015]] -- Stivă, coadă, Deque / Programare dinamică
* [[Clasele 9-10 lecția 3 - 2 oct 2015]] -- Evaluare de expresii
* [[Clasele 9-10 lecția 4 - 23 oct 2015]] -- Alocare dinamica; Trie
* [[Clasele 9-10 lecția 5 - 30 oct 2015]] -- Calcule modulo, Clase
* [[Clasele 9-10 lecția 6 - 6 nov 2015]] -- Calcule modulo; Hashuri
* [[Clasele 9-10 lecția 7 - 13 nov 2015]] -- Lee și BFS
* [[Clasele 9-10 lecția 8 - 20 nov 2015]] -- Rezolvare probleme baraj Schumen
* [[Clasele 9-10 lecția 9 - 27 nov 2015]] -- Union-Find
* [[Clasele 9-10 lecția 10 - 4 dec 2015]] -- Drum minim in graf
* [[Clasele 9-10 lecția 11 - 11 dec 2015]] -- Automate finite și KMP
* [[Clasele 9-10 lecția 11 - 18 dec 2015]] -- Diverse probleme
* [[Clasele 9-10 lecția 11 - 15 ian 2016]] -- ...

== Altele ==

* [http://varena.ro/teme-2015-2016-clasele-9-10 Clasamentul temelor]

Cercul de informatică, liceul Tudor Vianu, clasa a VIII-a, anul 2015-2016

2015-12-22T12:04:03Z

Dan:

== Clasamente ==

* [http://varena.ro/teme-2015-2016-clasa-8 Clasamentul temelor]

== Componenţa cercului de informatică ==

* [[Componența cercului clasa a 8-a, anul 2015-2016]]

== Note de curs ==

* [[Clasa a 8-a lecția 1 - 23 sep 2015]] -- Recapitulare a cunoștințelor teoretice învățate în primul semestru din anul trecut
* [[Clasa a 8-a lecția 2 - 30 sep 2015]] -- Permutări, Aranjamente, Combinări / Programare Dinamică
* [[Clasa a 8-a lecția 3 - 7 oct 2015]] -- Subprobleme suprapuse
* [[Clasa a 8-a lecția 4 - 14 oct 2015]] -- Subprobleme suprapuse
* [[Clasa a 8-a lecția 5 - 21 oct 2015]] -- Subprobleme suprapuse
* [[Clasa a 8-a lecția 6 - 28 oct 2015]] -- Geometrie analitică (puncte și drepte)
* [[Clasa a 8-a lecția 7 - 4 nov 2015]] -- Geometrie analitică (triunghiuri, poligoane și înfășurătoare convexă)
* [[Clasa a 8-a lecția 8 - 11 nov 2015]] -- Geometrie analitică (coordonate polare și unghiuri)
* [[Clasa a 8-a lecția 9 - 18 nov 2015]] -- Introducere în grafuri
* [[Clasa a 8-a lecția 10 - 25 nov 2015]] -- Rezolvare probleme baraj Schumen
* [[Clasa a 8-a lecția 11 - 2 dec 2015]] -- Introducere în arbori
* [[Clasa a 8-a lecția 12 - 9 dec 2015]] -- Probleme ONI 2011
* [[Clasa a 8-a lecția 13 - 16 dec 2015]] -- Drum minim în graf: Bellman-Ford
* [[Clasa a 8-a lecția 14 - 13 ian 2016]] -- ...

Clasele 9-10 lecția 3 - 2 oct 2015

2015-12-04T15:32:45Z

Dan: Created page with "= Prima oră = <syntaxhighlight> #include <cstdio> #include <cctype> // 2+2*2 // 6 // (+ (* 2 2) 2) // Expresie = Termen + Termen + Termen + ... // Termen = Factor * Facto..."

= Prima oră =

<syntaxhighlight>
#include <cstdio>
#include <cctype>

// 2+2*2
// 6

// (+ (* 2 2) 2)

// Expresie = Termen + Termen + Termen + ...
// Termen = Factor * Factor * Factor * ...
// Factor = (Expresie) | Număr

// E = T | T + T | T + T + T + ...
// T = F | F * F | F * F * F * ...
// F = (E) | Nr

// E = T + T = F + F * F = Nr + Nr * Nr = 2 + 2 * 2
/*
E
/ | \
T + T
| / | \
F F * F
| | |
Nr Nr Nr
| | |
2 2 2

Ex2: (2+3)*2

E = T = F * F = (E) * Nr = (T+T) * 2 = (F+F)*2 =
= (Nr+Nr)*2 = (2+3)*2

= 2/2/2 = (2/2)/2 st->dr
= 2/(2/2) dr->st

*/

int E(char* &sir);
int T(char* &sir);
int F(char* &sir);
int Nr(char* &sir, int raspuns = 0);

//2+2*2
//2
//2+2
//2+2+2+2+2+2
//(2+2)*2+2
int E(char* &sir) { // variabia sir = adresa primului
// caracter din sirul care se va evalua (si care
// se poate deriva dintr-un E
//printf("%c", sir[0]);
int raspuns = T(sir);
// avansam pana la sf. primului termen
while (sir[0] == '+') {
sir++;
raspuns += T(sir);
}
return raspuns;
}

int T(char* &sir) {
int raspuns = F(sir);
// avansam pana la sf. primului termen
while (sir[0] == '*') {
sir++;
raspuns *= F(sir);
}
return raspuns;
}
// E = T | T + T | T + T + T + ...
// T = F | F * F | F * F * F * ...
// F = (E) | Nr
//(

int F(char* &sir) {
int raspuns;
if (sir[0] == '(') {
sir++; // '('
raspuns = E(sir);
sir++; // ')'
} else if (isdigit(sir[0])) {
raspuns = Nr(sir);
} else {
throw sir;
}
return raspuns;
}

//2345
//2
/*
int Nr(char* &sir) {
int raspuns = 0;
while (isdigit(sir[0])) {
raspuns *= 10;
raspuns += sir[0] - '0';
sir++;
}
return raspuns;
}//*/

int Nr(char* &sir, int raspuns) {
if (isdigit(sir[0])) {
int cifra = sir[0] - '0';
sir++;
return Nr(sir, raspuns * 10 + cifra);
} else {
return raspuns;
}
}

int main(void) {
const int MAX_SIZE = 100;
char sir[MAX_SIZE + 1];

// citirea datelor
fgets(sir, MAX_SIZE, stdin);

// calcularea solutiei
try {
char* s = sir;
int raspuns = E(s);
if (*s != '\n') {
throw s;
}
// afisarea solutiei
printf("%d\n", raspuns);
} catch (char* sir) {
fprintf(stderr, "Am o eroare aici: %s\n", sir);
}
return 0;
}
</syntaxhighlight>

= A doua oră =

În a doua oră am discutat pe scurt idei de rezolvare pentru problema [http://acm.timus.ru/problem.aspx?space=1&num=1220 1220 - Stacks (Timus)] dată ca temă data trecută.

Soluția propusă de mine a fost să simulăm o listă simplu înlănțuită de întregi cu ajutorul a doi vectori: unul de unsigned int (pentru stocarea valorilor) și unul de unsigned short int (pentru stocarea indicilor elementelor aterioare din stive).

<syntaxhighlight>
unsigned int valoare[100001];
unsigned short int anterior[100001];

unsigned short int inceputStiva[1001];
</syntaxhighlight>

Singura problemă cu această abordare este că indicii stocați în vectorul anterior au nevoie de 17 biți pentru a fi stocați (cu unul mai mult decât permite tipul de date unsigned short int). Soluția se bazează pe observația că valorile stocate în vectorul valoare nu folosesc decât 30 de biți din cei 32 disponibili, astfel că putem folosi unul dintre cei doi rămași pentru a stoca complet indicele elementului anterior din stivă.

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 4 probleme:
* [http://www.infoarena.ro/problema/bool Bool (Infoarena)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1186 1186 - Chemical Reactions (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1223 1223 - Chernobyl’ Eagle on a Roof (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1495 1495 - One-two, One-two 2 (Timus)].

Clasa a 7-a lecția 13 - 03 dec 2015

2015-12-03T13:41:26Z

Dan: /* Deque */

= Tema - rezolvări =

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_11_-_2_dec_2014]

= Lecție =
== Despre structura de date coadă ==
* Ideea de ''tip de date abstract'': un tip de date abstract este un ''model matematic'', ca și automatele. Acest model definește operații asupra tipului de date, precum și restricții asupra efectului acestor operații.Tipurile de date abstracte sînt utile în simplificarea algoritmilor, deaorece descompun problema în subprobleme mai mici, cunoscute și studiate.
* Exemplu: tipul de date abstract ''coadă'', care definește operațiile ''enqueue'', care adaugă un element la coadă, și ''dequeue'', care scoate un element din coadă. Restricțiile sînt asupra ordinii de returnare a elementelor și anume ele trebuie returnate după regula "primul venit primul plecat". De aceea se spune că o coadă este o structură de tip ''FIFO'' (first in, first out). Definim, de asemenea doua operații utile: ''empty'' (coadă goală) și ''full'' (coadă plină). [[Image:coada.gif|frame|none|Coada ca tip abstract de date]]
* Tipurile de date abstracte separă funcționalitatea de implementare. În cazul cozii există mai multe implementări posibile. Noi vom studia una dintre cele mai folosite.
* Implementarea cu vectori circulari
** Folosește un vector pentru a păstra elementele și doi indici, primul și ultimul care memorează poziția primului, respectiv ultimului element din coadă. Pentru a nu deplasa elemente atunci cînd scoatem un element din coadă vom incrementa doar poziția primului element. Atunci cînd adăugăm un element în coadă incrementăm poziția ultimului element.
** Pentru a refolosi golurile rămase în urmă la scoaterea din coadă și a nu deplasa cei doi indici la infinit vom defini o mărime maximă a cozii, n. Atunci cînd unul din indici depășește această mărime el revine la zero. Logic vorbind după ultimul element din vector urmează din nou primul. De aceea spunem că vectorul este circular. Formula de actualizare a indicilor devine <tt>primul = (primul + 1) % n</tt> și <tt>ultimul = (ultimul + 1) % n</tt>, unde n este numărul maxim de elemente din coadă. [[Image:coada-vector-circular.gif|frame|none|Implementare coadă cu vector circular]]
** Observăm că primul este poziția primului element din coadă, iar ultimul este poziția primului element liber din vector.
** Coadă goală. Cum răspundem la întrebarea "este coada goală"? Se observă că acest lucru se întimplă cînd primul == ultimul.
** Coada plină. Cum răspundem la întrebarea "este coada plină"? Observăm că aceasta se întîmplă tot atunci cînd <tt>primul == ultimul</tt>. Pentru a diferenția între aceste două cazuri vom "sacrifica" un element din vector, folosind numai n-1 poziții. În felul acesta testul de coadă plină va fi <tt>(ultimul + 1) % n = primul</tt>.
* În această implementare cele patru operații au complexitate O(1).
* Unul din avantajele acestei implementări, de care veți auzi în detaliu în facultate este că scoaterea de elemente se poate face în paralel cu adăugarea, de exemplu în cazul cînd un proces generează elementele de adăugat și un alt proces, independent, colectează elementele spre procesare.

== Deque ==

<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h> // pentru malloc
#include <assert.h>

int SIZE = 4;

int *coada;
int inceput, sfarsit;

void init(int size) {
// malloc returneaza void* si trebuie conversie la int*
coada = (int*)malloc(sizeof(int) * size);
}

int size() {
return sfarsit - inceput;
}

void resize(int newSize) {
int* copie = coada;
init(newSize);
// for(int k = 0; k < SIZE; k++) {
// coada[k] = copie[(inceput + k) % SIZE];
// }
// inceput = 0;
// sfarsit = SIZE;
for (int k = inceput; k < sfarsit; k++) {
coada[k % newSize] = copie[k % SIZE];
}
SIZE = newSize;
free(copie);
}

void push_back(int value) {
if (size() == SIZE) {
resize(SIZE * 2);
}
coada[sfarsit % SIZE] = value;
sfarsit++;
}

void pop_back() {
if (SIZE > 4 && size() * 4 == SIZE) {
resize(SIZE / 2);
}
sfarsit--;
}

int front() {
return coada[inceput % SIZE];
}

int back() {
return coada[(sfarsit - 1) % SIZE];
}

void pop_front() {
if (SIZE > 4 && size() * 4 == SIZE) {
resize(SIZE / 2);
}
inceput++;
}

int isEmpty() {
return inceput == sfarsit;
}

int main() {
init(SIZE);
push_back(1);
push_back(2);
push_back(3);
assert(front() == 1); pop_front();
assert(front() == 2); pop_front();
printf("%d <= %d\n", size(), SIZE);
push_back(4);
push_back(5);
push_back(6);
push_back(7);
printf("%d <= %d\n", size(), SIZE);
assert(front() == 3); pop_front();
assert(front() == 4); pop_front();
printf("%d <= %d\n", size(), SIZE);
assert(front() == 5); pop_front();
assert(front() == 6); pop_front();
printf("%d <= %d\n", size(), SIZE);
return 0;
}
</syntaxhighlight>

== Maximum în fereastră glisantă (maximum over a sliding window) ==
* Enunț: dîndu-se un șir de ''n'' numere considerăm cele ''n – k + 1'' subsecvențe de ''k'' numere consecutive în șir (denumite și "ferestre" de lungime ''k''). Putem vedea aceste ferestre ca pe o singură fereastră, deplasabilă, care ne dă acces la ''k'' elemente din vector odată. Se cere ca pentru fiecare fereastră să se găsească maximul.
* Algoritmul de rezolvare trivial (forță brută) recalculează maximul pentru fiecare din ferestre, avînd complexitate ''O(kn)''.
* Pentru a reduce complexitatea găsirii maximului procedăm astfel: luăm prima fereastră, de la ''0'' la ''k-1''. Să spunem că maximul se află pe poziția ''p1''. Pe măsură ce vom deplasa fereastra este imposibil ca elementele din-naintea maximului să fie vreodată maximul ferestrei, deoarece ele vor face parte împreună cu maximul din această fereastră. Să considerăm poziția celui mai mare element după maxim și la dreapta lui, în fereastră. Fie ea ''p2''. Rezultă că nici un element pe pozițiile intermediare ''i'', ''p1 2'', nu poate fi vreodată maxim în fereastră, deoarece aceste elemente vor fi împreună cu ''p2'' în toate ferestrele care le conțin. Similar, considerînd ''p3'' poziția următorului maxim, nici un element între ''p2'' și ''p3'' nu va putea fi maxim. Astfel apare următorul algoritm:
** Memorăm toate maximele descrescătoare din prima fereastră, într-o coadă. Primul element din coadă este maximul ferestrei.
** Cînd deplasăm fereastra trebuie să actualizăm structura de maxime din coadă. Pentru aceasta dăm atenție elementului care dispare din fereastră și celui care intră în fereastră.
** Dacă elementul care iese nu este maximul curent, nu avem nimic de făcut.
** Dacă este maximul curent vom scoate primul element din coada de maxime.
** Dacă elementul proaspăt adăugat în fereastră este mai mic decît ultimul maxim din coadă se adaugă la coadă. În caz contrar el va "arunca" ultimul element, iar și încercăm din nou adăugarea în coadă.
** Rezultă că noul element din fereastră "aruncă" toate elementele de la urma cozii strict mai mici ca el, iar apoi îl adăugăm normal la coadă. [[Image:maximum-fereastra-glisanta.gif|frame|none|În figură noul maxim va elimina din coadă maximele 2 și 3. Coada rămasă va conține maximul 1 și maximul nou]]
* La prima vedere pare că acest algoritm are complexitate ''O(kn)''. Folosind analiza amortizată putem calcula complexitatea reală ca fiind ''O(n)''.
* Memoria suplimentară folosită este mărimea maximă a cozii, adică ''O(k)''.
* Observăm că putem folosi acest algoritm la problema [http://varena.ro/problema/cuburi cuburi]. Genul acesta de prelucrare, eliminarea unor cifre ale unui număr astfel încît numărul rămas să fie maxim (sau minim) apare des la olimpiade.
* La temă aveţi şi problema [http://varena.ro/problema/maxim maxim], o problemă de clasa a 5a la origine, adaptată pentru clasa a 8a şi analiză amortizată. Pentru cei cărora le plac provocările, încercaţi să rezolvaţi problema cu memorie ''O(1)''.

= Temă =
[http://varena.ro/runda/2014-12-09-clasa-7-tema-12 Tema 12 clasa a 7a]
* [http://varena.ro/problema/cuburi cuburi] dată la ONI 2012 clasa a 8a
* [http://varena.ro/problema/maxim maxim] dată la ONI 2007 clasa a 5a

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_12_-_9_dec_2014]

Clasa a 7-a lecția 11 - 26 nov 2015

2015-12-03T09:30:33Z

Dan:

= Temă Rezolvari =

[http://varena.ro/runda/2015-11-19-clasa-7-tema-10 Tema 10 clasa a 7a]

= Tema =
* [http://varena.ro/problema/el el]
* [http://varena.ro/problema/becuri becuri]
* [http://varena.ro/problema/cript cript]

Clasa a 8-a lecția 9 - 18 nov 2015

2015-11-19T12:35:56Z

Dan: Created page with "= Temă = Pentru data viitoare veți avea de rezolvat următoarea problemă: * [http://acm.timus.ru/problem.aspx?space=1&num=1325 1325 - Dirt (Timus)]."

= Temă =
Pentru data viitoare veți avea de rezolvat următoarea problemă:
* [http://acm.timus.ru/problem.aspx?space=1&num=1325 1325 - Dirt (Timus)].

Clasele 9-10 lecția 7 - 13 nov 2015

2015-11-13T18:15:24Z

Dan: /* Temă */

= 1033 - Labyrinth =
<syntaxhighlight>
#include <cstdio>
#include <queue>

using std::queue;

const int MAX_N = 33;

int N;
char harta[1 + MAX_N + 1][1 + MAX_N + 1];
// . - spațiu liber
// # - zid
// ! - spațiu liber parcurs (accesibil)

struct Casuta {
int l;
int c;

Casuta add(const Casuta &alta) const {
Casuta rezultat;
rezultat.l = this->l + alta.l;
rezultat.c = this->c + alta.c;
return rezultat;
}
};

Casuta vecini[] = {
{-1, 0},
{ 0, 1},
{ 1, 0},
{ 0,-1},
};

queue<Casuta> coadaBfs;

int raspuns;

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

// citirea datelor
scanf("%d", &N);
for (i = 1; i <= N; ++i) {
scanf("\n");
for (j = 1; j <= N; ++j) {
scanf("%c", &harta[i][j]);
}
}
for (i = 0; i <= N + 1; i++) {
harta[0][i] = '#';
harta[N + 1][i] = '#';
harta[i][0] = '#';
harta[i][N + 1] = '#';
}

coadaBfs.push({1, 1});
coadaBfs.push({N, N});
harta[1][1] = '!';
harta[N][N] = '!';
while (!coadaBfs.empty()) {
Casuta nod = coadaBfs.front();
coadaBfs.pop();
for (i = 0; i < 4; ++i) {
Casuta vecin;
vecin = nod.add(vecini[i]);
if (harta[vecin.l][vecin.c] == '.') {
harta[vecin.l][vecin.c] = '!';
coadaBfs.push(vecin);
}
}
}

raspuns = 0;
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
if (harta[i][j] == '!') {
Casuta nod = {i, j};
for (k = 0; k < 4; ++k) {
Casuta vecin = nod.add(vecini[k]);
if (harta[vecin.l][vecin.c] == '#') {
raspuns++;
}
}
}
}
}
raspuns -= 4; // scădem pereții intrărilor
raspuns *= 9; // înmulțim cu aria unui perete

printf("%d\n", raspuns);
return 0;
}
</syntaxhighlight>

= 1709 - Penguin-Avia =
<syntaxhighlight>
#include <cstdio>
#include <queue>

using std::queue;

const int MAX_N = 100;

int N;
int D, A;

char adiacenta[MAX_N][MAX_N];

queue<int> coadaBfs;
bool vizitat[MAX_N];

long long raspuns;

int main(void) {
int i, j;

// citirea datelor
scanf("%d", &N);
scanf("%d %d", &D, &A);
for (i = 0; i < N; ++i) {
scanf("\n");
for (j = 0; j < N; ++j) {
scanf("%c", &adiacenta[i][j]);
}
}

for (i = 0; i < N; i++) {
if (!vizitat[i]) {
if (i != 0) {
adiacenta[0][i] = 'a';
adiacenta[i][0] = 'a';
raspuns += A;
}
coadaBfs.push(i);
vizitat[i] = true;
while (!coadaBfs.empty()) {
int nod = coadaBfs.front();
coadaBfs.pop();
int vecin;
for (vecin = 0; vecin < N; vecin++) {
if (adiacenta[nod][vecin] == '1') {
if (!vizitat[vecin]) {
adiacenta[nod][vecin] = '0';
adiacenta[vecin][nod] = '0';
vizitat[vecin] = true;
coadaBfs.push(vecin);
} else {
adiacenta[nod][vecin] = 'd';
adiacenta[vecin][nod] = 'd';
raspuns += D;
}
}
}
}
}
}
printf("%lld\n", raspuns);
for (i = 0; i < N; ++i) {
for (j = 0; j < N; ++j) {
printf("%c", adiacenta[i][j]);
}
printf("\n");
}
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 5 probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1033 1033 - Labyrinth (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1709 1709 - Penguin-Avia (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1242 1242 - Werewolf (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1218 1218 - Episode N-th: The Jedi Tournament (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1080 1080 - Map Coloring (Timus)].

Clasele 11-12 lecția 7 - 13 nov 2015

2015-11-13T18:15:22Z

Dan: /* Temă */

= Arbori binari echilibrați augmentați =
<syntaxhighlight>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using std::pair;

class Treap {
public:
int value;
int priority; // Max-Heap
int size;
bool reversed;
Treap* left;
Treap* right;
};

Treap* duplicate(const Treap* node) {
Treap* answer = new Treap;
answer->value = node->value;
answer->priority = node->priority;
answer->size = node->size;
answer->reversed = node->reversed;
answer->left = node->left;
answer->right = node->right;
return answer;
}

Treap* propagate(Treap* node) {
Treap* newNode;
if (node != NULL && node->reversed) {
newNode = duplicate(node);
newNode->reversed = false;
if (node->left != NULL) {
newNode->right = duplicate(node->left);
newNode->right->reversed ^= 1;
} else {
newNode->right = NULL;
}
if (node->right != NULL) {
newNode->left = duplicate(node->right);
newNode->left->reversed ^= 1;
} else {
newNode->left = NULL;
}
} else {
newNode = node;
}
return newNode;
}

Treap* reverse(Treap* node) {
if (node == NULL) {
return NULL;
} else {
Treap* newNode = duplicate(node);
newNode->reversed ^= 1;
return newNode;
}
}

int getSize(Treap* node) {
if (node == NULL) {
return 0;
} else {
return node->size;
}
}

Treap* updateSize(Treap* node) {
if (node != NULL)
node->size =
getSize(node->left) + 1 + getSize(node->right);
return node;
}

Treap* find(Treap* node, int index) {
node = propagate(node);
if (node == NULL || node->size <= index) {
return NULL;
}
if (index < getSize(node->left)) {
return find(node->left, index);
} else if (index == getSize(node->left)) {
return node;
} else { // if (leftSize < index)
return find(node->right, index - getSize(node->left) - 1);
}
}

pair<Treap*, Treap*> split(Treap* node, int size1) {
node = propagate(node);
pair<Treap*, Treap*> answer;
if (node == NULL) {
answer.first = NULL;
answer.second = NULL;
} else {
assert(size1 <= node->size);

if (getSize(node->left) + 1 <= size1) {
answer.first = new Treap;
answer.first->value = node->value;
answer.first->priority = node->priority;
answer.first->reversed = false;
answer.first->left = node->left;
pair<Treap*, Treap*> splitAnswer =
split(node->right, size1 - (getSize(node->left) + 1));
answer.first->right = splitAnswer.first;
answer.second = splitAnswer.second;
} else { // size1 < leftSize + 1
answer.second = new Treap;
answer.second->value = node->value;
answer.second->priority = node->priority;
answer.second->reversed = false;
answer.second->right = node->right;
pair<Treap*, Treap*> splitAnswer =
split(node->left, size1);
answer.first = splitAnswer.first;
answer.second->left = splitAnswer.second;
}
updateSize(answer.first);
updateSize(answer.second);
}
return answer;
}

Treap* join(Treap* first, Treap* second) {
first = propagate(first);
second = propagate(second);
if (first == NULL) {
return second;
} else if (second == NULL) {
return first;
} else if (second->priority < first->priority) {
Treap* newNode = duplicate(first);
newNode->right = join(first->right, second);
updateSize(newNode);
return newNode;
} else { // if (first->priority < second->priority)
Treap* newNode = duplicate(second);
newNode->left = join(first, second->left);
updateSize(newNode);
return newNode;
}
}

int myRandom() {
return (rand() << 15) ^ rand();
}

Treap* insert(Treap* node, int index, int value, int priority = myRandom()) {
assert(index <= getSize(node));
node = propagate(node);
Treap* newNode = NULL;
if (node == NULL || node->priority < priority) {
newNode = new Treap;
pair<Treap*, Treap*> splitAnswer = split(node, index);
newNode->value = value;
newNode->priority = priority;
newNode->left = splitAnswer.first;
newNode->right = splitAnswer.second;
newNode->reversed = false;
} else if (getSize(node->left) < index) {
newNode = duplicate(node);
newNode->right = insert(node->right,
index - (getSize(node->left) + 1),
value, priority);
} else { // if (value <= node->value)
newNode = duplicate(node);
newNode->left = insert(node->left, index, value, priority);
}
updateSize(newNode);
return newNode;
}

Treap* erase(Treap* node, int index, int size) {
pair<Treap*, Treap*> aux;
aux = split(node, index);
Treap* t1 = aux.first;
aux = split(aux.second, size);
//Treap* t2 = aux.first;
Treap* t3 = aux.second;
return join(t1, t3);
}

Treap* reverse(Treap* node, int index, int size) {
pair<Treap*, Treap*> aux;
aux = split(node, index);
Treap* t1 = aux.first;
aux = split(aux.second, size);
Treap* t2 = reverse(aux.first);
Treap* t3 = aux.second;
return join(join(t1, t2), t3);
}

void dump(Treap* node, int depth = 0) {
node = propagate(node);
if (node != NULL) {
dump(node->left, depth + 1);
printf("%12d %2d ", node->priority, node->size);
for (int i = 0; i < depth; i++) {
printf(" ");
}
printf("%d\n", node->value);
dump(node->right, depth + 1);
}
}

int main(void) {
srand(time(NULL));
Treap* arb1 = NULL;
Treap* arb2 = insert(arb1, 0, 5);
Treap* arb3 = insert(arb2, 0, 3);
Treap* arb4 = insert(arb3, 1, 6);
Treap* arb5 = insert(arb4, 2, 4);
Treap* arb6 = insert(arb5, 3, 9);
Treap* arb7 = reverse(arb6);
Treap* arb8 = insert(arb7, 2, 1);
Treap* arb9 = insert(arb8, 1, 7);
Treap* arb10 = reverse(arb9, 2, 2);
Treap* arb11 = erase(arb10, 2, 2);
dump(arb1);
printf("\n");
dump(arb2);
printf("\n");
dump(arb3);
printf("\n");
dump(arb4);
printf("\n");
dump(arb5);
printf("\n");
dump(arb6);
printf("\n");
dump(arb7);
printf("\n");
dump(arb8);
printf("\n");
dump(arb9);
printf("\n");
dump(arb10);
printf("\n");
dump(arb11);
printf("\n");

return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 3 probleme:
* [http://infoarena.ro/problema/secv8 secv8 - Secv8 (Infoarena)];
* [http://infoarena.ro/problema/zeap zeap - Zeap (Infoarena)];
* [http://infoarena.ro/problema/pikachu pikachu - Pikachu (Infoarena)].

Clasele 9-10 lecția 6 - 6 nov 2015

2015-11-06T16:38:35Z

Dan: Created page with "= Hashuri = <syntaxhighlight> const int P1 = 1000000007; const int P2 = 1000000009; struct Hash { Zn<P1> rest1; Zn<P2> rest2; int size; Hash() { rest1 = 0;..."

= Hashuri =

<syntaxhighlight>
const int P1 = 1000000007;
const int P2 = 1000000009;

struct Hash {
Zn<P1> rest1;
Zn<P2> rest2;
int size;

Hash() {
rest1 = 0;
rest2 = 0;
size = 0;
}
};

const int MAX_N = 100000;
const int BASE = 253;

Zn<P1> Bases1[1 + MAX_N];
Zn<P2> Bases2[1 + MAX_N];

void init() {
int i;
Bases1[0] = 1;
Bases2[0] = 1;
for (i = 1; i <= MAX_N; i++) {
Bases1[i] = Bases1[i - 1] * Zn<P1>(BASE);
Bases2[i] = Bases2[i - 1] * Zn<P2>(BASE);
}
}

Hash append(Hash s, char l) {
s.rest1 = s.rest1 * Zn<P1>(BASE) + Zn<P1>(l);
s.rest2 = s.rest2 * Zn<P2>(BASE) + Zn<P2>(l);
s.size++;
return s;
}

Hash prepend(char l, Hash s) {
s.rest1 = Zn<P1>(l) * Bases1[s.size] + s.rest1;
s.rest2 = Zn<P2>(l) * Bases2[s.size] + s.rest2;
s.size++;
return s;
}

Hash join(Hash s1, Hash s2) {
s1.rest1 = s1.rest1 * Bases1[s2.size] + s2.rest1;
s1.rest2 = s1.rest2 * Bases2[s2.size] + s2.rest2;
s1.size += s2.size;
return s1;
}

bool equals(Hash s1, Hash s2) {
return s1.rest1 == s2.rest1 && s1.rest2 == s2.rest2 && s1.size == s2.size;
}

Hash eraseFromEnd(Hash s, char l) {
s.rest1 = (s.rest1 - Zn<P1>(l)) / Zn<P1>(BASE);
s.rest2 = (s.rest2 - Zn<P2>(l)) / Zn<P2>(BASE);
s.size--;
return s;
}

Hash eraseFromBeginning(char l, Hash s) {
s.rest1 = s.rest1 - Zn<P1>(l) * Bases1[s.size - 1];
s.rest2 = s.rest2 - Zn<P2>(l) * Bases2[s.size - 1];
s.size--;
return s;
}

void dump(Hash h) {
printf("%d %d %d\n", (int)h.rest1, (int)h.rest2, h.size);
}
</syntaxhighlight>

= 1354 - Palindrome. Again Palindrome =
<syntaxhighlight>
const int SIZE = 10000;

char sir[2 * SIZE + 1];

int main() {
init();
int i;
scanf("%s", sir);
Hash normal, invers;
int n = strlen(sir);
int sol = n;
for (i = n - 1; i >= 1; i--) {
normal = prepend(sir[i], normal);
invers = append(invers, sir[i]);
//dump(normal);
//dump(invers);
if (equals(invers, normal)) {
sol = i;
}
}
for (i = sol - 1; i >= 0; i--) {
sir[n] = sir[i];
n++;
}
sir[n] = 0;
//printf("%d\n", sol);
printf("%s\n", sir);
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 2 probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1423 1423 - String Tale (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1517 1517 - Freedom of Choice (Timus)].

Clasele 9-10 lecția 5 - 30 oct 2015

2015-11-06T16:09:37Z

Dan: /* Calcule modulo */

= Calcule modulo =

<syntaxhighlight>
template<int MOD>
class Zn {
long long value; // 0 <= value < MOD

public:
Zn(int value = 0) {
this->value = ((value % MOD) + MOD) % MOD;
}

Zn operator *(const Zn &other) const { // this * other
return (this->value * other.value) % MOD;
}

Zn operator +(const Zn &other) const { // this + other
return (this->value + other.value) % MOD;
}

Zn operator -() const { // -this
return (MOD - this->value) % MOD;
}

Zn operator -(const Zn &other) const { // this - other
return (this->value - other.value + MOD) % MOD;
}

Zn operator ^(const unsigned int exp) const { // this ^ exp
if (exp == 0) {
return Zn(1);
} else if (exp % 2 == 1) { // b impar
return (*this) * ((*this) ^ (exp - 1));
} else { // b par
Zn ab2 = (*this) ^ (exp / 2);
return ab2 * ab2;
}
}

Zn operator /(const Zn &other) const { // this / other
return (*this) * (other ^ (unsigned int)(MOD - 2));
}

operator int() const {
return this->value;
}
};
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 2 probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1354 1354 - Palindrome. Again Palindrome (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1486 1486 - Equal Squares (Timus)].

Clasele 11-12 lecția 6 - 6 nov 2015

2015-11-06T16:02:51Z

Dan: /* Treap persistent */

= Treap =
<syntaxhighlight>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using std::pair;

class Treap {
public:
int value;
int priority; // Max-Heap
Treap* left;
Treap* right;
};

Treap* find(Treap* node, int value) {
if (node == NULL || node->value == value) {
return node;
} else if (node->value < value) {
return find(node->right, value);
} else { // if (value < node->value)
return find(node->left, value);
}
}

pair<Treap*, Treap*> split(Treap* node, int value) {
pair<Treap*, Treap*> answer;
if (node == NULL) {
answer.first = NULL;
answer.second = NULL;
} else if (node->value <= value) {
answer.first = new Treap;
answer.first->value = node->value;
answer.first->priority = node->priority;
answer.first->left = node->left;
pair<Treap*, Treap*> splitAnswer = split(node->right, value);
answer.first->right = splitAnswer.first;
answer.second = splitAnswer.second;
delete node;
} else { // value < node->value
answer.second = new Treap;
answer.second->value = node->value;
answer.second->priority = node->priority;
answer.second->right = node->right;
pair<Treap*, Treap*> splitAnswer = split(node->left, value);
answer.first = splitAnswer.first;
answer.second->left = splitAnswer.second;
delete node;
}
return answer;
}

Treap* join(Treap* first, Treap* second) {
if (first == NULL) {
return second;
} else if (second == NULL) {
return first;
} else if (second->priority < first->priority) {
first->right = join(first->right, second);
return first;
} else { // if (first->priority < second->priority)
second->left = join(first, second->left);
return second;
}
}

int myRandom() {
return (rand() << 15) ^ rand();
}

Treap* insert(Treap* node, int value, int priority = myRandom()) {
if (node == NULL || node->priority < priority) {
pair<Treap*, Treap*> splitAnswer = split(node, value);
Treap* answer = new Treap;
answer->value = value;
answer->priority = priority;
answer->left = splitAnswer.first;
answer->right = splitAnswer.second;
return answer;
} else if (node->value < value) {
node->right = insert(node->right, value, priority);
return node;
} else { // if (value <= node->value)
node->left = insert(node->left, value, priority);
return node;
}
}

Treap* erase(Treap* node, int value) {
if (node == NULL) {
return NULL;
} else if (node->value == value) {
Treap* answer = join(node->left, node->right);
delete node;
return answer;
} else if (node->value < value) {
node->right = erase(node->right, value);
return node;
} else { // if (value < node->value)
node->left = erase(node->left, value);
return node;
}
}

void dump(Treap* node, int depth = 0) {
if (node != NULL) {
dump(node->left, depth + 1);
printf("%12d ", node->priority);
for (int i = 0; i < depth; i++) {
printf(" ");
}
printf("%d\n", node->value);
dump(node->right, depth + 1);
}
}

int main(void) {
srand(time(NULL));
Treap* arb = NULL;
arb = insert(arb, 5);
arb = insert(arb, 3);
arb = insert(arb, 6);
arb = insert(arb, 4);
arb = insert(arb, 9);
arb = insert(arb, 1);
arb = insert(arb, 7);
dump(arb);
printf("\n");
arb = erase(arb, 7);
dump(arb);

return 0;
}
</syntaxhighlight>

= Treap persistent =
<syntaxhighlight>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using std::pair;

class Treap {
public:
int value;
int priority; // Max-Heap
Treap* left;
Treap* right;
};

Treap* duplicate(const Treap* node) {
Treap* answer = new Treap;
answer->value = node->value;
answer->priority = node->priority;
answer->left = node->left;
answer->right = node->right;
return answer;
}

Treap* find(Treap* node, int value) {
if (node == NULL || node->value == value) {
return node;
} else if (node->value < value) {
return find(node->right, value);
} else { // if (value < node->value)
return find(node->left, value);
}
}

pair<Treap*, Treap*> split(const Treap* node, int value) {
pair<Treap*, Treap*> answer;
if (node == NULL) {
answer.first = NULL;
answer.second = NULL;
} else if (node->value <= value) {
answer.first = new Treap;
answer.first->value = node->value;
answer.first->priority = node->priority;
answer.first->left = node->left;
pair<Treap*, Treap*> splitAnswer = split(node->right, value);
answer.first->right = splitAnswer.first;
answer.second = splitAnswer.second;
} else { // value < node->value
answer.second = new Treap;
answer.second->value = node->value;
answer.second->priority = node->priority;
answer.second->right = node->right;
pair<Treap*, Treap*> splitAnswer = split(node->left, value);
answer.first = splitAnswer.first;
answer.second->left = splitAnswer.second;
}
return answer;
}

Treap* join(Treap* first, Treap* second) {
if (first == NULL) {
return second;
} else if (second == NULL) {
return first;
} else if (second->priority < first->priority) {
Treap* newNode = duplicate(first);
newNode->right = join(first->right, second);
return newNode;
} else { // if (first->priority < second->priority)
Treap* newNode = duplicate(second);
newNode->left = join(first, second->left);
return newNode;
}
}

int myRandom() {
return (rand() << 15) ^ rand();
}

Treap* insert(Treap* node, int value, int priority = myRandom()) {
if (node == NULL || node->priority < priority) {
pair<Treap*, Treap*> splitAnswer = split(node, value);
Treap* answer = new Treap;
answer->value = value;
answer->priority = priority;
answer->left = splitAnswer.first;
answer->right = splitAnswer.second;
return answer;
} else if (node->value < value) {
Treap* newNode = duplicate(node);
newNode->right = insert(node->right, value, priority);
return newNode;
} else { // if (value <= node->value)
Treap* newNode = duplicate(node);
newNode->left = insert(node->left, value, priority);
return newNode;
}
}

Treap* erase(Treap* node, int value) {
if (node == NULL) {
return NULL;
} else if (node->value == value) {
Treap* answer = join(node->left, node->right);
return answer;
} else if (node->value < value) {
Treap* newNode = duplicate(node);
newNode->right = erase(node->right, value);
return newNode;
} else { // if (value < node->value)
Treap* newNode = duplicate(node);
newNode->left = erase(node->left, value);
return newNode;
}
}

void dump(Treap* node, int depth = 0) {
if (node != NULL) {
dump(node->left, depth + 1);
printf("%12d ", node->priority);
for (int i = 0; i < depth; i++) {
printf(" ");
}
printf("%d\n", node->value);
dump(node->right, depth + 1);
}
}

int main(void) {
srand(time(NULL));
Treap* arb1 = NULL;
Treap* arb2 = insert(arb1, 5);
Treap* arb3 = insert(arb2, 3);
Treap* arb4 = insert(arb3, 6);
Treap* arb5 = insert(arb4, 4);
Treap* arb6 = insert(arb5, 9);
Treap* arb7 = insert(arb6, 1);
Treap* arb8 = insert(arb7, 7);
Treap* arb9 = erase(arb6, 4);
dump(arb1);
printf("\n");
dump(arb2);
printf("\n");
dump(arb3);
printf("\n");
dump(arb4);
printf("\n");
dump(arb5);
printf("\n");
dump(arb6);
printf("\n");
dump(arb7);
printf("\n");
dump(arb8);
printf("\n");
dump(arb9);
printf("\n");

return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarea problemă:
* [http://varena.ro/problema/ants ants - Ants (Varena)].

Clasele 9-10 lecția 1 - 18 sep 2015

2015-10-31T15:18:30Z

Dan:

= Analiză amortizată =
== Analiză amortizată ==

* analizează un algoritm care face pe o structură de date diverse operații cu diverse costuri
* încercăm să găsim o limită cât mai strânsă pentru costul mediu al unei operații
* există trei metode:

=== Analiză agregată ===

* calculează costul total al celor ''n'' operații și împarte la ''n'' pentru a afla costul mediu al unei operații

=== Metoda contabilității ===

* cere credit suplimentar pentru operațiile ieftine, încercând ca prin aceasta să plătească operațiile mai scumpe
* ne duce cu gândul la un contabil care nu dorește să dea nimic pe datorie. Imediat ce îi prezentăm un element pentru inserarea în structură, contabilul ne cere să plătim și transformările viitoare pe care le poate suferi elementul
* echivalent, metoda urmărește evoluția unui element prin structura de date, pe toată durata vieții lui

=== Metoda potențialului ===

* alegem o funcție Φ cu valori pozitive. Această funcție se numește potențial și asociază fiecărei stări a structurii de date un număr nenegativ. Fie ''CR(i)'' costul real al operației cu numărul ''i''. Atunci definim costul amortizat ca

<math>C_A(i) = C_R(i) + \Phi(i) - \Phi(i - 1)</math>

* deși poate părea magică, însumând costul total pentru operațiile 1, 2, ..., 'n', obținem:

<math>\sum_{i=1}^{n} C_A(i) = \sum_{i=1}^{n} C_R(i) + \Phi(n) - \Phi(0)</math>

* așadar, suma costurilor amortizate este o limită superioară pentru suma costurilor reale, cu condiția ca potențialul final să fie mai mare decât cel inițial
* cum alegem funcția-potențial? Aici este arta.
* empiric, dorim ca potențialul să „echilibreze” costurile amortizate, atunci când costurile reale variază asimptotic
* vrem ca operațiile ieftine să fie însoțite de o creștere (mică) de potențial, iar operațiile scumpe să fie însoțite de o cădere mare de potențial
* intuitiv, potențialul mare al structurii indică posibilitatea ca următoarea operație să fie scumpă, iar potențialul mic indică probabilitatea ca următoarele câteva operații să fie ieftine

= Temă =
Pentru data viitoare nu veți avea temă.

Clasele 11-12 lecția 5 - 30 oct 2015

2015-10-31T15:13:25Z

Dan: /* Temă */

= Arbore binar de căutare =
<syntaxhighlight>
#include <cstdio>
#include <algorithm>

using std::pair;

class BST { // Binary Search Tree
public:
int value;
BST* left;
BST* right;

};

BST* find(BST* node, int value) {
if (node == NULL || node->value == value) {
return node;
} else if (node->value < value) {
return find(node->right, value);
} else { // if (value < node->value)
return find(node->left, value);
}
}

pair<BST*, BST*> split(BST* node, int value) {
pair<BST*, BST*> answer;
if (node == NULL) {
answer.first = NULL;
answer.second = NULL;
} else if (node->value <= value) {
answer.first = new BST;
answer.first->value = node->value;
answer.first->left = node->left;
pair<BST*, BST*> splitAnswer = split(node->right, value);
answer.first->right = splitAnswer.first;
answer.second = splitAnswer.second;
delete node;
} else { // value < node->value
answer.second = new BST;
answer.second->value = node->value;
answer.second->right = node->right;
pair<BST*, BST*> splitAnswer = split(node->left, value);
answer.first = splitAnswer.first;
answer.second->left = splitAnswer.second;
delete node;
}
return answer;
}

BST* join(BST* first, BST* second) {
if (first == NULL) {
return second;
} else {
first->right = join(first->right, second);
return first;
}
}

BST* insert(BST* node, int value) {
pair<BST*, BST*> splitAnswer = split(node, value);
BST* answer = new BST;
answer->value = value;
answer->left = splitAnswer.first;
answer->right = splitAnswer.second;
return answer;
}

BST* erase(BST* node, int value) {
if (node == NULL) {
return NULL;
} else if (node->value == value) {
BST* answer = join(node->left, node->right);
delete node;
return answer;
} else if (node->value < value) {
node->right = erase(node->right, value);
return node;
} else { // if (value < node->value)
node->left = erase(node->left, value);
return node;
}
}

void dump(BST* node, int depth = 0) {
if (node != NULL) {
dump(node->left, depth + 1);
for (int i = 0; i < depth; i++) {
printf(" ");
}
printf("%d\n", node->value);
dump(node->right, depth + 1);
}
}

int main(void) {
BST* arb = NULL;
arb = insert(arb, 5);
arb = insert(arb, 3);
arb = insert(arb, 6);
arb = insert(arb, 4);
arb = insert(arb, 9);
arb = insert(arb, 1);
arb = insert(arb, 7);
//dump(arb);
//printf("\n");
arb = erase(arb, 7);
//dump(arb);

return 0;
}
</syntaxhighlight>

= Heap =
<syntaxhighlight>
class Heap {
public:
int value;
Heap* left;
Heap* right;
};

Heap* insert(Heap* node, int value) {
if (node == NULL) {
node = new Heap;
node->value = value;
node->left = NULL;
node->right = NULL;
} else if (node->value < value) {
int oldValue = node->value;
node->value = value;
if (rand() % 2 == 1) {
node->left = insert(node->left, oldValue);
} else {
node->right = insert(node->right, oldValue);
}
} else { // if (value <= node->value)
if (rand() % 2 == 1) {
node->left = insert(node->left, value);
} else {
node->right = insert(node->right, value);
}
}
return node;
}

int top(Heap* node) {
return node->value;
}

Heap* pop(Heap* node) {
if (node == NULL) {
return NULL;
} else { // if (node != NULL)
if (node->left == NULL) {
Heap* answer = node->right;
delete node;
return answer;
} else if (node->right == NULL) {
Heap* answer = node->left;
delete node;
return answer;
} else if (node->right->value < node->left->value) {
node->value = node->left->value;
node->left = pop(node->left);
return node;
} else { // if (node->left->value <= node->right->value)
node->value = node->right->value;
node->right = pop(node->right);
return node;
}
}
}

void dump(Heap* node, int depth = 0) {
if (node != NULL) {
dump(node->left, depth + 1);
for (int i = 0; i < depth; i++) {
printf(" ");
}
printf("%d\n", node->value);
dump(node->right, depth + 1);
}
}

int main() {
Heap* h = NULL;
h = insert(h, 5);
h = insert(h, 3);
h = insert(h, 6);
h = insert(h, 4);
h = insert(h, 9);
h = insert(h, 1);
h = insert(h, 7);
dump(h);
for (int i = 0; i < 7; i++) {
printf("%d ", top(h));
h = pop(h);
}
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 2 probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1513 1513 - Lemon Tale (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1495 1495 - One-two, One-two 2 (Timus)].

Clasele 11-12 lecția 4 - 23 oct 2015

2015-10-31T15:11:40Z

Dan: /* Temă */

= Aho-Corasick =

<syntaxhighlight>
#include <cstdio>
#include <queue>

const int SIGMA = 3; // {a, b, c}
const char FIRST_LETTER = 'a';

class TrieNode { // nod al trie-ului
public:
TrieNode* next[SIGMA];
//vector<pair<char, TrieNode*> > next;

int contor;
TrieNode* failLink;
TrieNode* outputLink;
int occurences;

void insert(char* word);
int query(char* word);
bool erase(char* word);
void dump(char letter, int depth);
};

void TrieNode::insert(char* word) {
if (*word == 0) {
this->contor++;
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
this->next[*word - FIRST_LETTER] = new TrieNode;
}
this->next[*word - FIRST_LETTER]->insert(word + 1);
}
}

int TrieNode::query(char* word) {
if (*word == 0) {
return this->contor;
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
return 0;
} else {
return this->next[*word - FIRST_LETTER]->query(word + 1);
}
}
}

bool TrieNode::erase(char* word) {
if (*word == 0) {
if (this->contor == 0) {
return false;
} else {
this->contor--;
return true;
}
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
return false;
} else {
bool answer = this->next[*word - FIRST_LETTER]->erase(word + 1);
if (answer) {
TrieNode* mySon = this->next[*word - FIRST_LETTER];
bool toDelete = mySon->contor == 0;
for (int i = 0; i < SIGMA; i++) {
toDelete &= mySon->next[i] == NULL;
}
if (toDelete) {
delete mySon;
this->next[*word - FIRST_LETTER] = NULL;
}
}
return answer;
}
}
}

void TrieNode::dump(char letter = '-', int depth = 0) {
for (int i = 0; i < depth; ++i) {
printf(" ");
}
printf("%c %d %p (Fail: %p, Output: %p)\n", letter, this->contor,
this, this->failLink, this->outputLink);
for (int i = 0; i < SIGMA; ++i) {
if (this->next[i] != NULL)
this->next[i]->dump(i + FIRST_LETTER, depth + 1);
}
}

class Trie {
private:
TrieNode* root;

public:
Trie() {
this->root = new TrieNode;
}

void insert(char* word) {
this->root->insert(word);
}

int query(char* word) {
return this->root->query(word);
}

bool erase(char* word) {
return this->root->erase(word);
}

void ahoPreprocessing() {
std::queue<TrieNode*> bfsQueue;
this->root->failLink = this->root;
this->root->outputLink = this->root;
for (int i = 0; i < SIGMA; i++) { // primul nivel
if (this->root->next[i] != NULL) {
this->root->next[i]->failLink = this->root;
this->root->next[i]->outputLink = this->root;
bfsQueue.push(this->root->next[i]);
}
}

while (!bfsQueue.empty()) {
TrieNode* node = bfsQueue.front();
bfsQueue.pop();
for (int i = 0; i < SIGMA; i++) {
if (node->next[i] != NULL) {
TrieNode* son = node->next[i];
TrieNode* tmp = node->failLink;
while (tmp->next[i] == NULL && tmp != this->root) {
tmp = tmp->failLink;
}
if (tmp->next[i] != NULL) {
son->failLink = tmp->next[i];
} else {
son->failLink = tmp; // this->root
}
if (son->failLink->contor > 0) {
son->outputLink = son->failLink;
} else {
son->outputLink = son->failLink->outputLink;
}

bfsQueue.push(son);
}
}

}
}

void dump() {
this->root->dump();
}

void findInPattern(char* word) {
TrieNode* currentNode = this->root;

while (*word != 0) {
while (currentNode->next[*word - FIRST_LETTER] == NULL
&& currentNode != this->root) {
currentNode = currentNode->failLink;
}
if (currentNode->next[*word - FIRST_LETTER] != NULL) {
currentNode = currentNode->next[*word - FIRST_LETTER];
} // else currentNode == this->root
word++;

//printf("%s == %p\n", word, currentNode);

currentNode->occurences++;
/*
if (currentNode->contor > 0) {
// aparitia cuvantului;
printf("%p == %s\n", currentNode, word);
}
TrieNode* outputNode = currentNode->outputLink;
while (outputNode != this->root) {
// aparitia cuvantului;
printf("%p == %s\n", outputNode, word);
outputNode = outputNode->outputLink;
}//*/
}
}
};

int main(void) {
Trie T;
T.insert("abc");
T.insert("bac");
T.insert("ab");
T.insert("acc");
T.insert("bcc");
T.insert("b");
T.ahoPreprocessing();
T.dump();
T.findInPattern("abccbacc");

//abccbacc
//O(N * SIGMA)
//O(N)
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 4 probleme:
* [http://www.infoarena.ro/problema/ahocorasick ahocorasick (Infoarena)];
* [http://www.infoarena.ro/problema/virus virus (Infoarena)];
* [http://varena.ro/problema/petrecere petrecere (Varena)];
* [http://varena.ro/problema/reducere reducere (Varena)].

Clasele 11-12 lecția 1 - 18 sep 2015

2015-10-31T15:00:19Z

Dan: Created page with "= Punctul = == Reprezentare în memoria calculatorului == Vom stoca coordonatele carteziene ale punctului (ordonata - x și abscisa - y). <syntaxhighlight> struct Punct { do..."

= Punctul =
== Reprezentare în memoria calculatorului ==
Vom stoca coordonatele carteziene ale punctului (ordonata - x și abscisa - y).
<syntaxhighlight>
struct Punct {
double x;
double y;
};
</syntaxhighlight>

== Distanța dintre două puncte ==
Vom folosi teorema lui Pitagora și vom obține formula:
<syntaxhighlight>
double distanta(Punct p1, Punct p2) {
return sqrt((p1.x - p2.x) * (p1.x - p2.x) +
(p1.y - p2.y) * (p1.y - p2.y));
}
</syntaxhighlight>

= Dreapta =

O dreaptă este unic determinată de două ouncte distincte. Pe baza coordonatelor celor două puncte putem determina ecuația dreptei.

== Ecuația dreptei ==
Ecuația dreptei este o egalitate în care apar două necunoscute (x și y) cu proprietatea că mulțimea soluțiilor perechilor de numere (x, y) coincide cu coordonatele tuturor punctelor de pe dreaptă.

== Ecuația dreptei determinată de două puncte ==

Se dau două puncte p1 și p2 de coorodonate (x1, y1) și (x2, y2). Fie (x, y) un punct de pe dreapta determinată în mod unic de punctele p1 și p2. Atunci, folosind asemănarea triunghiurilor obținem ecuația:

<pre>
(x - x1) / (x2 - x1) = (y - y1) / (y2 - y1)

(x - x1) * (y2 - y1) = (y - y1) * (x2 - x1)

x * y2 - x * y1 - x1 * y2 + x1 * y1 = y * x2 - y * x1 - y1 * x2 + y1 * x1

x * y2 - x * y1 - x1 * y2 + x1 * y1 - y * x2 + y * x1 + y1 * x2 - y1 * x1 = 0

x * (y2 - y1) + y * (x1 - x2) + y1 * x2 - x1 * y2 = 0
</pre>

Introducând substituțiile:
<pre>
a = y2 - y1
b = x1 - x2
c = y1 * x2 - x1 * y2
</pre>

ajungem la forma generală a ecuației dreptei:
<pre>
a*x + b*y + c = 0
</pre>

== Reprezentarea în memoria calculatorului ==
Vom stoca o dreaptă prin valoarea coeficienților a, b și c ale ecuației sale:
<syntaxhighlight>
struct Dreapta {
double a;
double b;
double c;
};
</syntaxhighlight>

Pe care le vom calcula astfel:

<syntaxhighlight>
Dreapta obtineDreapta(Punct p1, Punct p2) {
Dreapta d;
d.a = p2.y - p1.y;
d.b = p1.x - p2.x;
d.c = p1.y * p2.x - p1.x * p2.y;
return d;
}
</syntaxhighlight>

== Interpretarea ecuației dreptei ==
Pentru a testa dacă un punct p aparține unei drepte d, înlocuim x și y din ecuația dreptei cu coordonatele punctului p.

<syntaxhighlight>
bool egale(double a, double b) {
return 1 - 1e-8 <= a / b && a / b <= 1 + 1e-8;
}

bool punctApartineDreptei(Dreapta d, Punct p) {
return egale(d.a * p.x + d.b * p.y + d.c, 0);
}
</syntaxhighlight>

== Semiplanele determinate de o dreaptă ==
Orice drepată d (cu ceficienții a, b și c) împarte planul în două semiplane. Vom distinge între ele numindu-le semiplanul pozitiv și semiplanul negativ.

Putem determina dacă un punct p (de coordonate x și y) se află în semiplanul pozitiv sau în semiplanul negativ calculând semnul expresiei:
<pre>
a*x + b*y + c
</pre>

astfel:
<syntaxhighlight>
int semiplan(Dreapta d, Punct p) {
if (egale(d.a * p.x + d.b * p.y + d.c, 0)) {
return 0;
} else if (d.a * p.x + d.b * p.y + d.c < 0) {
return -1;
} else {
return 1;
}
}
</syntaxhighlight>

== Forma canonică a ecuației dreptei ==
Ecuația unei drepe d poate fi înmulțită cu orice număr real r diferit de 0 și astfel obținem o altă ecuație cu aceeași mulțime a soluțiilor. Altfel spus, înmulțind coeficienții ecuației dreptei (a, b și c) cu același număr rear r obținem coeficienții unei ecuații ce desemnează aceeași dreaptă d.

De aceea, dacă pentru coeficienții a, b și c ai unei drepte d alegem r astfel:
<pre>
r = 1 / sqrt(a * a + b * b)
</pre>
și îi înmulțim prin r, aceștia vor respecta condiția suplimentară:
<pre>
a * a + b * b = 1
</pre>

Putem aduce o dreaptă la forma sa canonică astfel:
<syntaxhighlight>
Dreapta obtineFormaCanonica(Dreapta d) {
double r = sqrt(d.a * d.a + d.b * d.b);
d.a /= r;
d.b /= r;
d.c /= r;
return d;
}
</syntaxhighlight>

== Coincidența a două drepte ==
Două drepte coincid dacă și numai dacă conțin aceleași puncte. Două drepete conțin aceleași puncte dacă și numai dacă soluțiile ecuațiilor lor coincid. Soluțiile a două ecuații coincid dacă și numai dacă sunt echivalente. Două ecuații sunt echivalente dacă și numai dacă înmulțind una dintre ele cu un număr real r o obținem pe cealaltă.

Astfel, pentru a verifica dacă două drepte d1 și d2 cu coeficienții a1, b1, c1 respectiv a2, b2, și c2 coincid este suficient să verificăm dacă:
<pre>
a1 / a2 = b1 / b2 = c1 / c2
</pre>
Mai mult, dacă cele două ecuații sunt în formă canonică atunci:
<pre>
a1 / a2 = b1 / b2 = c1 / c2 = 1 sau -1
</pre>
iar semnul raportului dă "sensul" dreptei, care determină semnele semiplanelor.

Putem verifica dacă două drepte coincid astfel:
<syntaxhighlight>
bool coincid(Dreapta d1, Dreapta d2) {
return egale(d1.a * d2.b, d1.b * d2.a) &&
egale(d1.a * d2.c, d1.c * d2.a);
}
</syntaxhighlight>

== Panta unei drepte ==
Fie două puncte p1 și p2 de coordonate x1 și y1 respectiv x2 și y2 aparținând unei drepte d. Spunem că panta m dreptei d este:
<pre>
m = (y2 - y1) / (x2 - x1)
</pre>

Folosind formulele de calcul ale coeficienților a și b:
<pre>
a = y2 - y1
b = x1 - x2
</pre>
putem deduce că:
<pre>
m = -a / b
</pre>

Putem calcula panta unei drepte astfel:
<syntaxhighlight>
double panta(Dreapta d) {
return -d.a / d.b;
}
</syntaxhighlight>

== Paralelismul a două drepte ==
Două drepte d1 și d2 cu coeficieții a1, b1 și c1 respectiv a2, b2 și c2 sunt paralele dacă au aceeași pantă, adică:
<pre>
-a1 / b1 = -a2 / b2

a1 / b1 = a2 / b2

a1 * b2 = a2 * b1
</pre>

Putem verifica dacă două drepte sunt paralele astfel:
<syntaxhighlight>
bool suntParalele(Dreapta d1, Dreapta d2) {
return egale(d1.a * d2.b, d2.a * d1.b);
}
</syntaxhighlight>

== Distanța de la un punct la o dreaptă ==
Fie d o dreaptă cu coeficienții ecuației în '''formă canonică''' a, b și c și p un punct de coordonate x și y.

Distanța de la punctul p la dreapta d este dată de formula:
<pre>
a*x + b*y + c
</pre>

Putem calcula distanța de la un punct la o dreaptă astfel:
<syntaxhighlight>
double distanta(Dreapta d, Punct p) {
return d.a * p.x + d.b * p.y + d.c;
}
</syntaxhighlight>

= Triunghiul =

== Reprezentarea în memoria calculatorului ==
Vom stoca un triunghi prin cele trei puncte care îl determină:
<syntaxhighlight>
struct Triunghi {
Punct A;
Punct B;
Punct C;
};
</syntaxhighlight>

== Calculul ariei (cu formula lui Heron) ==
Formula lui Heron pentru calculul ariei unui triunghi cu vârfurile A, B și C este:
<pre>
a = BC
b = AC
c = AB
p = (a + b + c) / 2
Aria = sqrt((p - a) * (p - b) * (p - c) * p)
</pre>

Putem calcula aria folosind formula lui Heron astfel:
<syntaxhighlight>
double ariaHeron(Triunghi t) {
double a = distanta(t.B, t.C);
double b = distanta(t.A, t.C);
double c = distanta(t.A, t.B);
double p = (a + b + c) / 2;
return sqrt((p - a) * (p - b) * (p - c) * p);
}
</syntaxhighlight>

== Calculul ariei (cu determinant) ==
Formula de calcul a ariei unui triunghi cu vârfurile A, B și C cu ajutorul unui determinant este:
<pre>
| A.x A.y 1 |
D = | B.x B.y 1 |
| C.x C.y 1 |
Aria = |D| / 2
</pre>

Putem calcula aria cu ajutorul determinantului astfel:
<syntaxhighlight>
double ariaDeterminant(Triunghi t) {
double D
= t.A.x * t.B.y
+ t.B.x * t.C.y
+ t.C.x * t.A.y
- t.C.x * t.B.y
- t.A.x * t.C.y
- t.B.x * t.A.y;
return fabs(D) / 2;
}
</syntaxhighlight>

== Calculul ariei (cu înălțimea) ==
Formula pentru calculul ariei unui triunghi cu vârfurile A, B și C cu ajutorul înălțimii este:
<pre>
Aria = AB * dist(C, AB) / 2
</pre>

Putem calcula aria cu ajutorul înățimii astfel:
<syntaxhighlight>
double ariaInaltime(Triunghi t) {
return distanta(t.A, t.B) * distanta(obtineFormaCanonica(obtineDreapta(t.A, t.B)), t.C);
}
</syntaxhighlight>

== Sensul punctelor unui triunghi ==
Cele trei puncte ale unui triunghi pot fi date în sens trigonometric sau în sensul acelor de ceasornic.

Putem determina sensul în care sunt date în două feluri:
* cu semnul determinantului;
* cu semnul semiplanului mărginit de dreapta formată de primele două puncte și care îl conține pe al treilea.

Putem afla sensul punctelor unui triunghi astefel:
<syntaxhighlight>
int sensTriunghi(Triunghi t) {
double D
= t.A.x * t.B.y
+ t.B.x * t.C.y
+ t.C.x * t.A.y
- t.C.x * t.B.y
- t.A.x * t.C.y
- t.B.x * t.A.y;
if (D < 0) {
return -1;
} else {
return 1;
}
}
</syntaxhighlight>

= Temă =
Pentru data viitoare nu veți avea temă.

Clasele 9-10 lecția 4 - 23 oct 2015

2015-10-31T14:46:55Z

Dan:

= Prima oră =
== Liste simplu înlănțuite ==

=== Reprezentare în memoria calculatorului ===

<syntaxhighlight>
struct Node {
int head; // valoare
Node* tail; // urmator
};
</syntaxhighlight>

=== Alocare dinamică a memoriei cu prealocare ===

Atunci când trebuie să alocăm dinamic memorie puțină de foarte multe ori, folosirea frecventă a instrucțiunii new duce la consum suplimentar de timp și memorie, deoarece instrucțiunea new face apel la funcțiile sistemului de operare de gestionare a memoriei.

Într-o astfel de situație, ne putem ocupa noi înșine de gestionarea memoriei astfel:

<syntaxhighlight>
const int ALLOC_SIZE = 1 << 16;

Node* start;
int size = ALLOC_SIZE;
std::vector<Node*> addresses;

void prealloc(int noNodes) {
start = new Node[noNodes];
size = 0;
addresses.push_back(start);
}

Node* newNode() {
if (size == ALLOC_SIZE) {
prealloc(ALLOC_SIZE);
}
return &start[size++];
}

void myDelete() {
int i;
for (i = 0; i < (int)addresses.size(); ++i)
delete[] addresses[i];
}
</syntaxhighlight>

Mai departe putem apela funcția newNode() în loc să folosim instrucțiunea new Node. De asemenea, va trebui să apelăm funcția myDelete() la finalul execuției programului.

=== Lista vidă (care nu conține niciun element) ===
<syntaxhighlight>
Node* emptyList() {
return NULL;
}
</syntaxhighlight>

=== Test dacă o listă este vidă ===
<syntaxhighlight>
bool isEmpty(Node* list) {
return list == NULL;
}
</syntaxhighlight>

=== Adăugarea unei valori la începutul unei liste ===
<syntaxhighlight>
Node* prepend(int value, Node* list) {
Node* tmp = newNode();
tmp->head = value;
tmp->tail = list;
return tmp;
}
</syntaxhighlight>

=== Afișarea unei liste pe ecran ===
<syntaxhighlight>
void printList(Node* list) {
if (!isEmpty(list)) {
printf("%d ", list->head);
printList(list->tail);
}
}
</syntaxhighlight>

=== Suma elementelor unei liste ===
Cu acumulator și cu mai puțin consum de memorie (optimizată de compilator):
<syntaxhighlight>
// Spațiu: (2*pointeri+intreg)
int sumList1(Node* list, int sum = 0) {
if (!isEmpty(list)) {
return sumList1(list->tail, sum + list->head);
} else {
return sum;
}
}
</syntaxhighlight>

Fără acumulator și cu un consum mai mare de memorie (neoptimizată de compilator):
<syntaxhighlight>
// Spațiu: 2*pointeri*dimensiuneaListei
int sumList2(Node* list) {
if (isEmpty(list)) {
return 0;
} else {
return list->head + sumList2(list->tail);
}
}
</syntaxhighlight>

=== Ștergerea unei liste ===
<syntaxhighlight>
// Spațiu: 3*pointer
void eraseList(Node* list) {
if (!isEmpty(list)) {
Node* tail = list->tail;
delete list;
eraseList(tail);
}
}
</syntaxhighlight>

=== Testarea funcțiilor ===
<syntaxhighlight>
int main(void) {
int i;
int val;
int N;

// citirea datelor
Node* list = emptyList();
scanf("%d", &N);
for (i = 0; i < N; ++i) {
scanf("%d", &val);
list = prepend(val, list);
}

// afisarea solutiei
printList(list);
printf("\n");
printf("%d\n", sumList1(list));
printf("%d\n", sumList2(list));
myDelete();

return 0;
}
</syntaxhighlight>

= A doua oră =
== Trie ==
Trie-ul este o structură de date care permite stocarea și interogarea unui dicționar de cuvinte. Inițial, o structură trie nu conține nicun cuvânt. Operațiile care se pot efectua asupra unui trie sunt:
* inserarea unui cuvânt;
* ștergerea unui cuvânt;
* căutarea unui cuvânt.

=== Reprezentarea în memorie a unui trie ===
Un trie va fi reprezentat în memorie sub forma unui arbore ale cărui noduri vor avea un număr finit de fii etichetați, câte unul pentru fiecare literă din alfabetul cuvintelor care se indexează.

Spunem că un cuvânt se află într-un trie dacă și numai dacă există un drum care pornește din rădăcină și merge din fiu în fiu, pe muchiile corespunzătoare literelor cuvântului.

Un nod al arborelui va fi sotcat astfel:
<syntaxhighlight>
const int SIGMA = 3; // {a, b, c}
const char FIRST_LETTER = 'a';

class TrieNode { // nod al trie-ului
private:
TrieNode* next[SIGMA];
int contor;

public:
void insert(char* word);
int query(char* word);
bool erase(char* word);
};
</syntaxhighlight>

=== Inserarea unui cuvânt în trie ===
Un cuvânt nou se va insera în trie prin crearea drumului său, dacă nu există.

<syntaxhighlight>
void TrieNode::insert(char* word) {
if (*word == 0) {
this->contor++;
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
this->next[*word - FIRST_LETTER] = new TrieNode;
}
this->next[*word - FIRST_LETTER]->insert(word + 1);
}
}
</syntaxhighlight>

=== Căutarea unui cuvânt în trie ===
Un cuvânt va fi căutat în heap verificând dacă se poate parcurge drumul său.

<syntaxhighlight>
int TrieNode::query(char* word) {
if (*word == 0) {
return this->contor;
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
return 0;
} else {
return this->next[*word - FIRST_LETTER]->query(word + 1);
}
}
}
</syntaxhighlight>

=== Ștergerea unui cuvânt din trie ===
Un cuvânt va fi șters din trie ștergând toate nodurile de pe drumul corespunzător cuvântului cu condiția ca acestea să nu fie folosite de alte drumuri, corespunzătoare altor cuvinte din trie.

<syntaxhighlight>
bool TrieNode::erase(char* word) {
if (*word == 0) {
if (this->contor == 0) {
return false;
} else {
this->contor--;
return true;
}
} else {
if (this->next[*word - FIRST_LETTER] == NULL) {
return false;
} else {
bool answer = this->next[*word - FIRST_LETTER]->erase(word + 1);
if (answer) {
TrieNode* mySon = this->next[*word - FIRST_LETTER];
bool toDelete = mySon->contor == 0;
for (int i = 0; i < SIGMA; i++) {
toDelete &= mySon->next[i] == NULL;
}
if (toDelete) {
delete mySon;
this->next[*word - FIRST_LETTER] = NULL;
}
}
}
}
}
</syntaxhighlight>

=== Stocarea rădăcinii ===
Rădăcina unui trie poate fi stocată într-o altă clasă și toate operațiile pot fi apelate de acolo:

<syntaxhighlight>
class Trie {
private:
TrieNode* root;

public:
Trie() {
this->root = new TrieNode;
}

void insert(char* word) {
this->root->insert(word);
}

int query(char* word) {
return this->root->query(word);
}

bool erase(char* word) {
return this->root->erase(word);
}
};
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 3 probleme:
* [http://www.varena.ro/problema/trie Trie (Varena)];
* [http://www.infoarena.ro/problema/trie Trie (Infoarena)];
* [http://acm.timus.ru/problem.aspx?num=1542 1542 - Autocompletion (Timus)].

Clasa a 8-a lecția 5 - 21 oct 2015

2015-10-29T11:52:15Z

Dan:

= 1167 - Bicolored Horses =
Enunț: [http://acm.timus.ru/problem.aspx?space=1&num=1167 1167 - Bicolored Horses]

<pre>
Se dau:
- N cai ordonați și K grajduri
- Pentru fiecare cal știm tipul de cal (alb sau negru)

Cerință: Să se găsească o repartizare a cailor în grajduri
(fără să li se modifice ordinea) astfel încât să se obțină
un coeficient de nefericire total minim.

Se cere:
- Coeficientul minim de nefericire
= suma coeficienților de nefericire din fiecare grajd
= suma(pentru fiecare grajd, nrCaiAlbi * nrCaiNegri)
</pre>

== Implementare nerecursivă ==
Astăzi am trecut la implementarea nerecursivă a problemelor decompozabile în subprobleme suprapuse. De această dată am rezolvat o problemă de programare dinamică.

Implementarea nerecursivă trebuie redactată direct, fără pași intermediari. În plus, codul scris este mult mai puțin lizibil. Avantajul acestei metode de rezolvare este timpul redus de execuție iar dezavantajul este lipsa clarității codului.

Timpul de execuție este redus prin lipsa apelurilor recusive care necesită timp pentru transcrierea pe stivă a paraterilor.

Lizibilitatea este mult îngreunată deoarece nu este evident pentru cititorul codului dacă ordinea de calcul a elementelor din matrice este cea corectă. Nu este evident nici dacă inițializăm toate valorile matricei care nu sunt calculate de cazul general dar folosite de acesta.

Redactarea codului în această formă este, în plus, complicată și de faptul că trebuie să găsim o ordine în care să calculăm elementele matricei (sau matricelor) astfel încât de fiecare dată când aplicăm formula recurentă valorile de care depinde valoarea curentă să fie deja calculate.

Un alt avantaj al acestei metode este că că permite, în anumite situații, optimizarea stațiului folosit. De exemplu, în cazul de față, se pot stoca doar ultimele două coloane ale matricei '''Nefericire'''.

<syntaxhighlight>
#include <stdio.h>
#include <limits.h>

const int MAX_N = 500;
const int INF = INT_MAX / 2;

int Nefericire[1 + MAX_N][1 + MAX_N];
// Primul indice reprezintă numărul de cai puși în grajduri.
// Al doilea indice reprezintă numărul de grajduri ocupate deja.

int CaiNegri[1 + MAX_N];

int min(int a, int b) {
return a < b ? a : b;
}

int caiNegri(int begin, int end) {
return CaiNegri[end] - CaiNegri[begin];
}

int caiAlbi(int begin, int end) { // exclusiv begin, inclusiv end
return (end - begin) - caiNegri(begin, end);
}

int main() {
int i;
int N, K;
int calulCurent;
scanf("%d %d", &N, &K);
CaiNegri[0] = 0; // initializare
for (i = 1; i <= N; ++i) {
scanf("%d", &calulCurent);
CaiNegri[i] = CaiNegri[i - 1] + calulCurent;
}

int cai, grajduri;

// initializare
cai = 0;
for (grajduri = 1; grajduri <= K; grajduri++) {
Nefericire[cai][grajduri] = INF;
}
for (cai = 1; cai <= N; cai++) {
grajduri = 0;
Nefericire[cai][grajduri] = INF;
}
Nefericire[0][0] = 0;

// cazul general
for (cai = 1; cai <= N; cai++) {
for (grajduri = 1; grajduri <= K; grajduri++) {
int minim = INF;
for(int ultimiiCai = 1; cai - ultimiiCai >= grajduri - 1; ultimiiCai++)
// ultimiiCai reprezintă numărul de cai din grajdul cu numărul grajduri
minim = min(minim, Nefericire[cai - ultimiiCai][grajduri - 1] +
caiAlbi(cai - ultimiiCai, cai) *
caiNegri(cai - ultimiiCai, cai));
Nefericire[cai][grajduri] = minim;
}
}

// calcularea solutiei
int answer = Nefericire[N][K];

printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1586 1586 - Threeprime Numbers (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1167 1167 - Bicolored Horses (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1183 1183 - Brackets Sequence (Timus)].

Clasa a 8-a lecția 4 - 14 oct 2015

2015-10-29T11:50:42Z

Dan:

= 2018 - The Debut Album =
Enunț: [http://acm.timus.ru/problem.aspx?space=1&num=2018 2018 - The Debut Album]

== Implementare recursivă ==
<syntaxhighlight>
#include <cstdio>

#define MOD 1000000007

int limite[2];

// Calculează numărul de albume cu un număr dat de piese,
// respectând restricțiile din enunț care încep cu un anumit
// tip de piesă dat
int nrAlbume(int piese, int prim) {
if (piese == 0) {
// La limită, pot crea un singur album cu 0 piese.
// Această valoare se stabilește astfel încât, atunci
// când este interogată de cazul general (de mai jos)
// să conducă la obținerea rezultatului corect.
return 1;
} else {
int i;
int raspuns = 0;
// i reprezintă numărul de piese de același tip cu care
// încep albumele pe care le număr
for (i = 1; i <= limite[prim] && i <= piese; i++) {
raspuns += nrAlbume(piese - i, 1 - prim);
raspuns %= MOD;
}
return raspuns;
}
}

// Calculează numărul de albume cu un număr dat de piese,
// respectând restricțiile din enunț
int nrAlbume(int piese) {
return nrAlbume(piese, 0) + nrAlbume(piese, 1);
}

int main() {
int N;
scanf("%d %d %d", &N, &limite[0], &limite[1]);
printf("%d\n", nrAlbume(N));
return 0;
}
</syntaxhighlight>

Această implementare, deși corectă, are un timp de execuție exponențial, deoarece problema este împărțită în subprobleme care la rândul lor sunt împărțite în subprobleme și așa mai departe.

== Implementare cu memoizare ==

<syntaxhighlight>
#include <cstdio>

#define MOD 1000000007
#define MAX_PIESE 50000

int limite[2];

int NrAlbume[1 + MAX_PIESE][2];

// Calculează numărul de albume cu un număr dat de piese,
// respectând restricțiile din enunț care încep cu un anumit
// tip de piesă dat
int nrAlbume(int piese, int prim) {
if (NrAlbume[piese][prim] == 0) {
if (piese == 0) {
// La limită, pot crea un singur album cu 0 piese.
// Această valoare se stabilește astfel încât, atunci
// când este interogată de cazul general (de mai jos)
// să conducă la obținerea rezultatului corect.
NrAlbume[piese][prim] = 1;
} else {
int i;
int raspuns = 0;
// i reprezintă numărul de piese de același tip cu care
// încep albumele pe care le număr
for (i = 1; i <= limite[prim] && i <= piese; i++) {
raspuns += nrAlbume(piese - i, 1 - prim);
raspuns %= MOD;
}
NrAlbume[piese][prim] = raspuns;
}
}
return NrAlbume[piese][prim];
}

// Calculează numărul de albume cu un număr dat de piese,
// respectând restricțiile din enunț
int nrAlbume(int piese) {
return nrAlbume(piese, 0) + nrAlbume(piese, 1);
}

int main() {
int N;
scanf("%d %d %d", &N, &limite[0], &limite[1]);
printf("%d\n", nrAlbume(N));
return 0;
}
</syntaxhighlight>

Observăm că numărul de subprobleme distincte pe care trebuie să le rezolvăm este polinomial, iar algoritmul inițial calcula soluția pentru multe dintre aceste subprobleme de mai multe ori.

Aplicăm tehnica memoizării: Pornind de la aceste observații, ne dăm seama că putem stoca rezultatele tuturor subproblemelor și, de fiecare dată când este necesară reutilizarea rezultatului unei subprobleme calculată anterior vom folosi valoarea stocată după calculul inițial.

Astfel, timpul de execuție este redus de la exponențial la polinomial.

= Optimizarea soluției =

În prima etapă rescriem codul pentru tratarea cazului general al recurenței sub forma unei funcții pe care o vom optimiza ulterior.
<syntaxhighlight>
#include <cstdio>

#define MOD 1000000007
#define MAX_PIESE 50000

int limite[2];

int NrAlbume[1 + MAX_PIESE][2];

int max(int a, int b) {
return a > b ? a : b;
}

int nrAlbume(int piese, int prim);

// Calculează numărul de albume cu un număr de piese dat
// printr-un interval, respectând restricțiile din enunț
// care încep cu un anumit tip de piesă dat.
int sumaNrAlbume(int piese1, int piese2, int prim) {
int i;
int raspuns = 0;
for (i = piese1; i <= piese2; i++) {
raspuns += nrAlbume(i, prim);
raspuns %= MOD;
}
return raspuns;
}

// Calculează numărul de albume cu un număr dat de piese,
// respectând restricțiile din enunț care încep cu un anumit
// tip de piesă dat.
int nrAlbume(int piese, int prim) {
if (NrAlbume[piese][prim] == 0) {
if (piese == 0) {
// La limită, pot crea un singur album cu 0 piese.
// Această valoare se stabilește astfel încât, atunci
// când este interogată de cazul general (de mai jos)
// să conducă la obținerea rezultatului corect.
NrAlbume[piese][prim] = 1;
} else {
NrAlbume[piese][prim] = sumaNrAlbume(
max(0, piese - limite[prim]), piese - 1, 1 - prim);
}
}
return NrAlbume[piese][prim];
}
</syntaxhighlight>

Rescriem din nou funcția într-o formă cu mai puțini parametri.
<syntaxhighlight>
// Calculează numărul de albume cu un număr de piese dat
// printr-un interval de forma [0, piese], respectând restricțiile
// din enunț care încep cu un anumit tip de piesă dat.
int sumaNrAlbume(int piese, int prim) {
int i;
int raspuns = 0;
for (i = 0; i <= piese; i++) {
raspuns += nrAlbume(i, prim);
raspuns %= MOD;
}
return raspuns;
}

// Calculează numărul de albume cu un număr de piese dat
// printr-un interval, respectând restricțiile din enunț
// care încep cu un anumit tip de piesă dat.
int sumaNrAlbume(int piese1, int piese2, int prim) {
return sumaNrAlbume(piese2, prim) - sumaNrAlbume(piese1 - 1, prim);
}
</syntaxhighlight>

Rescriem noua funcție în formă recursivă.
<syntaxhighlight>
// Calculează numărul de albume cu un număr de piese dat
// printr-un interval de forma [0, piese], respectând restricțiile
// din enunț care încep cu un anumit tip de piesă dat.
int sumaNrAlbume(int piese, int prim) {
if (piese < 0) {
return 0;
} else if (piese == 0) {
return nrAlbume(0, prim);
} else {
return nrAlbume(piese, prim) + sumaNrAlbume(piese - 1, prim);
}
}
</syntaxhighlight>

În final, putem aplica memoizarea pe noua funcție:
<syntaxhighlight>
int SumaNrAlbume[1 + MAX_PIESE][2];

// Calculează numărul de albume cu un număr de piese dat
// printr-un interval de forma [0, piese], respectând restricțiile
// din enunț care încep cu un anumit tip de piesă dat.
int sumaNrAlbume(int piese, int prim) {
if (piese < 0) {
return 0;
} else {
if (SumaNrAlbume[piese][prim] == 0) {
if (piese == 0) {
SumaNrAlbume[piese][prim] = nrAlbume(0, prim);
} else {
SumaNrAlbume[piese][prim] = nrAlbume(piese, prim) + sumaNrAlbume(piese - 1, prim);
}
}
return SumaNrAlbume[piese][prim];
}
}
</syntaxhighlight>

Cu ajutorul acestei optimizări am redus cu un factor timpul de execuție polinomial.

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1017 1017 - Staircases (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1353 1353 - Milliard Vasya's Function (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=2018 2018 - The Debut Album (Timus)].

Clasa a 8-a lecția 3 - 7 oct 2015

2015-10-29T05:48:56Z

Dan: /* Programare dinamică */

= Rezolvare temă =
== 1635 - Mnemonics and Palindromes (Timus) ==

<pre>
Pal[i][j] = Secvența V[i..j] este palindrom

Pal[i][j] = true, dacă i == j (lungime 1)
= true, dacă i - 1 == j (lungime 0)
= true, dacă V[i] == V[j] și Pal[i + 1][j - 1]

Cost[i] = numărul minim de palindroame în care poate fi împărțit
textul cu ultimul palindrom terminându-se pe poziția i

Cost[i] = min(j 

= Subprobleme suprapuse =

Problemele decompozabil în subprobleme suprapuse pot fi împărțite în trei categorii:
* probleme de numărare: probleme în care se cere numărarea tuturor configurațiilor care au o anumită formă specificată în enunț;
* probleme de optim (numite de probleme de programare dinamică): probleme în care se cere alegerea unei soluții de cost minim;
* probleme de existență: probleme în care se cere să se spună dacă există o configurație de o anumită formă specificată în enunț.

Aceste categorii de probleme pot fi rezolvate prin explorarea (generarea) tuturor configurațiilor posibile (de regulă prin recursivitate). Din păcate, această abordare are un timp de execuție exponențial și va trebui redus.

== Tehnica generală de rezolvare a unei probleme decompozabilă în subprobleme suprapuse ==

Orice problemă care se poate descompune în subprobleme suprapuse poate fi abordată astfel:
* Vom implementa o soluție de recursivă, care va explora toate soluțiile posibile.
* Dacă această implementare folosește variable globale, vom face în așa fel încât toate aceste variable să devină parametri ale funcției recursive.
* Vom elimina toțo parametrii redundanți ai funcției.
* Vom aplica tehnica memoizării asupra acestei funcții.

'''Observație:''' Toți acești pași sunt doar un ghid care să vă ajute să treceți de la o soluție de tip recursiv la o soluție de tip calcul tabelar. Pentru început rezolvați câteva probleme trecând prin toți pașii, apoi puteți sări peste o parte din ei, până când veți putea scrie direct codul în forma sa finală, după aplicarea tuturor acestor pași.

== Problemă de existență ==
Dându-se un cuvânt (format numai din litere mici ale alfabetului englez) și o mască (formată din '''*''', '''?''' și litere mici ale alfabetului englez), să se determine dacă masca se potrivește peste cuvânt.

O literă mică din mască se potrivește cu aceeași litară mică din cuvânt. Caracterul '''?''' se potrivește cu orice literă mică din cuvânt. Iar caracterul '''*''' se potrivește cu oricâte litere mici din cuvânt (zero, una sau mai multe).

<syntaxhighlight>
#include <cstdio>
#include <cctype>

const int MAX_SIZE = 100;
char Cuvant[MAX_SIZE + 1];
char Masca[MAX_SIZE + 1];

char Verifica[MAX_SIZE + 1][MAX_SIZE + 1];

char verifica(int i, int j) { // sufixele care incep de
// pe pozitiile i si j in cuvant respectiv masca
// se pot transforma unul in celalalt
if (Verifica[i][j] == -1) {
if (Cuvant[i] == 0 && Masca[j] == 0) {
Verifica[i][j] = 1; // true
} else if (Masca[j] == 0) {
Verifica[i][j] = 0; // false
} else if (isalpha(Masca[j])) {
if (Cuvant[i] == Masca[j]) {
Verifica[i][j] = verifica(i + 1, j + 1);
} else {
Verifica[i][j] = 0; // false
}
} else if (Masca[j] == '?') {
if (Cuvant[i] == 0) {
Verifica[i][j] = 0; // false
} else {
Verifica[i][j] = verifica(i + 1, j + 1);
}
} else if (Masca[j] == '*') {
int k = i;
while (Cuvant[k] != 0 && verifica(k, j + 1) == 0) {
++k;
}
Verifica[i][j] = verifica(k, j + 1);
}
}
return Verifica[i][j];
}

int main(void) {
// citirea datelor
scanf("%s", Cuvant);
scanf("%s", Masca);

// calcularea solutiei
int i, j;
for (i = 0; i < MAX_SIZE + 1; ++i) {
for (j = 0; j < MAX_SIZE + 1; ++j) {
Verifica[i][j] = -1;
}
}
int answer = verifica(0, 0);

// afisarea solutiei
printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

== Problemă de optim (de programare dinamică) ==
[http://acm.timus.ru/problem.aspx?space=1&num=1119 1119 - Metro (Timus)]

<syntaxhighlight>
#include <cstdio>
#include <cmath>

const int MAX_N = 1000;
const int MAX_M = 1000;

int N, M;

int Diag[1 + MAX_N][1 + MAX_M];

int max(int a, int b) {
return a > b ? a : b;
}

int NrDiagMax[1 + MAX_N][1 + MAX_M];

int nrDiagMax(int i, int j) {
if (NrDiagMax[i][j] == -1) {
if (i == N && j == M) {
NrDiagMax[i][j] = 0;
} else if (Diag[i][j]) {
NrDiagMax[i][j] = nrDiagMax(i + 1, j + 1) + 1;
} else {
NrDiagMax[i][j] = max(
nrDiagMax(i + 1, j),
nrDiagMax(i, j + 1));
}
}
return NrDiagMax[i][j];
}

int main(void) {
// citirea datelor
scanf("%d %d", &N, &M);

// calcularea solutiei
int i, j;
for (i = 0; i < N + 1; ++i) {
for (j = 0; j < M + 1; ++j) {
NrDiagMax[i][j] = -1;
}
}
double answer = 100 *
(N + M + (sqrt(2) - 2) * nrDiagMax(0, 0));
// afisarea solutiei
printf("%.0lf\n", answer);
return 0;
}
</syntaxhighlight>

== Probleme de numărare ==
* [http://acm.timus.ru/problem.aspx?space=1&num=1009 1009 - K-based Numbers (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1081 1081 - Binary Lexicographic Sequence (Timus)].

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1119 1119 - Metro (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1073 1073 - Square Country (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1009 1009 - K-based Numbers (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1081 1081 - Binary Lexicographic Sequence (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1225 1225 - Flags (Timus)].

Clasele 11-12 lecția 2 - 25 sep 2015

2015-10-23T06:46:38Z

Dan: /* Prima oră */

= Prima oră =

== Operații logice ==

Operatorii logici discutați au fost:
* ''&&'' și / and / conjuncție
* ''||'' sau / or / disjuncție
* ''!'' not / negație

Acești operatori iau ca parametri orice tip de date. Prin convenție se consideră că parametrii lor iau valorile:
- ''Adevărat'' - pentru 0 sau NULL;
- ''Fals'' - pentru orice este diferit de 0.

Operatorii funcționează după următoarele reguli:

{| class="wikitable" style="margin: 0 0 1em 1em"
|- align="center"
|'''x&&y''' || x==0 || x!=0
|- align="center"
|y==0 || 0 || 0
|- align="center"
|y!=0 || 0 || 1
|- align="center"
|}

{| class="wikitable" style="margin: 0 0 1em 1em"
|- align="center"
|'''<nowiki>x||y</nowiki>''' || x==0 || x!=0
|- align="center"
|y==0 || 0 || 1
|- align="center"
|y!=0 || 1 || 1
|- align="center"
|}

{| class="wikitable" style="margin: 0 0 1em 1em"
|- align="center"
| || x==0 || x!=0
|- align="center"
|'''!x''' || 1 || 0
|- align="center"
|}

== Operații pe biți ==

Operatorii pe biți discutați au fost:
* ''&'' și pe biți / bitwise and
* ''|'' sau pe biți / bitwise or
* ''^'' sau exclusiv pe biți / bitwise xor
* ''~'' complementarul / bitwise not

Operatorul ^ funcționează după următoarele reguli:

{| class="wikitable" style="margin: 0 0 1em 1em"
|- align="center"
|'''x^y''' || x==0 || x==1
|- align="center"
|y==0 || 0 || 1
|- align="center"
|y==1 || 1 || 0
|- align="center"
|}

Operatorii pe biți se aplică pe (perechi de) secvențe de biți (de lungimi egale) și calculează o secvență de biți produsă prin aplicarea repetată a operației logice corespunzătoare pe fiecare poziție a secvenței.

== Radixsort ==
Radixsort este un algoritm de sortare care se aplică cel mai bine pe o mulțime de șiruri de caractere de aceeași lungime.

O problemă pe care puteți testa o implementare a algoritmului este [[http://www.infoarena.ro/problema/zimeria]].

Idea principală a algoritmului este să analizăm, pe etape, caracterele de pe o anumită poziție din toate cuvintele. Pe baza acestei idei, există două versiuni total diferite ale algoritmului, în funcție de ordine în care parcurgem caracterele.

=== LSD (Least Significant Digit) ===
Acest algoritm parcurge caracterele șirului de la ultimul la primul (de la caracterul care influențează cel mai puțin ordinea finală a cuvintelor către cel care o influențează cel mai semnificativ).

Algoritmul are L (= lungimea cuvintelor) pași. În primul pas se efectuează asupra șirului de intrare o sortare stabilă ținând cont de cea mai puțin semnificativă cifră. În pasul i se efectuează asupra șirului rezultat la pasul i-1 o sortare stabilă ținând cont de a i-a cea mai puțin semnificativă cifră.

Se poate demonstra prin inducție că după al i-lea pas șirurile sunt sortate după ultimele i cifre.

=== MSD (Most Significant Digit) ===
Acest algoritm parcurge caracterele șirului de la primul la ultimul (de la caracterul care influențează cel mai mult ordinea finală a cuvintelor către cel care o influențează cel mai puțin semnificativ).

Algoritmul este unul recursiv. În primul pas, toate cuvintele sunt sortate ținând cont de primul caracter. Pe baza acestuia se formează mai multe grupe compacte de cuvinte care au același prefix de lungime 1. În pasul următor fiecare din aceste grupe se sortează recursiv după următorul caracter. Acest proces se repetă recursiv fie până la ultimul caracter fie până când se ajunge la o grupă cu un singur element.

= A doua oră =

== Codificarea și memorarea submulțimilor ==

Putem codifica și memora o submulțime a unei mulțimi cu un număr finit (și mic) de elemente folosindu-ne de biții unui întreg. Presupunem că mulțimea are 64 de elemente (numerele întregi de la 0 la 63). Atunci putem asocia bitul i al unui ungined long long elementului cu valoarea i. Dacă elementul i face parte din submulțime, vom seta bitul i pe 1. Dacă elementul i nu face parte din submulțime, vom seta bitul i pe 0.

Exemple de codificare:
{| class="wikitable" style="margin: 0 0 1em 1em"
|- align="center"
|întreg10 || întreg2 || submulțime
|- align="center"
|0 || 000 || {}
|- align="center"
|1 || 001 || {0}
|- align="center"
|2 || 010 || {1}
|- align="center"
|3 || 011 || {1, 0}
|- align="center"
|4 || 100 || {2}
|- align="center"
|5 || 101 || {2, 0}
|- align="center"
|6 || 110 || {2, 1}
|- align="center"
|7 || 111 || {2, 1, 0}
|- align="center"
|}

La tablă am prezentat un algoritm de generare (și afișare) a tuturor submulțimilor mulțimii numerelor de la 0 la N-1:

<syntaxhighlight>
void genereaza(int N) {
int lim = 1 << N;
for (i = 0; i < lim; ++i) {
for (j = 0; j < N; ++j) {
if (i & (1 << j)) {
printf("%d ", j);
}
}
printf("\n");
}
}
</syntaxhighlight>

=== Aplicație ===
Am discutat apoi o problemă ([http://www.infoarena.ro/problema/sobo Sobo (Infoarena)]) de programare dinamică care calculează costuri optime pentru fiecare submulțime.

Apoi am schițat o rezolvare a acesteia. (Atenție: sursa de mai jos nu a fost testată)

<syntaxhighlight>
#include <cstdio>
#include <algorithm>

using namespace std;

int N, L;
int M[15][1000];
int sobolaniCu1[1000];
int Cost[1000];

int Solve[1 << 15];

int answer;

// 1 <= sobolani <= 2^N
int solve(int sobolani) {
if (Solve[sobolani] == 0) {
if (sobolani & (sobolani - 1) == 0) { // se testeaza
// daca a ramas un singur sobolan in submultime
Solve[sobolani] = 0;
} else {
int i;
Solve[sobolani] = 0;
for (i = 0; i < L; ++i) {
int cu0 = sobolani & (~sobolaniCu1[i]);
int cu1 = sobolani & sobolaniCu1[i];
if (cu0 > 0 && cu1 > 0) {
int answerI = Cost[i] +
max(solve(cu0), solve(cu1));
Solve[sobolani] = min(Solve[sobolani], answerI);
}
}
}
}
return Solve[sobolani];
}
// Functia recursiva foloseste:
// Timp: O(L^N) Spatiu pt. functie: O(N) (fara memoizare)
// Timp: O(2^N*L) Spatiu pt. functie: O(2^N) (cu memoizare)

int main(void) {
int i, j;

// citirea datelor
// ...

// calcularea solutiei
for (i = 0; i < N; ++i) {
for (j = 0; j < L; ++j) {
sobolaniCu1[j] |= (1 << i) || M[i][j];
// if (M[i][j]) {
// sobolaniCu1[j] |= 1 << i;
// }
}
}
answer = solve((1 << N) - 1);

// afisarea solutiei
printf("%d\n", answer);
return 0;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://www.infoarena.ro/problema/zimeria Zimeria (Infoarena)];
* [http://www.infoarena.ro/problema/divk Divk (Infoarena)].
* [http://www.infoarena.ro/problema/sobo Sobo (Infoarena)];
* [http://www.infoarena.ro/problema/ture Ture (Infoarena)].

Clasa a 7-a lecția 6 - 22 oct 2015

2015-10-22T13:34:42Z

Dan: /* Temă */

=Tema Rezolvări=
Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_5_-_15_oct_2015]

== Problema Alee ==

=== Cu reconstituirea drumului ===
<syntaxhighlight>
#include <stdio.h>
#include <assert.h>

#define MAX_N 175

int mat[1 + MAX_N + 1][1 + MAX_N + 1];
int dist[1 + MAX_N + 1][1 + MAX_N + 1];

// doar primele 4 directii sunt folosite
int dirLin[] = { 1, -1, 0, 0, 1, 1, -1, -1};
int dirCol[] = { 0, 0, 1, -1, 1, -1, 1, -1};

int linie[MAX_N * MAX_N];
int coloana[MAX_N * MAX_N];
int inceput, sfarsit;

int main(void) {
FILE* in = fopen("alee.in", "r");
FILE* out = fopen("alee.out", "w");
int N, M;
int i, j;
int l, c;

// citirea datelor
fscanf(in, "%d %d", &N, &M);
for (i = 0; i < M; ++i) {
fscanf(in, "%d %d", &l, &c);
mat[l][c] = 1; // obstacol
}
int L1, C1, L2, C2;
fscanf(in, "%d %d", &L1, &C1);
fscanf(in, "%d %d", &L2, &C2);
// bordarea matricei
for (c = 0; c <= N + 1; c++) {
mat[0][c] = 1;
mat[N + 1][c] = 1;
}
for (l = 1; l <= N; l++) {
mat[l][0] = 1;
mat[l][N + 1] = 1;
}

// calcularea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= N + 1; ++j) {
dist[i][j] = 0;
}
}
dist[L1][C1] = 1;
int vechi = 0;
inceput = sfarsit = 0;
linie[sfarsit] = L1;
coloana[sfarsit] = C1;
sfarsit++;
while (inceput < sfarsit && dist[L2][C2] == 0) {
l = linie[inceput];
c = coloana[inceput];
inceput++;
for (i = 0; i < 4; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == 0 && dist[l + dirLin[i]][c + dirCol[i]] == 0) {
dist[l + dirLin[i]][c + dirCol[i]] = dist[l][c] + 1;
linie[sfarsit] = l + dirLin[i];
coloana[sfarsit] = c + dirCol[i];
sfarsit++;
}
}
++vechi;
}

// afisarea solutiei
fprintf(out, "%d\n", dist[L2][C2]);

// reconstituirea drumului
l = L2;
c = C2;
fprintf(out, "%d %d\n", l, c);
for (j = dist[l][c]; j > 1; j--) {
assert(dist[l][c] == j);
i = 0;
while (dist[l + dirLin[i]][c + dirCol[i]] != dist[l][c] - 1) {
// Conditia i < 4 nu este necesara deoarece tot timpul
// va exista cel putin un vecin.
i++;
}
l = l + dirLin[i];
c = c + dirCol[i];
fprintf(out, "%d %d\n", l, c);
}
fclose(in);
fclose(out);
return 0;
}
</syntaxhighlight>

=== Cu operații specifice structurii coadă ===
<syntaxhighlight>
#include <assert.h>

#define MAX_N 175

int mat[1 + MAX_N + 1][1 + MAX_N + 1];
int dist[1 + MAX_N + 1][1 + MAX_N + 1];

// doar primele 4 directii sunt folosite
int dirLin[] = { 1, -1, 0, 0, 1, 1, -1, -1};
int dirCol[] = { 0, 0, 1, -1, 1, -1, 1, -1};

int linie[MAX_N * MAX_N];
int coloana[MAX_N * MAX_N];
int inceput, sfarsit;

void push(int l, int c) {
linie[sfarsit] = l;
coloana[sfarsit] = c;
sfarsit++;
}

int topL() {
return linie[inceput % SIZE];
}

int topC() {
return coloana[inceput % SIZE];
}

void pop() {
inceput++;
}

int isEmpty() {
return inceput == sfarsit;
}

int size() {
return sfarsit - inceput;
}

int main(void) {
FILE* in = fopen("alee.in", "r");
FILE* out = fopen("alee.out", "w");
int N, M;
int i, j;
int l, c;

// citirea datelor
fscanf(in, "%d %d", &N, &M);
for (i = 0; i < M; ++i) {
fscanf(in, "%d %d", &l, &c);
mat[l][c] = 1; // obstacol
}
int L1, C1, L2, C2;
fscanf(in, "%d %d", &L1, &C1);
fscanf(in, "%d %d", &L2, &C2);
for (c = 0; c <= N + 1; c++) {
mat[0][c] = 1;
mat[N + 1][c] = 1;
}
for (l = 1; l <= N; l++) {
mat[l][0] = 1;
mat[l][N + 1] = 1;
}

// calcularea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= N + 1; ++j) {
dist[i][j] = 0;
}
}
dist[L1][C1] = 1;
int vechi = 0;
inceput = sfarsit = 0;
linie[sfarsit] = L1;
coloana[sfarsit] = C1;
sfarsit++;
while (!isEmpty() && dist[L2][C2] == 0) {
l = topL();
c = topC();
pop();
for (i = 0; i < 4; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == 0 && dist[l + dirLin[i]][c + dirCol[i]] == 0) {
dist[l + dirLin[i]][c + dirCol[i]] = dist[l][c] + 1;
push(l + dirLin[i], c + dirCol[i]);
}
}
++vechi;
}

// afisarea solutiei
fprintf(out, "%d\n", dist[L2][C2]);

// reconstituirea drumului
l = L2;
c = C2;
fprintf(out, "%d %d\n", l, c);
for (j = dist[l][c]; j > 1; j--) {
assert(dist[l][c] == j);
i = 0;
while (dist[l + dirLin[i]][c + dirCol[i]] != dist[l][c] - 1) {
// Conditia i < 4 nu este necesara deoarece tot timpul
// va exista cel putin un vecin.
i++;
}
l = l + dirLin[i];
c = c + dirCol[i];
fprintf(out, "%d %d\n", l, c);
}
fclose(in);
fclose(out);
return 0;
}
</syntaxhighlight>

=== Cu coadă implementată circular ===
<syntaxhighlight>
...

#define SIZE (2 * (MAX_N + MAX_N))

int linie[SIZE];
int coloana[SIZE];
int inceput, sfarsit;

void push(int l, int c) {
linie[sfarsit % SIZE] = l;
coloana[sfarsit % SIZE] = c;
sfarsit++;
}

int topL() {
return linie[inceput % SIZE];
}

int topC() {
return coloana[inceput % SIZE];
}

void pop() {
inceput++;
}

int isEmpty() {
return inceput == sfarsit;
}

int size() {
return sfarsit - inceput;
}

...
</syntaxhighlight>

= Temă =
[http://varena.ro/runda/2015-10-22-clasa-7-tema-6 Tema 6 clasa a 7-a]

Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://varena.ro/problema/zigzag zigzag];
* [http://varena.ro/problema/bile1 bile1].

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_6_-_22_oct_2015]

Clasa7

2015-10-22T13:22:31Z

Dan: /* BFS Continuare */

= Recapitulare materie =

== Secvență bitonă prin rotație ==
Verificare secvență bitonă prin rotație. O secvență este bitonă dacă mai întîi crește și apoi, eventual, descrește. O secvență bitonă prin rotație este o secvență care fie este bitonă, fie poate fi făcută bitonă prin rotații succesive. Problema trebuie rezolvată fără a folosi vectori, similar cu problema secvenței crescătoare prin rotație. Soluție liniară. Dacă ați înțeles algoritmul încercați-vă forțele rezolvînd problema [http://varena.ro/problema/bitona secvență bitonă].

== Problema selecției ==
Dat un șir de <tt>n</tt> numere și o poziție <tt>k</tt> în acel șir să se spună ce element s-ar afla pe acea poziție dacă șirul ar fi sortat. Aplicăm repetat pivotarea quicksort. Calcul aproximativ al complexității pe cazul mediu: este O(n), în loc de O(n log n) dacă am fi făcut sortare. Dacă ați înțeles algoritmul încercați-vă forțele rezolvînd problema [http://varena.ro/problema/selectie selecție].

== Elementul majoritar ==
Dat un vector cu <tt>n</tt> elemente să se spună dacă conține un element majoritar. Un element majoritar este un element care apare de cel puțin <tt>n/2 + 1</tt> ori. Încercați să dați o soluție mai bună decît sortarea. Am discutat variante de algoritmi:
* Forță brută: luăm fiecare element din vector și vedem de cîte ori apare. Complexitate O(n2).
* Prin sortare: sortăm vectorul și căutăm subsecvența de elemente egale de lungime maximă. Complexitate: O(n2) cu sortare prin selecție, O(n log n) cu quicksort.
* Algoritmul optim: considerăm primul element drept candidat, iar apoi parcurgem vectorul, numărînd de cîte ori apare candidatul. De fiecare dată cînd apare un element diferit de candidat decrementăm contorul. Dacă contorul ajunge negativ repornim procedura cu elementul curent drept nou candidat. În final dacă candidatul are măcar o apariție îl verificăm de cîte ori apare în vector. Complexitate O(n).

Dacă ați înțeles algoritmul încercați-vă forțele rezolvînd problema [http://varena.ro/problema/majoritar elementul majoritar].

== Paranteze ==
Verificare expresie cu paranteze. Se dă o expresie cu paranteze rotunde, pătrate și acolade: <nowiki>(), [] și {}</nowiki>. Ele pot să apară în orice ordine, adică și <nowiki>)</nowiki> după <nowiki>]</nowiki>. Să se spună dacă o expresie este corectă. Exemple: <tt><nowiki>([()[]()]())[]</nowiki></tt> este corectă, <tt><nowiki>([)], )(, ([()]</nowiki></tt> nu sînt corecte. Am discutat despre cazul mai simplu, în care avem doar paranteze rotunde, apoi am generalizat la cazul cu mai multe tipuri de paranteze, folosind o stivă.

== Baze de numerație ==
Un ''sistem de numerație'' este un mod de a exprima numerele. Cu alte cuvinte o notație matematică pentru a reprezenta numerele folosind cifre sau alte simboluri într-o manieră consecventă. Sistemul de numerație este cel care face ca simbolurile "11" să fie interpretate ca simbolul binar al lui trei, simbolul zecimal al lui unsprezece, sau simbolul altor numere în diferite baze.

Un sistem de numerație:

* Reprezintă o mulțime utilă de numere (de ex. toți întregii, sau numerele raționale)
* Reprezintă unic fiecare număr
* Ideal, ar trebui să reflecte structura algebrică și aritmetică a numerelor

=== Conversia de la baza 10 la baza 2 ===
Pentru a converti un număr ''n'' din baza 10 în baza 2 îl vom împărți la 2 în mod repetat, pîna ce obținem cîtul zero. Apoi vom colecta resturile obținute de la ultimul către primul. Aceste resturi sînt cifrele numărului în baza doi, de la stînga la dreapta.

==== Exemplul 1 ====
Să convertim numărul ''26'' la baza 2:

''26 = 2×13 + 0'' 
''13 = 2×6 + 1'' 
''6 = 2×3 + 0'' 
''3 = 2×1 + 1'' 
''1 = 2×0 + 1'' 
 
''26(10) = 11010(2)''

==== Exemplul 2 ====
Să convertim numărul ''37'' la baza 2:

''37 = 2×18 + 1'' 
''18 = 2×9 + 0'' 
''9 = 2×4 + 1'' 
''4 = 2×2 + 0'' 
''2 = 2×1 + 0'' 
''1 = 2×0 + 1'' 
 
''37(10) = 100101(2)''

=== Conversia de la baza 2 la baza 10 ===
Această conversie se poate face direct, scriind fiecare cifră binară explicit înmulțită cu puterea corespunzătoare a lui 2.

==== Exemplul 3 ====
Să convertim numărul ''100101'' din baza 2 în baza 10:

''100101(2) = 1×25 + 0×24 + 0×23 + 1×22 + 0×21 + 1×20'' 
''100101(2) = 1×32 + 0×16 + 0×8 + 1×4 + 0×2 + 1×1'' 
''100101(2) = 32 + 4 + 1'' 
''100101(2) = 37(10)'' 

Deși această metodă a evaluării directe prin dezvoltarea numărului cu puterile lui doi este mai simplu de înțeles, există un algoritm ceva mai rapid. Începînd cu rezultatul ''0'', parcurgem cifrele binare de la stînga la dreapta. Pentru fiecare cifră a numărului de la intrare vom înmulți rezultatul cu doi și vom aduna cifra la rezultat.

==== Exemplul 4 ====
Să convertim numărul ''11010'' din baza 2 în baza 10 folosind acest algoritm:

''0×2 + 1 = 1'' 
''1×2 + 1 = 3'' 
''3×2 + 0 = 6'' 
''6×2 + 1 = 13'' 
''13×2 + 0 = 26'' 
 
''11010(2) = 26(10)'' 

Acesta este algoritmul pe care îl vom prefera pentru conversia numerelor din baza 2 în baza 10.

=== Conversie de la baza 10 la baza 2 ===
Se citește <tt>n</tt> de maxim 18 cifre. Să se afișeze reprezentarea lui în baza 2.

Varianta clasică, despre care am vorbit mai sus, este cea în care reținem resturile împărțirii repetate la doi și apoi le afișăm în ordine inversă:

<syntaxhighlight>#include <stdio.h>

int cifre[60]; // 60 de cifre binare = 18 cifre zecimale

int main() {
FILE *fin, *fout;
int m, i;
long long n; // 18 cifre inseamna long long

fin = fopen( "b10b2.in", "r" );
fscanf( fin , "%lld", &n );
fclose( fin );

m = 0;
while ( n > 0 ) {
cifre[m] = n % 2; // extragem pe rind resturile impartirii la 2
m++;
n /= 2;
}

fout = fopen( "b10b2.out", "w" );
for ( i = m - 1; i >= 0; i-- ) // afisam resturile in ordine inversa
fprintf( fout, "%d", cifre[i] );
fprintf( fout, "\n" );
fclose( fout );

return 0;
}</syntaxhighlight>

=== Conversie de la baza 2 la baza 10 ===
La intrare avem o înșiruire de caractere 0 și 1, neseparate de spații și terminate cu final de linie. Ele reprezintă un număr în baza 2 de cel mult 60 de cifre binare. Să se convertească acest număr la baza 10 și să se afișeze.

Vom proceda precum am discutat mai sus. Vom citi cifrele binare una cîte una și le vom adăuga la coada lui <tt>n</tt>, înmulțindu-l pe acesta cu doi și apoi adunînd cifra. Iată programul:

<syntaxhighlight>#include <stdio.h>

int main() {
FILE *fin, *fout;
long long n; // 18 cifre inseamna long long
char ch;

fin = fopen( "b2b10.in", "r" );
n = 0;
ch = fgetc( fin );
while( ch != '\n' ) {
n = n * 2 + ch - '0';
ch = fgetc( fin );
}
fclose( fin );

fout = fopen( "b2b10.out", "w" );
fprintf( fout, "%lld\n", n );
fclose( fout );

return 0;
}</syntaxhighlight>

=== Aplicație: submulțimile unei mulțimi ===
''Aceasta este o problemă clasică în matematică și informatică.''

Rezolvați în clasă următorul exercițiu: să se afișeze toate submulțimile nevide ale mulțimii <nowiki>{ 1, 2, 3, ..., n }</nowiki>.

Cum abordăm această problemă? La prima vedere pare foarte grea. Va trebui, probabil, să afișăm toate submulțimile de un element. Aceasta e simplu. Apoi cele de două elemente. Tot simplu, vom selecta perechile cu două bucle <tt>for</tt>. Apoi cele cu trei elemente. Hmmm, de data asta avem nevoie de trei bucle <tt>for</tt>. Apoi de patru. Apoi de cinci. Cînd se oprește? Răspunsul depinde de <tt>n</tt>. Dar stai! Nu putem scrie un număr variabil de bucle <tt>for</tt> una într-alta!

Ne trebuie o altă abordare. Vom codifica mulțimile. Cum? Foarte simplu: folosind vectorul lor caracteristic. Pentru fiecare element al mulțimii, de la 1 la <tt>n</tt>, vom avea un element în vectorul <tt>v</tt>. Pentru o submulțime dată <tt>v[i]</tt> este 1 dacă elementul <tt>i</tt> apare în submulțime.

Acest mod de codificare demonstrează un lucru interesant: numărul de submulțimi al unei mulțimi, incluzînd mulțimea vidă, este 2n. Interesant!

Cum vom folosi acest vector? Destul de neclar. Ne-ar trebui un mod în care să variem toate elementele sale de la zero la unu. Și iar ne întoarcem la buclele <tt>for</tt> una într-alta. Dar există un mod natural în care elementele pot trece prin toate combinațiile posibile de 0 și 1: dacă în loc să folosim un vector cu <tt>n</tt> elemente folosim un număr binar cu <tt>n</tt> cifre. Dacă pornim cu numărul binar de la zero și îl incrementăm pînă ce ajungem la 2n cele <tt>n</tt> cifre ale sale vor trece prin toate configurațiile posibile. Exact ce ne dorim!

În concluzie, care este algoritmul? Iată-l descris mai jos:

<pre>1. Pentru i de la 1 la 2^n - 1
1.1 Descompune i în baza 2
1.2 Pentru fiecare cifră binară 1 care se află pe poziția j
1.2.1 Afișează j
1.3 Sfîrșit de submulțime, treci la linia următoare</pre>

Remarcați că algoritmul nu folosește vectori! Vă invit să rezolvați problema [http://varena.ro/problema/submultimi1 submulțimi1] la vianuarena, folosind acest algoritm. După ce o rezolvați, pentru verificare, iată codul complet mai jos:

<syntaxhighlight lang="C" style="border: dashed">#include <stdio.h>

int main() {
FILE *fin, *fout;
int n, m, i, p2max, p;

fin = fopen( "submultimi1.in", "r" );
fscanf( fin, "%d", &n );
fclose( fin );

p2max = 1; // calculam 2^n, numarul pina unde trebuie sa numaram
for ( i = 0; i < n; i++ )
p2max *= 2;

fout = fopen( "submultimi1.out", "w" );
for ( i = 1; i < p2max; i++ ) { // numaram de la 1 la 2^n exclusiv
m = i; // copiem contorul, sa nu il pierdem
for ( p = 1; p <= n; p++ ) { // obtinem pe rind cifrele binare
if ( m % 2 == 1 ) // 1 inseamna ca pozitia apartine multimii
fprintf( fout, "%d ", p ); // afisam pozitia cifrei 1, p
m /= 2;
}
fprintf( fout, "\n" ); // am afisat o submultime, linie noua
}
fclose( fout );

return 0;
}</syntaxhighlight>

== Calculul multiplicității unui număr în ''n''<nowiki>!</nowiki> ==

=== Calculul multiplicității unui număr prim în ''n''<nowiki>!</nowiki> ===
Matematicianul [http://en.wikipedia.org/wiki/Adrien-Marie_Legendre Adrien-Marie_Legendre] a descoperit că multiplicitatea (exponentul) unui număr prim ''p'' care apare în descompunerea în factori primi a lui ''n''<nowiki>!</nowiki> poate fi exprimată exact ca:

:<math>Exp(p,n!) = \left \lfloor \frac{n}{p} \right \rfloor + \left \lfloor \frac{n}{p^2} \right \rfloor + \left \lfloor \frac{n}{p^3} \right \rfloor + \cdots = \sum_{i=1}^{\infty} \left \lfloor \frac{n}{p^i} \right \rfloor .</math>

Acest fapt se bazează pe numărarea factorilor ''p'' ai întregilor de la 1 la ''n''. Numărul multiplilor lui ''p'' în numerele de la 1 la ''n'' este <math>\textstyle \left \lfloor \frac{n}{p} \right \rfloor</math>; dar această formulă numără numerele cu doi factori ''p'' o singură dată. De aceea trebuie să mai numărăm încă <math>\textstyle \left \lfloor \frac{n}{p^2} \right \rfloor</math> factori ai lui ''p''. În mod similar pentru trei, patru, cinci factori, pînă la infinit. Însă suma este finită deoarece ''p'' ''i'' este mai mic sau egal cu ''n'' într-un număr finit de valori ale lui ''i'', drept care funcția parte întreagă va fi zero pentru toate celelalte valori.

Cînd scriem programul pentru calculul exponentului ne vom opri la acel ''i'' pentru care ''pi > n''.

=== Calculul multiplicității unui număr prim la o putere în ''n''<nowiki>!</nowiki> ===
Este simplu de demonstrat că dacă avem un număr prim ''p'' la o putere ''k'' atunci multiplicitatea lui ''pk'' în ''n''<nowiki>!</nowiki> este

:<math>Exp(p^k,n!) = \frac{Exp(p,n!)}{k}</math>

=== Calculul multiplicității unui număr oarecare în ''n''<nowiki>!</nowiki> ===
Este simplu să arătăm că dacă avem un număr ''a'' a cărui descompunere în factori primi este

:''a = p1k1 • p2k2 • … • pmkm''

atunci multiplicitatea (exponentul) lui ''a'' în ''n''<nowiki>!</nowiki> este

:<math>Exp(a,n!) = min(Exp(p_1^{k_1},n!),Exp(p_2^{k_2},n!),\ldots,Exp(p_m^{k_m},n!))</math>

sau

:<math>Exp(a,n!) = min(\frac{Exp(p_1,n!)}{k_1},\frac{Exp(p_2,n!)}{k_2},\ldots,\frac{Exp(p_m,n!)}{k_m})</math>

== Memoizare ==
''Memoizarea'' este o metodă de a face un program mai rapid fără a-i schimba modul în care el funcționează. Ideea ei este ca atunci cînd efectuăm un calcul scump să păstrăm valoarea calculată într-un tablou pentru a economisi timp în cazul cînd în viitor vom avea din nou nevoie de acea valoare. Să o învățăm prin exemple.
=== Exemplu ===
Să presupunem că ni se dau ''n'' numere ''a0, a1, ..., an-1'' și ni se cere să afișăm factorialele acelor numere modulo ''k''. O soluție naivă ar putea fi următoarea:

<syntaxhighlight>for ( i = 0; i < n; i++ ) {
p = 1;
for ( j = 2; j < a[i]; j++ )
p = (p * j) % k;
printf( "%d ", p );
}</syntaxhighlight>

Să calculăm complexitatea tipului de execuție: pentru fiecare număr ''ai'' vom face ''O(ai)'' înmulțiri, drept pentru care complexitatea soluției este ''O(suma(ai))''. Desigur că putem face un program mai eficient care calculează un vector <tt>fact[i]</tt> unde <tt>fact[i]</tt> este ''i''! (''i'' factorial). Acest vector se poate calcula în ''O(max(ai))'', după care printr-o parcurgere a numerelor ''ai'' vom putea calcula rezultatul ceea ce duce la o complexitate optimă de ''O(n + max(ai))''.

Însă în unele cazuri nu este ușor să schimbăm radical programul pentru a scrie o soluție mai eficientă decît soluția naivă. Cum putem folosi tehnica ''memoizării'' pentru a modifica foarte puțin soluția brută și a o aduce la complexitate optimă? Am putea ca de fiecare dată cînd calculăm ''ai''! să păstrăm rezultatul într-un vector la poziția ''ai''. Vom păstra, de asemenea și toate factorialele intermediare calculate pe parcurs. Atunci cînd vom avea nevoie de calculul unui factorial vom merge în jos pînă la primul factorial calculat. Iată implementarea:

<syntaxhighlight>fact[1] = 1; // pentru a ne opri la final
for ( i = 0; i < n; i++ ) {
j = a[i];
while ( fact[j] == 0 ) // cautam in jos primul factorial calculat
j--;
p = fact[j];
for ( j++; j <= a[i]; j++ ) // calculam toate valorile pina la a[i]
fact[j] = (fact[j-1] * j) % k;
printf( "%d ", fact[j] );
}</syntaxhighlight>

Ce complexitate în timp are această soluție? Deoarece ea nu repetă calcule în vectorul <tt>fact</tt> rezultă că fiecare element al vectorului va fi calculat cel mult odată, în timp ''O(1)'', deci soluția va fi optimă, ''O(n+max(ai))''. Observați că am obținut aceeași complexitate optimă dar fără a schimba structura algoritmului nostru naiv, ci doar memorînd rezultate parțiale într-un vector. Aceasta este exact ideea memoizării.

== Funcții în limbajul C ==
Funcțiile permit programelor complicate să fie parcelate în blocuri mici, fiecare din ele fiind mai ușor de scris, citit și modificat (întreținut). Am întîlnit deja funcția <tt>main()</tt> și am folosit funcții de intrare ieșire, precum și funcții matematice din bibliotecile standard. Vom vedea în continuare cum putem să scriem propriile noastre funcții.

=== De ce funcții ===
* Pentru a nu repeta cod.
* Pentru organizare, citibilitate, ușurinta înțelegerii codului și întreținerea codului.
* Recursivitate, precum vom vedea anul următor.

=== Sintaxa: cum scriem o funcție ===
==== Sintaxa (simplificare) ====
<pre><tip returnat> <nume funcție>(<tip1> <var1>, <tip2> <var2>, ..., <tipn> <varn>) {
... declarații variabile ...
... cod funcție ...
return <valoare return>; // dacă tipul returnat nu este 'void'
}
</pre>
==== Parametri și valoarea returnată ====
* Parametri, valoare returnată
* Transmisia parametrilor se face numai prin copiere, pe stiva sistem
** Ce afișează următorul program:
<syntaxhighlight>void inc( int a ) {
a++;
}

int main() {
int x = 0;
inc( x );
printf( "%d", x );
return 0;
}</syntaxhighlight>
* Valoarea returnată, prin copiere pe stiva sistem
* Cum modificam parametrii, operatorii <tt>&</tt> si <tt>&</tt>; ar fi bine să evitați, deocamdată. Exemplu: functia swap.
* Transmisie vectori ca parametri; vom transmite și lungimea; vectorul și lungimea lui sînt componente inseparabile ale tipului de date abstract.
** Ce se întîmplă dacă modificăm elementele vectorului în funcție?
** Ce se întîmplă dacă modificăm lungimea vectorului în funcție?
* Declarații de variabile și vizibilitatea acestora. Așezarea lor pe stivă.
* Conversia de tip cînd chemăm funcția cu alte tipuri decît cele declarate.

==== Apelul ====
O funcție este apelată astfel: <tt>numeFunctie( valoare1, valoare2, ..., valoaren );</tt>

= Tema =
* Implementați algoritmii din clasă la vianuarena: [http://varena.ro/problema/bitona bitonă], [http://varena.ro/problema/majoritar majoritar], [http://varena.ro/problema/selectie selecție]
* [http://varena.ro/runda/2014-09-30-clasa-7-tema-2 Tema 2 clasa a 7a]
* '''Opţional:''' Tema de la clasa a 8a
Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_2_-_30_sep_2014]

= Lecția 3 - Recursivitate (extensie) =

== Interclasarea a doi vectori prin recursivitate ==

Dându-se 3 vectori:
* vectorul 1 prin pointeri către începutul și după sfârșitul lui;
* vectorul 2 prin pointeri către începutul și după sfârșitul lui;
* vectorul 3 printr-un pointer către începutul lui
și garantându-se că:
* elementele vectorilor 1 și 2 sunt în ordine crescătoare;
* vectorul 3 are rezervat un spațiu cel puțin egal cu suma lungimilor vectorilor 1 și 2,
să se scrie o funcție recursivă care primește ca parametri cei 3 vectori și îi interclasează pe primii 2 în al treilea.

<syntaxhighlight>
void interclaseaza(
int* v1Inc, int* v1Sf,
int* v2Inc, int* v2Sf,
int* v3Inc) {
if (v1Inc != v1Sf && v2Inc != v2Sf) {
if (*v1Inc < *v2Inc) {
*v3Inc = *v1Inc;
interclaseaza(v1Inc + 1, v1Sf, v2Inc, v2Sf, v3Inc + 1);
} else {
*v3Inc = *v2Inc;
interclaseaza(v1Inc, v1Sf, v2Inc + 1, v2Sf, v3Inc + 1);
}
} else if (v1Inc != v1Sf) {
*v3Inc = *v1Inc;
interclaseaza(v1Inc + 1, v1Sf, v2Inc, v2Sf, v3Inc + 1);
} else if (v2Inc != v2Sf) {
*v3Inc = *v2Inc;
interclaseaza(v1Inc, v1Sf, v2Inc + 1, v2Sf, v3Inc + 1);
}
}
</syntaxhighlight>

= Temă =

Opțional: Să se rezolve cerința 2 din problema [http://varena.ro/problema/portofel Portofel] prin recursivitate.

= BFS Continuare =

== Problema Alee ==

=== Cu reconstituirea drumului ===
<syntaxhighlight>
#include <stdio.h>
#include <assert.h>

#define MAX_N 175

int mat[1 + MAX_N + 1][1 + MAX_N + 1];
int dist[1 + MAX_N + 1][1 + MAX_N + 1];

// doar primele 4 directii sunt folosite
int dirLin[] = { 1, -1, 0, 0, 1, 1, -1, -1};
int dirCol[] = { 0, 0, 1, -1, 1, -1, 1, -1};

int linie[MAX_N * MAX_N];
int coloana[MAX_N * MAX_N];
int inceput, sfarsit;

int main(void) {
FILE* in = fopen("alee.in", "r");
FILE* out = fopen("alee.out", "w");
int N, M;
int i, j;
int l, c;

// citirea datelor
fscanf(in, "%d %d", &N, &M);
for (i = 0; i < M; ++i) {
fscanf(in, "%d %d", &l, &c);
mat[l][c] = 1; // obstacol
}
int L1, C1, L2, C2;
fscanf(in, "%d %d", &L1, &C1);
fscanf(in, "%d %d", &L2, &C2);
// bordarea matricei
for (c = 0; c <= N + 1; c++) {
mat[0][c] = 1;
mat[N + 1][c] = 1;
}
for (l = 1; l <= N; l++) {
mat[l][0] = 1;
mat[l][N + 1] = 1;
}

// calcularea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= N + 1; ++j) {
dist[i][j] = 0;
}
}
dist[L1][C1] = 1;
int vechi = 0;
inceput = sfarsit = 0;
linie[sfarsit] = L1;
coloana[sfarsit] = C1;
sfarsit++;
while (inceput < sfarsit && dist[L2][C2] == 0) {
l = linie[inceput];
c = coloana[inceput];
inceput++;
for (i = 0; i < 4; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == 0 && dist[l + dirLin[i]][c + dirCol[i]] == 0) {
dist[l + dirLin[i]][c + dirCol[i]] = dist[l][c] + 1;
linie[sfarsit] = l + dirLin[i];
coloana[sfarsit] = c + dirCol[i];
sfarsit++;
}
}
++vechi;
}

// afisarea solutiei
fprintf(out, "%d\n", dist[L2][C2]);

// reconstituirea drumului
l = L2;
c = C2;
fprintf(out, "%d %d\n", l, c);
for (j = dist[l][c]; j > 1; j--) {
assert(dist[l][c] == j);
i = 0;
while (dist[l + dirLin[i]][c + dirCol[i]] != dist[l][c] - 1) {
// Conditia i < 4 nu este necesara deoarece tot timpul
// va exista cel putin un vecin.
i++;
}
l = l + dirLin[i];
c = c + dirCol[i];
fprintf(out, "%d %d\n", l, c);
}
fclose(in);
fclose(out);
return 0;
}
</syntaxhighlight>

=== Cu operații specifice structurii coadă ===
<syntaxhighlight>
#include <assert.h>

#define MAX_N 175

int mat[1 + MAX_N + 1][1 + MAX_N + 1];
int dist[1 + MAX_N + 1][1 + MAX_N + 1];

// doar primele 4 directii sunt folosite
int dirLin[] = { 1, -1, 0, 0, 1, 1, -1, -1};
int dirCol[] = { 0, 0, 1, -1, 1, -1, 1, -1};

int linie[MAX_N * MAX_N];
int coloana[MAX_N * MAX_N];
int inceput, sfarsit;

void push(int l, int c) {
linie[sfarsit] = l;
coloana[sfarsit] = c;
sfarsit++;
}

int topL() {
return linie[inceput % SIZE];
}

int topC() {
return coloana[inceput % SIZE];
}

void pop() {
inceput++;
}

int isEmpty() {
return inceput == sfarsit;
}

int size() {
return sfarsit - inceput;
}

int main(void) {
FILE* in = fopen("alee.in", "r");
FILE* out = fopen("alee.out", "w");
int N, M;
int i, j;
int l, c;

// citirea datelor
fscanf(in, "%d %d", &N, &M);
for (i = 0; i < M; ++i) {
fscanf(in, "%d %d", &l, &c);
mat[l][c] = 1; // obstacol
}
int L1, C1, L2, C2;
fscanf(in, "%d %d", &L1, &C1);
fscanf(in, "%d %d", &L2, &C2);
for (c = 0; c <= N + 1; c++) {
mat[0][c] = 1;
mat[N + 1][c] = 1;
}
for (l = 1; l <= N; l++) {
mat[l][0] = 1;
mat[l][N + 1] = 1;
}

// calcularea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= N + 1; ++j) {
dist[i][j] = 0;
}
}
dist[L1][C1] = 1;
int vechi = 0;
inceput = sfarsit = 0;
linie[sfarsit] = L1;
coloana[sfarsit] = C1;
sfarsit++;
while (!isEmpty() && dist[L2][C2] == 0) {
l = topL();
c = topC();
pop();
for (i = 0; i < 4; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == 0 && dist[l + dirLin[i]][c + dirCol[i]] == 0) {
dist[l + dirLin[i]][c + dirCol[i]] = dist[l][c] + 1;
push(l + dirLin[i], c + dirCol[i]);
}
}
++vechi;
}

// afisarea solutiei
fprintf(out, "%d\n", dist[L2][C2]);

// reconstituirea drumului
l = L2;
c = C2;
fprintf(out, "%d %d\n", l, c);
for (j = dist[l][c]; j > 1; j--) {
assert(dist[l][c] == j);
i = 0;
while (dist[l + dirLin[i]][c + dirCol[i]] != dist[l][c] - 1) {
// Conditia i < 4 nu este necesara deoarece tot timpul
// va exista cel putin un vecin.
i++;
}
l = l + dirLin[i];
c = c + dirCol[i];
fprintf(out, "%d %d\n", l, c);
}
fclose(in);
fclose(out);
return 0;
}
</syntaxhighlight>

=== Cu coadă implementată circular ===
<syntaxhighlight>
...

#define SIZE (2 * (MAX_N + MAX_N))

int linie[SIZE];
int coloana[SIZE];
int inceput, sfarsit;

void push(int l, int c) {
linie[sfarsit % SIZE] = l;
coloana[sfarsit % SIZE] = c;
sfarsit++;
}

int topL() {
return linie[inceput % SIZE];
}

int topC() {
return coloana[inceput % SIZE];
}

void pop() {
inceput++;
}

int isEmpty() {
return inceput == sfarsit;
}

int size() {
return sfarsit - inceput;
}

...
</syntaxhighlight>

Clasa8

2015-10-07T13:10:17Z

Dan: Replaced content with "= Work in progress = = Temă = Pentru data viitoare veți avea de rezolvat următoarele probleme: * [http://acm.timus.ru/problem.aspx?space=1&num=1119 1119 - Metro (Timus..."

= Work in progress =

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1119 1119 - Metro (Timus)];
* ....

Clasa a 8-a lecția 2 - 30 sep 2015

2015-10-07T09:23:42Z

Dan: /* Temă */

= Exemple =
== Permutări ==

Permutările numerelor de la 1 la N sunt toate modurile în care pot fi ordonate numerele de la 1 la N.

De exemplu, pentru N = 3, toate modurile în care pot fi ordonate numerele 1, 2 și 3 sunt:
* 1, 2, 3
* 1, 3, 2
* 2, 1, 3
* 2, 3, 1
* 3, 1, 2
* 3, 2, 1

== Aranjamente ==

Aranjamentele numerelor de la 1 la N luate câte K sunt toate modurile în care pot fi luate (alese) K numere dintre numerele de la 1 la N și ordonate (aranjate).

De exemplu, pentru N = 3, și K = 2 toate modurile în care pot fi aranjate 2 dintre numerele 1, 2 și 3 sunt:
* 1, 2
* 2, 1
* 1, 3
* 3, 1
* 2, 3
* 3, 2

== Combinări ==

Combinările numerelor de la 1 la N luate câte K sunt toate modurile în care pot fi luate (alese) K numere dintre numerele de la 1 la N (fără a ține cont de ordinea în care le alegem).

De exemplu, pentru N = 3, și K = 2 toate modurile în care pot fi alese 2 dintre numerele 1, 2 și 3 sunt:
* 1, 2
* 1, 3
* 2, 3

= Implementare =

Generarea permutărilor, aranjamentelor și combinărilor se face cel mai ușor prin backtracking recursiv. Dinferențele de implementare dintre cele trei probleme sunt minore și le vom analiza în continuare.

== Permutări ==

Pentru generarea permutărilor vom ține minte, în timpul execuției backtracking-ului:
* '''permCurenta''': începutul (prefixul) permutării curente (cea pe care urmează să o generăm);
* '''lista''': o listă cu toate elementele de la 1 la N care nu fac parte din începutul permutării curente.

Condiția de oprire a recursivității (backtracking-ului) este ca începutul permutării curente să fie o permutare completă (să aibă dimensiunea N).

Atunci în backtracking-ul nu se oprește, încearcă să completeze prefixul permutării curente cu un element care nu face parte din prefix. De accea vva parcurge elementele din '''lista''' și pe rând, va completa prefixul curent cu fiecare și va completa apoi restul permutării în mod recursiv.

=== Operații pe listă ===
Vom avea nevoie de trei operații pe lista elementelor nefolosite încă:
* '''void listaInit(int N)''': Inițializarea liste cu toate elementele de la 1 la N;
* '''void stergeDinLista(int pozitie)''': Eliminarea elementului de pe o anumită poziție din listă (și mutarea ultimului element din listă în locul celui eliminat);
* '''void adaugaInLista(int pozitie, int valoare)''': Adăugarea unei valori pe o anumită poziție din listă (și mutarea fostei valori la sfârșitul listei).

=== Implementare ===
<syntaxhighlight>
#include <stdio.h>

const int MAX_N = 10;

int lista[MAX_N];
int lungimeLista;

void listaInit(int N) {
int i;
for (i = 0; i < N; ++i) {
lista[i] = i + 1;
}
lungimeLista = N;
}

void stergeDinLista(int pozitie) {
lungimeLista--;
lista[pozitie] = lista[lungimeLista];
}

void adaugaInLista(int pozitie, int valoare) {
lista[lungimeLista] = lista[pozitie];
lungimeLista++;
lista[pozitie] = valoare;
}

int N;
int permCurenta[MAX_N];

void permN(int poz) {
if (poz == N) {
int i;
for (i = 0; i < N; ++i) {
printf("%d ", permCurenta[i]);
}
printf("\n");
} else {
int i;
for (i = 0; i < lungimeLista; ++i) {
permCurenta[poz] = lista[i];
stergeDinLista(i);
permN(poz + 1);
adaugaInLista(i, permCurenta[poz]);
}
}
}

int main(void) {
// citirea datelor
scanf("%d", &N);

// calcularea solutiei
// afisarea solutiei
listaInit(N);
permN(0);

return 0;
}
</syntaxhighlight>

== Aranjamente ==

Pentru generarea aranjamentelor vom face o singură modificare la algoritmul de generare al permutărilor: vom modifica condiția de oprire astfel încât lungimea aranjării curente să fie K.

=== Implementare ===
<syntaxhighlight>
#include <cstdio>

const int MAX_N = 18;

int lista[MAX_N];
int lungimeLista;

void listaInit(int N) {
int i;
for (i = 0; i < N; ++i) {
lista[i] = i + 1;
}
lungimeLista = N;
}

void stergeDinLista(int pozitie) {
lungimeLista--;
lista[pozitie] = lista[lungimeLista];
}

void adaugaInLista(int pozitie, int valoare) {
lista[lungimeLista] = lista[pozitie];
lungimeLista++;
lista[pozitie] = valoare;
}

int N, K;
int aranjCurenta[MAX_N];

void aranjNK(int poz) {
if (poz == K) {
int i;
for (i = 0; i < K; ++i) {
printf("%d ", aranjCurenta[i]);
}
printf("\n");
} else {
int i;
for (i = 0; i < lungimeLista; ++i) {
aranjCurenta[poz] = lista[i];
stergeDinLista(i);
aranjNK(poz + 1);
adaugaInLista(i, aranjCurenta[poz]);
}
}
}

int main(void) {
// citirea datelor
scanf("%d %d", &N, &K);

// calcularea solutiei
// afisarea solutiei
listaInit(N);
aranjNK(0);

return 0;
}
</syntaxhighlight>

== Combinări ==
Pentru generarea combinărilor numerelor de la 1 la N luate câte K vom ține un vector de elemente bool (folosind biții unui întreg - '''combCurenta''') cu rol de vector de frecvență: numărul i face sau nu face parte din prefixul curent al combinării în curs de generare.

Vom folosi shiftări pe biți pentru generarea de măști și operația ^ (xor) pentru schimbarea valorii unui anumit bit.

=== Implementare cu vector global ===

<syntaxhighlight>
#include <cstdio>

const int MAX_N = 18;

int N, K;
int combCurenta[MAX_N];

void combK(int poz = 0, int ultim = 0) {
if (poz == K) {
int i;
for (i = 0; i < K; ++i) {
printf("%d ", combCurenta[i]);
}
printf("\n");
} else {
int i;
for (i = ultim + 1; i <= N; ++i) {
combCurenta[poz] = i;
combK(poz + 1, i);
}
}
}

int main(void) {
freopen("combinari.in", "r", stdin);
freopen("combinari.out", "w", stdout);

// citirea datelor
scanf("%d %d", &N, &K);

// calcularea solutiei
// afisarea solutiei
combK();

return 0;
}
</syntaxhighlight>

=== Implementare cu întreg global ===
<syntaxhighlight>
#include <cstdio>

const int MAX_N = 18;

int N, K;
int combCurenta;

void combK(int poz = 0, int ultim = -1) {
if (poz == K) {
int i;
for (i = 0; i < N; ++i) {
if (combCurenta & (1 << i)) {
printf("%d ", i + 1);
}
}
printf("\n");
} else {
int i;
for (i = ultim + 1; i < N; ++i) {
combCurenta ^= 1 << i;
combK(poz + 1, i);
combCurenta ^= 1 << i;
}
}
}

int main(void) {
freopen("combinari.in", "r", stdin);
freopen("combinari.out", "w", stdout);

// citirea datelor
scanf("%d %d", &N, &K);

// calcularea solutiei
// afisarea solutiei
combK();

return 0;
}
</syntaxhighlight>

=== Implementare cu întreg dat ca parametru ===

<syntaxhighlight>
#include <cstdio>

const int MAX_N = 18;

int N, K;
int combCurenta[MAX_N];

void combK(int poz = 0, int ultim = 0) {
if (poz == K) {
int i;
for (i = 0; i < K; ++i) {
printf("%d ", combCurenta[i]);
}
printf("\n");
} else {
int i;
for (i = ultim + 1; i <= N; ++i) {
combCurenta[poz] = i;
combK(poz + 1, i);
}
}
}

int main(void) {
freopen("combinari.in", "r", stdin);
freopen("combinari.out", "w", stdout);

// citirea datelor
scanf("%d %d", &N, &K);

// calcularea solutiei
// afisarea solutiei
combK();

return 0;
}
</syntaxhighlight>

= Programare dinamică =
Astăzi am discutat rezolvarea problemei [http://acm.timus.ru/problem.aspx?space=1&num=1635 1635 - Mnemonics and Palindromes (Timus)]. Celor care au fost atenți, au înțeles și au reținut idea rezolvării le va fi mai ușor să rezolve această problemă dată și ca temă.

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1635 1635 - Mnemonics and Palindromes (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1146 1146 - Maximum Sum (Timus)];
* [http://varena.ro/problema/permutari Permutări (VArena)];
* [http://varena.ro/problema/combinari Combinări (VArena)].

Clasele 11-12 lecția 3 - 2 oct 2015

2015-10-06T12:56:30Z

Dan:

= Prima oră =

== Teoria jocurilor ==
Astăzi am discutat noțiuni introductive din teoria jocurilor și am văzut cum se calculează strategia optimă de câștig în jocurile imparțiale.

Un joc este imparțial dacă pentru orice stare a jocului ambii jucători au aceleași mutări la dispoziție.

Astfel, pentru orice stare a unui joc imparțial putem asocia o valoare de adevăr care spune dacă jucătorul aflat la mutare în acea stare are sau nu strategie sigură de gâștig indiferent de mutările ulterioare ale adversarului.

Regulile jocului vor defini cel puțin o stare ca fiind câștigătoare sau pierzătoare. Iar pe baza valorilor de adevăr asociate acestor stări va trebui să stabilim valoarea de adevăr ale tuturor celorlalte stări ale jocului. Pentru aceasta vom folosi următoarea formulă:

<pre>
Câștig[stareCurentă] = !(Caștig[stareViitoare1] && Caștig[stareViitoare1] && ... && Caștig[stareViitoareK])

unde:
Câștig[stare] = valoarea de adevăr asociată stării stare
stareViitoareI = mulțimea stărilor în care jucătorul aflat la mutare
în starea stareCurentă poate aduce jocul printr-o singură mutare
</pre>

Interpretarea acestei formule este:
* dacă, indiferent de mutarea pe care o va face, jucătorul curent va duce jocul într-o stare câștigătoare (pentru adversar) atunci starea curentă este pierzătoare (va pierde / nu are strategie optimă de câștig);
* dacă există cel puțin o mutare prin care jucătorul curent va duce jocul într-o stare pierzătoare (pentru adversar) atunci starea curentă este câștigătoare (va câștiga / are cel puțin o strategie optimă de câștig).

=== 1282 - Game Tree ===

Se dă un arbore cu rădăcină. Cei joi jucători pornesc din rădăcină și aleg alternativ pe care dintre fiii nodului curent să coboare în arbore. Toate frunzele au asociată o valoare:
* +1 - victorie pentru primul jucător;
* 0 - remiză;
* -1 - victorie pentru cel de-al doilea jucător.
Se cere să se spună care va fi deznodământul jocului dacă cei doi jucători aplică o strategie optimă.

= A doua oră =

În a doua oră am aplicat formula de calcul prezentată în prima oră pentru un joc cu un număr exponențial de stări ([http://www.infoarena.ro/problema/coins Coins (Infoarena)]). Mai exact, am asociat fiecărei stări a jocului un număr întreg care, scris în baza 2, are următoarea interpretare: fiecare bit de 1 corespunde unei căsuțe pe care se află un galben și fiecare bit de 0 corespunde unei căsuțe libere.

În esență, problema ne cere să calculă valorile de adevăr asociate elementelor unei mulțimi de cel mult 100000 de stări date.

Soluția este să calculăm valoarile de adevăr asociate tuturor celor 222 stări posibile ale jocului și apoi să răspundem la fiecare dintre întrebările date în O(1).

== Implementarea soluției ==

Primul lucru pe care trebuie să-l stabilim este modul de codificare al stărilor jocului în întregi. Vom vedea ulterior că implementarea este mai ușoară atunci când căsuțelor din stânga le corespund biții cei mai puțin semnificativi.

<syntaxhighlight>
int galben;
int stare = 0;
int cost = 0;
for(int j = 0; j < 22; ++j){
scanf("%d", &galben);
stare = stare ^ ((1 << j) * galben);
cost += galben;
}
</syntaxhighlight>

În pasul următor vom încerca să calculăm (recursiv) valoarea de adevăr asociată unei stări.

<syntaxhighlight>
bool castigatoare(int stare, int depth = 0) {
/*
for (int i = 0; i < depth; ++i) {
printf(" ");
}
printf("%d\n", stare);//*/
bool raspuns = true;
if ((stare & (stare + 1)) != 0) {
int i;
int ultimul0 = -1;
for (i = 0; i < 22; ++i) {
if (stare & (1 << i)) {
if (ultimul0 != -1) {
int nouaStare = stare ^ (1 << ultimul0) ^ (1 << i);
raspuns &= castigatoare(nouaStare, depth + 1);
}
} else {
ultimul0 = i;
}
}
raspuns = !raspuns;
}
return raspuns;
}
</syntaxhighlight>

Problema cu această metodă este că timpul de execuție devine exponențial în numărul de stări. O optimizare facilă ar fi memoizarea, care ar face ca timpul de execuție să devină liniar în numărul de stări. Deși complexitatea acestei abordări este bună, nu o vom folosi deoarece un algoritm iterativ are constanta per operație mult mai mică.

Folosindu-ne de observația că putem calcula valoarea de adevăr a unei stări dacă știm valoarea de adevăr a tuturor stărilor care au asociat un număr strict mai mic decât numărul asociat stării curente putem calcula aceste valori iterativ, în ordine, de la 0 la 222 - 1 astfel:

<syntaxhighlight>
bool Castigatoare[1 << 22];

for (int stare = 0; stare < (1 << 22); ++stare) {
bool raspuns = true;
// ...
// calculează răspunsul pentru stare în baza valorilor din array-ului Castigatoare
// ...
Castigatoare[stare] = raspuns;
}
</syntaxhighlight>

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1045 1045 - Funny Game (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1282 1282 - Game Tree (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1087 1087 - The Time to Take Stones (Timus)];
* [http://www.infoarena.ro/problema/coins Coins (Infoarena)];
* [http://www.infoarena.ro/problema/mesaj3 Mesaj 3 (Infoarena)].

Clasele 9-10 lecția 2 - 25 sep 2015

2015-09-27T11:52:54Z

Dan:

= Prima oră =

== Stiva ==

Stiva este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push(value) - inserează o valoare dată la ''sfârșitul'' listei;
* top - returnează valoarea de la ''sfârșitul'' listei;
* pop - șterge valoarea de la ''sfârșitul'' listei.

== Coada ==

Coada este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push(value) - inserează o valoare dată la ''sfârșitul'' listei;
* front - returnează valoarea de la ''începutul'' listei;
* pop - șterge valoarea de la ''începutul'' listei.

== Deque ==

Deque este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push_front(value) - inserează o valoare dată la ''începutul'' listei;
* push_back(value) - inserează o valoare dată la ''sfârșitul'' listei;
* pop_front - șterge valoarea de la ''începutul'' listei;
* pop_back - șterge valoarea de la ''sfârșitul'' listei;
* front - returnează valoarea de la ''începutul'' listei;
* back - returnează valoarea de la ''sfârșitul'' listei.

=== Implementare ===
La oră am implementat un deque cu ajutorul unui vector prealocat (de lungime fixă) și a două referințe care îl parcurg circular.

<syntaxhighlight>
const int SIZE;

int data[SIZE];

int top = 0; // poziția de început - front
int bottom = 0; // poziția imediat următoare după sfârșit - back

int size() {
return bottom - top;
}

void push_front(value) {
top--;
if (top == -1) {
top += SIZE;
bottom += SIZE;
}
data[top % SIZE] = value;
}

void push_back(value) {
data[bottom % SIZE] = value;
bottom++;
}

void pop_front() {
top++;
}

void pop_back() {
bottom--;
}

int front() {
return data[top % SIZE];
}

int back() {
return data[(top - 1) % SIZE];
}
</syntaxhighlight>

= A doua oră =

== Programare dinamică O(N3) ==
Am discutat o problemă clasică de programare dinamică numită [http://www.infoarena.ro/problema/podm Parantezare optimă de matrice (Infoarena)]. Fără a explica ce sunt matricele ca obiecte matematice și cum se înmulțesc acestea, vom reformula problema astfel:

Se citesc N și un șir V de N + 1 numere naturale. La un pas se poate elimina elementul i (1 < i <= N) din șirul de numere plătind un cost egal cu produsul V[i - 1] * V[i] * V[i + 1]. Toate elementele trebuie eliminate succesiv până când vom rămâne doar cu primul și cu ultimul. Se cere găsirea unei ordini în care trebuie eliminate elementele astfel încât suma costurilor operațiilor de eliminare să fie minimă.

Soluția se bazează pe calcularea costului total optim de eliminare a tuturor elementelor dintre pozițiile i și j pentru orice pereche de poziții i și j. Calcularea acestui cost se va realiza printr-o formulă recursivă care va presupune că ultimul element eliminat dintre i și j poate fi k (i < k < j):

<pre>
C[i][j] = min(k = i+1..j-1, C[i][k] + C[k][j] + V[i] * V[k] * V[j]), dacă j - i >= 2
(i<j) = 0, dacă j - i == 1
</pre>

Soluția problemei se va regăsi în C[1][N + 1].

Pentru a găsi o ordine optimă de eliminare a elementelor va trebui să reconstituim soluția, pornind de la perechea (1, N + 1), care ne va spune care este ultimul element șters (= k). Apoi vom face același lucru recursiv pentru perechile (1, k) și (k, N + 1) până vom ajunge la perechi de forma (i, i + 1) în care se va opri recursivitatea.

Tot pe o recurență cu aceeași structură se bazează și problema [http://acm.timus.ru/problem.aspx?space=1&num=1183 1183 - Brackets Sequence (Timus)] pe care nu am dus-o la bun sfârșit în clasă.

= Temă =
Pentru data viitoare veți avea de rezolvat următoarele 5 probleme:
* [http://acm.timus.ru/problem.aspx?space=1&num=1226 1226 - esreveR redrO (Timus)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1220 1220 - Stacks (Timus)];
* [http://www.infoarena.ro/problema/deque Deque (Infoarena)];
* [http://www.infoarena.ro/problema/podm Parantezare optimă de matrice (Infoarena)];
* [http://acm.timus.ru/problem.aspx?space=1&num=1183 1183 - Brackets Sequence (Timus)].

Clasa a 8-a lecția 1 - 23 sep 2015

2015-09-27T11:10:07Z

Dan: /* Deque */

Lecția de astăzi este o recapitulare a cunoștințelor teoretice învățate în primul semestru din anul trecut.

= Recursivitate =

== Plată suma ==
Moduri plată suma cu monede 1, 2, 5:

<syntaxhighlight>#include <stdio.h>

int mon[3] = { 1, 2, 5 };

int suma( int s, int nrmon ) { // in cite feluri platim s folosind nrmon monede
if ( nrmon == 0 ) // daca nu mai avem monede
return 0; // nu putem plati (zero moduri de plata)
if ( s < 0 ) // o suma negativa nu se poate plati
return 0;
if ( s == 0 ) // o suma de zero se plateste intr-un singur fel
return 1;
// putem plati in doua feluri de combinatii
// - fie in combinatii care se termina cu ultima moneda din vector
// - fie in combinatii care nu folosesc deloc ultima moneda din vector
return suma( s - mon[nrmon - 1], nrmon ) + suma( s, nrmon - 1 );
}

int main() {
int s;

scanf( "%d", &s );
printf( "%d este platibila in %d moduri\n", s, suma( s, 3 ) );
return 0;
}</syntaxhighlight>

== Tipuri de recursie ==
Există două moduri de implementare a unei soluții recursive:
=== Recursie Top-Down ===
Recursie '''Top-Down''': cînd pornim cu o problemă mai mare și apelăm funcția pentru probleme mai mici pe care le folosim ulterior în apelul curent. În subproblema de bază returnăm un rezultat de bază, cum ar fi zero sau unu. În această categorie sînt toate exemplele de mai sus cu excepția combinărilor, permutărilor si sumei de monede.
==== Factorial ====
Funcția factorial implementată recursiv top-down:

Ne vom folosi de definiția recursivă: <math>n! = \begin{cases} 1, & \mbox{dacă } n = 1 \\ n \cdot (n - 1)!, & \mbox{dacă } n > 1. \end{cases}</math>

<syntaxhighlight>

int fact( int n ) {
if ( n == 1 )
return 1;
else
return n * fact( n - 1 );
}

</syntaxhighlight>

=== Recursie Bottom-Up ===
Recursie '''Bottom-Up''': cînd pornim cu o problemă mai mare și cu un acumulator de soluție, care inițial este vid (zero sau unu), iar în apelurile ulterioare reducem mărimea problemei adăugînd (construind) soluția finală în acumulator. Exemplele de combinări și permutări sînt Bottom-Up în care acumulatorul este vectorul și nu este transmis în mod explicit, deși am putea face acest lucru.
==== Factorial ====
Funcția factorial implementată recursiv bottom-up cu acumulator:

<syntaxhighlight>#include <stdio.h>

int fact( int n, int ac ) {
if ( n == 1 ) // cind n = 1 am terminat calculul in ac
return ac;
else
return fact( n - 1, n * ac ); // adaugam n la acumulator
}

int main() {
int n;

scanf( "%d", &n );
printf( "%d! = %d\n", n, fact( n, 1 ) );

return 0;
}</syntaxhighlight>

== Fill recursiv (flood fill) ==
=== Introducere ===
Algoritmul ''fill'' "umple" toate golurile accesibile de la un punct dat. Golurile pot fi elemente zero intr-o matrice, de exemplu, iar vecinii pot fi definiți ca elementele adiacente pe linie și coloană (acesta este cazul cel mai întîlnit). Alteori vecinii pot fi definiți ca avînd un punct comun cu elementul curent, ceea ce include și elementele alăturate pe diagonală. Să luăm un exemplu clasic:

Se dă o matrice <tt>a[m][n]</tt> cu elemente <tt>0</tt> și <tt>1</tt>, <tt>0</tt> semnificînd liber și <tt>1</tt> semnificînd zid, precum și o poziție în matrice, <tt>(l, c)</tt>. Să se spuna cîte elemente <tt>0</tt> sînt accesibile de la <tt>(l, c)</tt> avansînd doar pe linie sau pe coloană.

<syntaxhighlight>int suma;
...
void fill( int l, int c ) {
suma++;
a[l][c] = 1;
if ( l > 0 && a[l-1][c] == 0 )
fill( l - 1, c );
if ( l < m-1 && a[l+1][c] == 0 )
fill( l + 1, c );
if ( c > 0 && a[l][c-1] == 0 )
fill( l, c - 1 );
if ( c < n-1 && a[l][c+1] == 0 )
fill( l, c + 1 );
}
...
int main() {
...
suma = 0;
if ( a[l][c] == 0 )
fill( l, c );
printf( "%d", suma );
...
}</syntaxhighlight>

Acest algoritm are complexitate O(m×n) ca timp, deoarece poate parcurge toate elementele matricei, iar prelucrarea per element este O(1). Memoria ocupată este de asemenea O(m×n) deoarece fiecare apel recursiv necesită O(1) memorie și putem avea O(m×n) apeluri recursive unul în altul.

'''Atenție'''! Acesta este principalul impediment al metodei! Ea folosește foarte multă memorie suplimentară.

= Liste =
== Definiție ==
[http://en.wikipedia.org/wiki/Linked_list Definiție]: în informatică o listă înlănțuită este o structură de date care constă dintr-un grup de noduri care împreună reprezintă o secvență. În forma ei cea mai simplă fiecare nod este format din date și o referință (înlănțuire) către nodul următor în secvență. Lista înlănțuită permite inserarea și ștergerea eficientă a elementelor de pe orice poziție în secvență. [[Image:lista-exemplu.gif|frame|none|Exemplu de listă înlănțuită]]

== Implementare ==
O primă implementare posibilă este folosind doi vectori: un vector ''v'' care memorează elementele listei (numere întregi de exemplu) și un vector ''next'', care memorează <nowiki>indicele următorului element din listă. Perechea (v[i], next[i]) conține un nod al listei.</nowiki>
== Operații cu liste ==
=== Inserare ===
{|
| valign="top"|[[Image:lista-inserare-desen.gif|frame|none|Inserare element - concept]]
| valign="top"|[[Image:lista-inserare-implementare.gif|frame|none|Inserare element - implementare]]
<syntaxhighlight>// pos conține poziția nodului de inserat
next[pos] = next[i];
next[i] = pos;</syntaxhighlight>
|-
| <center>Inserare element în listă după elementul i</center>
|}
=== Ștergere ===
{|
| valign="top"|[[Image:lista-stergere-desen.gif|frame|none|Ștergere element - concept]]
| valign="top"|[[Image:lista-stergere-implementare.gif|frame|none|Ștergere element - implementare]]
<syntaxhighlight>next[i] = next[next[i]];</syntaxhighlight>
|-
| <center>Ștergere element din listă după elementul i</center>
|}

= Structuri de date abstracte =
== Stiva ==

Stiva este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push(value) - inserează o valoare dată la ''sfârșitul'' listei;
* top - returnează valoarea de la ''sfârșitul'' listei;
* pop - șterge valoarea de la ''sfârșitul'' listei.

== Coada ==

Coada este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push(value) - inserează o valoare dată la ''sfârșitul'' listei;
* front - returnează valoarea de la ''începutul'' listei;
* pop - șterge valoarea de la ''începutul'' listei.

== Deque ==

Deque este o structură de date elementară care menține intern o listă de elemente. Inițial această listă este vidă. Asupra listei se pot efectua doar următoarele operații:
* push_front(value) - inserează o valoare dată la ''începutul'' listei;
* push_back(value) - inserează o valoare dată la ''sfârșitul'' listei;
* pop_front - șterge valoarea de la ''începutul'' listei;
* pop_back - șterge valoarea de la ''sfârșitul'' listei;
* front - returnează valoarea de la ''începutul'' listei;
* back - returnează valoarea de la ''sfârșitul'' listei.

= Analiza amortizată =

Despre '''analiza amortizată'''. Citat din [http://en.wikipedia.org/wiki/Introduction_to_Algorithms CLR]: În analiza amortizată facem media timpului necesar pentru a executa o secvență operații, împărțindu-l la toate operațiile executate. Prin analiza amortizată putem să arătăm că costul mediu al unei operații este mic, atunci cînd împărțim la numărul de operații, cu toate că o singură operație din secvență ar putea fi "scumpă". Acest cost mediu per operație se mai numește și ''costul amortizat''.

== Problema bibliotecarului (coada implementată cu două stive) ==
Un bibliotecar primește cărți una cîte una și le returnează în aceeași ordine, la cerere. În spatele ghișeului el are doi subalterni. Bibliotecarul trebuie să dea cărțile primite unuia din subalterni. Poate de asemenea să ceară înapoi cărți de la subalterni. Fiecare subaltern ține o stivă de cărți. Atunci cînd bibliotecarul îi dă o carte subalternul o pune peste toate celelalte, în stiva sa. Atunci cînd bibliotecarul îi cere o carte o ia pe prima din stivă și i-o returnează. Voi trebuie să găsiți algoritmul de funcționare a bibliotecarului astfel încît după un număr mare de depuneri și cereri de cărți numărul total de operații (înmînări de cărți) să fie cît mai mic ca complexitate. Puteți presupune că vor fi 500000 de depuneri de cărți și 500000 de cereri, în orice ordine coerentă.

Rezolvarea directă, evidentă, este, surprinzător, și cea corectă: bibliotecarul va da toate cărțile primite subalternului 1. Cînd i se cere o carte, i-o va cere subalternului 2. Dacă subalternul 2 nu are cărți atunci el îi va cere, pe rînd cărți subalternului 1 și i le va da subalternului 2, pînă ce subalternul 1 nu mai are cărți. Apoi returnează cartea pe care i-o va da subalternul 2.

Funcționează corect acest algoritm? Desigur, urmăriți un exemplu și vă veți convinge. Dar pare foarte ineficient! Pentru o carte cerută este posibil ca bibliotecarul să facă ''n'' operații! Să facem același calcul ca și mai devreme: orice carte va fi depusă la primul subaltern, apoi scoasă și depusă la cel de-al doilea subaltern și apoi returnată. Drept pentru care numărul total de operații va fi ''3n'', iar costul amortizat al unei operații de depunere sau de scoatere va fi O(1).

= Maximum în fereastră glisantă (maximum over a sliding window) =
* Enunț: dîndu-se un șir de ''n'' numere considerăm cele ''n – k + 1'' subsecvențe de ''k'' numere consecutive în șir (denumite și "ferestre" de lungime ''k''). Putem vedea aceste ferestre ca pe o singură fereastră, deplasabilă, care ne dă acces la ''k'' elemente din vector odată. Se cere ca pentru fiecare fereastră să se găsească maximul.
* Algoritmul de rezolvare trivial (forță brută) recalculează maximul pentru fiecare din ferestre, avînd complexitate ''O(kn)''.
* Pentru a reduce complexitatea găsirii maximului procedăm astfel: luăm prima fereastră, de la ''0'' la ''k-1''. Să spunem că maximul se află pe poziția ''p1''. Pe măsură ce vom deplasa fereastra este imposibil ca elementele din-naintea maximului să fie vreodată maximul ferestrei, deoarece ele vor face parte împreună cu maximul din această fereastră. Să considerăm poziția celui mai mare element după maxim și la dreapta lui, în fereastră. Fie ea ''p2''. Rezultă că nici un element pe pozițiile intermediare ''i'', ''p1 2'', nu poate fi vreodată maxim în fereastră, deoarece aceste elemente vor fi împreună cu ''p2'' în toate ferestrele care le conțin. Similar, considerînd ''p3'' poziția următorului maxim, nici un element între ''p2'' și ''p3'' nu va putea fi maxim. Astfel apare următorul algoritm:
** Memorăm toate maximele descrescătoare din prima fereastră, într-o coadă. Primul element din coadă este maximul ferestrei.
** Cînd deplasăm fereastra trebuie să actualizăm structura de maxime din coadă. Pentru aceasta dăm atenție elementului care dispare din fereastră și celui care intră în fereastră.
** Dacă elementul care iese nu este maximul curent, nu avem nimic de făcut.
** Dacă este maximul curent vom scoate primul element din coada de maxime.
** Dacă elementul proaspăt adăugat în fereastră este mai mic decît ultimul maxim din coadă se adaugă la coadă. În caz contrar el va "arunca" ultimul element, iar și încercăm din nou adăugarea în coadă.
** Rezultă că noul element din fereastră "aruncă" toate elementele de la urma cozii strict mai mici ca el, iar apoi îl adăugăm normal la coadă. [[Image:maximum-fereastra-glisanta.gif|frame|none|În figură noul maxim va elimina din coadă maximele 2 și 3. Coada rămasă va conține maximul 1 și maximul nou]]
* La prima vedere pare că acest algoritm are complexitate ''O(kn)''. Folosind analiza amortizată putem calcula complexitatea reală ca fiind ''O(n)''.
* Memoria suplimentară folosită este mărimea maximă a cozii, adică ''O(k)''.
* Observăm că putem folosi acest algoritm la problema [http://varena.ro/problema/cuburi cuburi]. Genul acesta de prelucrare, eliminarea unor cifre ale unui număr astfel încît numărul rămas să fie maxim (sau minim) apare des la olimpiade.
* La temă aveţi şi problema [http://varena.ro/problema/maxim maxim], o problemă de clasa a 5a la origine, adaptată pentru clasa a 8a şi analiză amortizată. Pentru cei cărora le plac provocările, încercaţi să rezolvaţi problema cu memorie ''O(1)''.

= Temă =
Pentru data viitoare va trebui să rezolvați două probleme:

* [http://acm.timus.ru/problem.aspx?num=1250 1250 - Sea Burial];
* [http://www.infoarena.ro/problema/secventa Secventa].

Instrucțiuni înscriere Clubul seniorilor

2015-09-16T17:01:41Z

Dan:

Acest grup a fost folosit atît pentru anunțuri cît și pentru discuții între voi pe tema cercului sau alte teme informatice. Se poate înscrie orice elev de la liceul Tudor Vianu din București, gimnaziu, din generația 2011-2015 (actualmente clasa a 9a). Înscrierea a fost '''obligatorie''' pentru cei care vin la cercul de informatică.

# Vizitați http://groups.varena.ro/listinfo/seniorii
# Completați formularul din secțiunea <nowiki>'Subscribing to Seniorii'</nowiki>:
## Introduceți adresa de email cu care doriți să vă înscrieți
## Introduceți numele vostru complet și corect în ordinea: ''<nowiki><nume mic> <nume mijlociu (daca există> <nume de familie></nowiki>'' Puteți folosi diacritice dacă doriți! Exemplu de nume în ordinea corectă: ''Cristian Aurelian Frâncu'' 
## Opțional: introduceți o parolă. Această parolă poate fi folosită pentru a vedea arhiva de mesaje, dar nu este necesară pentru a folosi lista (pentru a primi și a trimite email). Parola trebuie introdusă de două ori, pentru verificare.
# Apăsați butonul <nowiki>'Subscribe'</nowiki>
# Veți primi un email de confirmare a cererii de înscriere. În urma verificării că ați introdus numele corect și că faceți parte din clasele a 9a la liceul Vianu vi se va aproba înscrierea.
# După aprobarea înscrierii veți primi un email de confirmare și de bun venit la Clubul seniorilor. De acum încolo puteți folosi lista:
## Veți primi automat emailurile trimise pe acest grup
## Veți putea trimite emailuri pe grup trimițînd email la adresa ''seniorii@varena.ro''
# Succes!

Instrucțiuni înscriere Clubul înțelepților

2015-09-16T11:15:19Z

Dan:

Acest grup va fi folosit atît pentru anunțuri cît și pentru discuții între voi pe tema cercului sau alte teme informatice. Se poate înscrie orice elev de la liceul Tudor Vianu din București, gimnaziu, din generația 2012-2016 (actualmente clasa a 8a). Înscrierea este '''obligatorie''' pentru cei care vin la cercul de informatică.

# Vizitați http://groups.varena.ro/listinfo/inteleptii
# Completați formularul din secțiunea <nowiki>'Subscribing to Inteleptii'</nowiki>:
## Introduceți adresa de email cu care doriți să vă înscrieți
## Introduceți numele vostru complet și corect în ordinea: ''<nowiki><nume mic> <nume mijlociu (daca există> <nume de familie></nowiki>'' Puteți folosi diacritice dacă doriți! Exemplu de nume în ordinea corectă: ''Cristian Aurelian Frâncu'' 
## Opțional: introduceți o parolă. Această parolă poate fi folosită pentru a vedea arhiva de mesaje, dar nu este necesară pentru a folosi lista (pentru a primi și a trimite email). Parola trebuie introdusă de două ori, pentru verificare.
# Apăsați butonul <nowiki>'Subscribe'</nowiki>
# Veți primi un email de confirmare a cererii de înscriere. În urma verificării că ați introdus numele corect și că faceți parte din clasele a 8a la liceul Vianu vi se va aproba înscrierea.
# După aprobarea înscrierii veți primi un email de confirmare și de bun venit la Clubul înțelepților. De acum încolo puteți folosi lista:
## Veți primi automat emailurile trimise pe acest grup
## Veți putea trimite emailuri pe grup trimițînd email la adresa ''inteleptii@varena.ro''
# Succes!

Instrucțiuni înscriere Clubul campionilor

2015-09-16T11:14:45Z

Dan:

Acest grup va fi folosit atît pentru anunțuri cît și pentru discuții între voi pe tema cercului sau alte teme informatice. Se poate înscrie orice elev de la liceul Tudor Vianu din București, gimnaziu, din generația 2013-2017 (actualmente clasa a 7a). Înscrierea este '''obligatorie''' pentru cei care vin la cercul de informatică.

# Vizitați http://groups.varena.ro/listinfo/campionii
# Completați formularul din secțiunea <nowiki>'Subscribing to Campionii'</nowiki>:
## Introduceți adresa de email cu care doriți să vă înscrieți
## Introduceți numele vostru complet și corect în ordinea: ''<nowiki><nume mic> <nume mijlociu (daca există> <nume de familie></nowiki>'' Puteți folosi diacritice dacă doriți! Exemplu de nume în ordinea corectă: ''Cristian Aurelian Frâncu'' 
## Opțional: introduceți o parolă. Această parolă poate fi folosită pentru a vedea arhiva de mesaje, dar nu este necesară pentru a folosi lista (pentru a primi și a trimite email). Parola trebuie introdusă de două ori, pentru verificare.
# Apăsați butonul <nowiki>'Subscribe'</nowiki>
# Veți primi un email de confirmare a cererii de înscriere. În urma verificării că ați introdus numele corect și că faceți parte din clasele a 7a la liceul Vianu vi se va aproba înscrierea.
# După aprobarea înscrierii veți primi un email de confirmare și de bun venit la Clubul campionilor. De acum încolo puteți folosi lista:
## Veți primi automat emailurile trimise pe acest grup
## Veți putea trimite emailuri pe grup trimițînd email la adresa ''campionii@varena.ro''
# Succes!

Instrucțiuni înscriere Clubul gânditorilor

2015-09-16T11:14:08Z

Dan:

Acest grup va fi folosit atît pentru anunțuri cît și pentru discuții între voi pe tema cercului sau alte teme informatice. Se poate înscrie orice elev de la liceul Tudor Vianu din București, gimnaziu, din generația 2014-2018 (actualmente clasa a 6a). Înscrierea este '''obligatorie''' pentru cei care vin la cercul de informatică.

# Vizitați http://groups.varena.ro/listinfo/ganditorii
# Completați formularul din secțiunea <nowiki>'Subscribing to Ganditorii'</nowiki>:
## Introduceți adresa de email cu care doriți să vă înscrieți
## Introduceți numele vostru complet și corect în ordinea: ''<nowiki><nume mic> <nume mijlociu (daca există> <nume de familie></nowiki>'' Puteți folosi diacritice dacă doriți! Exemplu de nume în ordinea corectă: ''Cristian Aurelian Frâncu'' 
## Opțional: introduceți o parolă. Această parolă poate fi folosită pentru a vedea arhiva de mesaje, dar nu este necesară pentru a folosi lista (pentru a primi și a trimite email). Parola trebuie introdusă de două ori, pentru verificare.
# Apăsați butonul <nowiki>'Subscribe'</nowiki>
# Veți primi un email de confirmare a cererii de înscriere. În urma verificării că ați introdus numele corect și că faceți parte din clasele a 6a la liceul Vianu vi se va aproba înscrierea.
# După aprobarea înscrierii veți primi un email de confirmare și de bun venit la Clubul campionilor. De acum încolo puteți folosi lista:
## Veți primi automat emailurile trimise pe acest grup
## Veți putea trimite emailuri pe grup trimițînd email la adresa ''ganditorii@varena.ro''
# Succes!

Note de curs, probleme algoritmică, clasa IX/X, 28 noiembrie 2014

2015-06-23T22:03:47Z

Dan: Created page with "<pre> #include <stdlib.h> /* 3+(x-4*5)*5+9*y*y-z - + z + * 3 * * y - 5 9 y x * 4 5 2+2*2 + 2 *..."

<pre>
#include <stdlib.h>
/*

3+(x-4*5)*5+9*y*y-z

-
+ z
+ *
3 * * y
- 5 9 y
x *
4 5

2+2*2

+
2 *
2 2

*/

// MAX_INT = 0111 1111 1111 1111 1111 1111 1111 1111
// MIN_INT = 1000 0000 0000 0000 0000 0000 0000 0000
// -1 = 1111 1111 1111 1111 1111 1111 1111 1111+
// 1
// = 0000 0000 0000 0000 0000 0000 0000 0000

// MAX_INT = 0111 1111 1111 1111 1111 1111 1111 1111
// MAX_INT=0x7fffffff;
// MIN_INT = 1000 0000 0000 0000 0000 0000 0000 0000
// MIN_INT=0x80000000;

//const int MIN_INT = 1 << 31;
//const int MAX_INT = (1 << 31) - 1;
const int MAX_INT = 0x7fffffff;
const int MIN_INT = 0x80000000;

#include <cstdio>
#include <string>
#include <iostream>

using namespace std;

class Nod {
public:
virtual int evaluare() const = 0;

virtual int evaluare(int val) const = 0;

virtual ~Nod() {
;
}

virtual void print(ostream &f) const = 0;

virtual Nod* derivative(char var) const = 0;

friend ostream& operator << (ostream &f, const Nod& x) {
x.print(f);
return f;
}
};

class Operatie : public Nod {
public:
char op;
Nod* fiuSt;
Nod* fiuDr;

int evaluare(int val) const {
int answer;
switch (op) {
case '+':
answer = fiuSt->evaluare(val) + fiuDr->evaluare(val);
break;
case '-':
answer = fiuSt->evaluare(val) - fiuDr->evaluare(val);
break;
case '*':
answer = fiuSt->evaluare(val) * fiuDr->evaluare(val);
break;
case '/':
answer = fiuSt->evaluare(val) / fiuDr->evaluare(val);
break;
}
return answer;
}

int evaluare() const {
return this->evaluare(MIN_INT);
}

~Operatie() {
;
}

void print(ostream &f) const {
f << '(' << *fiuSt << op << *fiuDr << ')';
}

Nod* derivative(char var) const {
switch(op){
case '+':
{
Operatie* answer = new Operatie;
answer->op= '+';
answer->fiuSt= this->fiuSt->derivative(var);
answer->fiuDr= this->fiuDr->derivative(var);
return answer;
}
case '-':
{
Operatie* answer = new Operatie;
answer->op= '-';
answer->fiuSt= this->fiuSt->derivative(var);
answer->fiuDr= this->fiuDr->derivative(var);
return answer;
}
case '*':
{
Operatie* answer = new Operatie;
answer->op= '+';
Operatie* fiuSt = new Operatie;
fiuSt->op='*';
answer->fiuSt=fiuSt;
Operatie* fiuDr = new Operatie;
fiuDr->op='*';
answer->fiuDr=fiuDr;
fiuSt->fiuSt= this->fiuSt->derivative(var);
fiuSt->fiuDr= this->fiuDr;
fiuDr->fiuDr= this->fiuDr->derivative(var);
fiuDr->fiuSt= this->fiuSt;
return answer;
}
case '/':
{
Operatie* answer = new Operatie;
answer->op='/';
Operatie* numarator = new Operatie;
answer->fiuSt= numarator;
numarator->op= '-';
Operatie* fiuSt = new Operatie;
fiuSt->op='*';
numarator->fiuSt=fiuSt;
Operatie* fiuDr = new Operatie;
fiuDr->op='*';
numarator->fiuDr=fiuDr;
fiuSt->fiuSt= this->fiuSt->derivative(var);
fiuSt->fiuDr= this->fiuDr;
fiuDr->fiuDr= this->fiuDr->derivative(var);
fiuDr->fiuSt= this->fiuSt;
Operatie* numitor = new Operatie;
answer->fiuDr= numitor;
numitor->op= '*';
numitor->fiuSt= this-> fiuDr;
numitor->fiuDr= this-> fiuDr;
return answer;
}
}
/*if (this->nume == var) {
Valoare* answer = new Valoare;
answer->valoare = 1;
return answer;
} else {
Necunoscuta* answer = new Necunoscuta;
answer->nume = this->nume;
return answer;
}*/
}
};

class Valoare : public Nod {
public:
int valoare;

int evaluare() const {
return valoare;
}

int evaluare(int val) const {
return valoare;
}

~Valoare() {
;
}

void print(ostream &f) const {
f << valoare;
}

Nod* derivative(char var) const {
Valoare* answer = new Valoare;
answer->valoare = 0;
return answer;
}
};

class Necunoscuta : public Nod {
public:
char nume;

int evaluare() const {
throw "Functia nu se poate evalua";
return 0;
}

int evaluare(int val) const {
if (val == MIN_INT) {
throw "Functia nu se poate evalua";
}
return val;
}

~Necunoscuta () {
;
}

void print (ostream &f) const {
f << nume;
}

Nod* derivative(char var) const {
if (this->nume == var) {
Valoare* answer = new Valoare;
answer->valoare = 1;
return answer;
} else {
Necunoscuta* answer = new Necunoscuta;
answer->nume = this->nume;
return answer;
}
}
};

Nod* expresie(char* &adresa);

// factor = necunoscuta
// factor = constanta
// factor = (expresie)
Nod* factor(char* &adresa) {
if ( adresa[0]>='0'&&adresa[0]<='9' ){
Valoare* rezultat=new Valoare;
rezultat->valoare=adresa[0]-'0';
++adresa;
return rezultat;
} else if ( adresa[0]=='(' ){
++adresa;
Nod* rezultat=expresie(adresa);
if (adresa[0] != ')') {
throw "Lipseste ')'";
}
++adresa; // ')'
return rezultat;
} else if ( 'a' <= adresa[0] && adresa[0] <= 'z' ) {
Necunoscuta* rezultat = new Necunoscuta();
rezultat->nume = adresa[0];
++adresa;
return rezultat;
} else {
throw "Astept o valoare sau o paranteza";
}
}

// termen = factor*factor
// termen = factor/factor
// termen = factor/factor...
Nod* termen(char* &adresa) {
Nod* rezultat = factor (adresa);
while (adresa[0] == '*' || adresa[0] == '/') {
++adresa;
Operatie* rezultatAux = new Operatie();
rezultatAux->op = adresa[-1];
rezultatAux->fiuSt = rezultat;
rezultatAux->fiuDr = factor (adresa);
rezultat = rezultatAux;
}

return rezultat;
}

// expresie = termen+termen
// expresie = termen+termen+termen
// expresie = termen-termen
// expresie = termen-termen-termen
Nod* expresie(char* &adresa) {
Nod* rezultat = termen (adresa);
while (adresa[0] == '+' || adresa[0] == '-') {
++adresa;
Operatie* rezultatAux = new Operatie();
rezultatAux->op = adresa[-1];
rezultatAux->fiuSt = rezultat;
rezultatAux->fiuDr = termen (adresa);
rezultat = rezultatAux;
}

return rezultat;
}

Nod* construiesteArbore(char* V) {
char* adresa = V;
Nod* rezultat = expresie(adresa);
if (adresa[0] != 0) {
throw "Sirul nu s-a evaluat complet";
}
return rezultat;
}

const int MAX_N = 10000;

char V[MAX_N + 1];

int main(void) {
//printf("%d\n", rand() % 2);
printf("MIN_INT = %d\n", MIN_INT);
printf("MAX_INT = %d\n", MAX_INT);
// citirea datelor
scanf("%s", V);

// calcularea solutiei
try {
Nod* radacina = construiesteArbore(V);
int answer = radacina->evaluare(10);
cout << "f(x) = ";
cout << *radacina << endl;
cout << "f(10) = " << answer << endl;

cout << "f'(x) = " <<
*(radacina->derivative('x')) << endl;
} catch (char const* &error) {
cout << error;
}

return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 14 noiembrie 2014

2015-06-23T22:02:40Z

Dan: Created page with "<pre> /* 3+(x-4*5)*5+9*y*y-z - + z + * 3 * * y - 5 9 y x * 4 5 2+2*2 + 2 * 2 2 */ #include <c..."

<pre>
/*

3+(x-4*5)*5+9*y*y-z

-
+ z
+ *
3 * * y
- 5 9 y
x *
4 5

2+2*2

+
2 *
2 2

*/
#include <cstdio>
#include <string>
#include <iostream>

using namespace std;

class Nod {
public:
virtual int evaluare() const = 0;

virtual ~Nod() {
;
}

virtual void print(ostream &f) const = 0;

friend ostream& operator << (ostream &f, const Nod& x) {
x.print(f);
return f;
}
};

class Operatie : public Nod {
public:
char op;
Nod* fiuSt;
Nod* fiuDr;

int evaluare() const {
int answer;
switch (op) {
case '+':
answer = fiuSt->evaluare() + fiuDr->evaluare();
break;
case '-':
answer = fiuSt->evaluare() - fiuDr->evaluare();
break;
case '*':
answer = fiuSt->evaluare() * fiuDr->evaluare();
break;
case '/':
answer = fiuSt->evaluare() / fiuDr->evaluare();
break;
}
return answer;
}

~Operatie() {
;
}

void print(ostream &f) const {
f << '(' << *fiuSt << op << *fiuDr << ')';
}
};

class Valoare : public Nod {
public:
int valoare;

int evaluare() const {
return valoare;
}

~Valoare() {
;
}

void print(ostream &f) const {
f << valoare;
}
};

Nod* expresie(char* &adresa);

// factor = necunoscuta
// factor = constanta
// factor = (expresie)
Nod* factor(char* &adresa) {
if ( adresa[0]>='0'&&adresa[0]<='9' ){
Valoare* rezultat=new Valoare;
rezultat->valoare=adresa[0]-'0';
++adresa;
return rezultat;
} else if ( adresa[0]=='(' ){
++adresa;
Nod* rezultat=expresie(adresa);
if (adresa[0] != ')') {
throw "Lipseste ')'";
}
++adresa; // ')'
return rezultat;
} else {
throw "Astept o valoare sau o paranteza";
}
}

// termen = factor*factor
// termen = factor/factor
// termen = factor/factor...
Nod* termen(char* &adresa) {
Nod* rezultat = factor (adresa);
while (adresa[0] == '*' || adresa[0] == '/') {
++adresa;
Operatie* rezultatAux = new Operatie();
rezultatAux->op = adresa[-1];
rezultatAux->fiuSt = rezultat;
rezultatAux->fiuDr = factor (adresa);
rezultat = rezultatAux;
}

return rezultat;
}

// expresie = termen+termen
// expresie = termen+termen+termen
// expresie = termen-termen
// expresie = termen-termen-termen
Nod* expresie(char* &adresa) {
Nod* rezultat = termen (adresa);
while (adresa[0] == '+' || adresa[0] == '-') {
++adresa;
Operatie* rezultatAux = new Operatie();
rezultatAux->op = adresa[-1];
rezultatAux->fiuSt = rezultat;
rezultatAux->fiuDr = termen (adresa);
rezultat = rezultatAux;
}

return rezultat;
}

Nod* construiesteArbore(char* V) {
char* adresa = V;
Nod* rezultat = expresie(adresa);
if (adresa[0] != 0) {
throw "Sirul nu s-a evaluat complet";
}
return rezultat;
}

const int MAX_N = 10000;

char V[MAX_N + 1];

int main(void) {
// citirea datelor
scanf("%s", V);

// calcularea solutiei
try {
Nod* radacina = construiesteArbore(V);
int answer = radacina->evaluare();
cout << *radacina;
printf(" = %d\n", answer);
} catch (char const* &error) {
printf("%s\n", error);
}

return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 7 noiembrie 2014

2015-06-23T22:00:23Z

Dan:

<pre>
#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

template <class Type>
struct Vector {
int size;
Type *V;

Vector(int size, Type *data) {
this->size = size;
this->V = new Type[size];
// memcpy(this->V, data, size * sizeof(Type));
for (int i = 0; i < size; ++i) {
this->V[i] = data[i];
}
}

Vector(const Vector& arg) {
this->size = arg.size;
this->V = new Type[this->size];
// memcpy(this->V, data, size * sizeof(Type));
for (int i = 0; i < this->size; ++i) {
this->V[i] = arg[i];
}
}

Vector& operator = (const Vector& arg) {
delete this->V;
this->V = new Type[arg.size];
this->size = arg.size;
for (int i = 0; i < this->size; ++i) {
this->V[i] = arg[i];
}
return *this;
}

Type& operator [] (int poz) const {
return this->V[poz];
}

~Vector() {
delete this->V;
}
};

template <class Type>
Type primulElement(Vector<Type> v) {
return v[0];
// delete &v;
}

int main(void) {
int N;
int i;
float data[5];

// citirea datelor
scanf("%d", &N);
for (i = 0; i < N; ++i) {
scanf("%f", &data[i]);
}

Vector<float> v(N, data);
cout << v[3] << endl;
v[3] = 1;
cout << v[3] << endl;
Vector<float> w = v;
//Vector<float> w(v);
w = v;
cout << v[3] << ' ' << w[3] << ' ' << data[3] << endl;
w[3]++;
cout << v[3] << ' ' << w[3] << ' ' << data[3] << endl;

cout << primulElement(v) << endl;
Vector<int> q(1, new int[1]);
cout << primulElement(q) << endl;

return 0;
// delete &v;
// delete &w;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 31 octombrie 2014

2015-06-23T21:54:55Z

Dan: Created page with "<pre> #include <cstdio> #include <iostream> using namespace std; struct vector { int x, y, z; // constructor vector (int x = 0, int y = 0, int z = 0) { this->x = x;..."

<pre>
#include <cstdio>
#include <iostream>

using namespace std;

struct vector {
int x, y, z;

// constructor
vector (int x = 0, int y = 0, int z = 0) {
this->x = x;
this->y = y;
this->z = z;
}

vector operator +(const vector &v) const {
return vector(
this->x + v.x,
this->y + v.y,
this->z + v.z);
}

vector operator -(const vector &v) const {
return *this + (-v);
}

vector operator -() const {
return vector (-this->x, -this->y, -this->z);
}

vector operator *(int a) const {
return vector (this->x*a,this->y*a,this->z*a);
}

friend vector operator *(int a, const vector &v) {
return v * a;
}

friend istream& operator >>(istream &f,vector &v){
return f>>v.x>>v.y>>v.z;
}

friend ostream& operator <<(ostream &f,const vector &v){
return f<<v.x<<" "<<v.y<<" "<<v.z;
}
};

int main(void) {
vector v1;
vector v2;
vector v3;
vector vr;
//cin>>v1.x>>v1.y>>v1.z;
cin>>v1>>v2>>v3;
//scanf ("%d %d %d", &v1.x, &v1.y, &v1.z);
//scanf ("%d %d %d", &v2.x, &v2.y, &v2.z);
//scanf ("%d %d %d", &v3.x, &v3.y, &v3.z);

vr = (3 + 5) * (v1 * 3 + v2 - 7 * v3);

//printf ("%d %d %d\n", vr.x, vr.y, vr.z);
cout<<((3 + 5) * (v1 * 3 + v2 - 7 * v3))<<"\n";
//cout<<(vr<<"\n");
//(cout<<vr)<<"\n";
return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 23 ianuarie 2015

2015-06-23T21:35:38Z

Dan: Created page with "În acest curs am implementat un arbore de intervale folosind paradigma programări funcționale. == Definirea și construcția == Inițial, am definit un nod din arborele de..."

În acest curs am implementat un arbore de intervale folosind paradigma programări funcționale.

== Definirea și construcția ==
Inițial, am definit un nod din arborele de intervale. Fiind un arbore binar, fiecare nod are doi fii ordonați, fiul stâng (''left'') și fiul drept (''right''). Într-un nod am reținut numărul de frunze din subarborele asociat (''size''), suma frunzelor (''sum'') și valoarea adăugată tuturor fruzelor printr-o operație de update (''add'').

Apoi am implementat funcții care să construiască un arbore de intervale corespunzător unui vector prin de elemente nule respectiv unui vector oarecare de numere.
<pre>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>

using namespace std;

class ArbInt {
public:
const int sum;
const int add;
const ArbInt* const left;
const ArbInt* const right;
const int size;

ArbInt(int sum, int add, const ArbInt* const left, const ArbInt* const right, int size) :
sum(sum), add(add), left(left), right(right), size(size) {
;
}
};

const ArbInt* const emptyArbInt() {
return NULL;
}

bool isEmpty(const ArbInt* const arbInt) {
return arbInt == emptyArbInt();
}

const ArbInt* const createArbInt(int size) {
assert(size > 0);
if (size == 1)
return new ArbInt(0, 0, emptyArbInt(), emptyArbInt(), size);
else
return new ArbInt(0, 0,
createArbInt((size + 1) / 2),
createArbInt(size / 2),
size);
}

const ArbInt* const createArbInt(int* begin, int* end) {
if (end - begin == 1)
return new ArbInt(*begin, *begin, emptyArbInt(), emptyArbInt(), end - begin);
else {
const ArbInt* const arb1 = createArbInt(begin, begin + (end - begin) / 2);
const ArbInt* const arb2 = createArbInt(begin + (end - begin) / 2, end);
return new ArbInt(
arb1->sum + arb2->sum,
0,
arb1,
arb2,
end - begin);
}
}
</pre>

== Operațiile ==
Apoi am implementat cele două operații fundamentale pe arborii de intervale:
* '''addInterval''': adăungarea unei valori tuturor elementelor dintr-un interval (V[i] += val, begin <= i < end);
* '''sumInterval''': calcularea sumei elementelor dintr-un interval (s += V[i], begin <= i < end).

<pre>
const ArbInt* const addInterval(const ArbInt* const arbInt, int begin, int end, int add) {
if (begin == end)
return arbInt;
else if (end - begin == arbInt->size)
return new ArbInt(
arbInt->sum + arbInt->size * add,
arbInt->add + add,
arbInt->left,
arbInt->right,
arbInt->size);
else
return new ArbInt(
arbInt->sum + (end - begin) * add,
arbInt->add,
addInterval(arbInt->left,
min(begin, arbInt->left->size),
min(end, arbInt->left->size), add),
addInterval(arbInt->right,
max(0, begin - arbInt->left->size),
max(0, end - arbInt->left->size), add),
arbInt->size
);
}

int sumInterval(const ArbInt* const arbInt, int begin, int end) {
if (end - begin == arbInt->size)
return arbInt->sum;
else if (end <= arbInt->left->size)
return sumInterval(arbInt->left, begin, end)
+ arbInt->add * (end - begin);
else if (arbInt->left->size <= begin)
return sumInterval(arbInt->right,
begin - arbInt->left->size,
end - arbInt->left->size)
+ arbInt->add * (end - begin);
else
return sumInterval(arbInt->left, begin, arbInt->left->size) +
sumInterval(arbInt->right, 0, end - arbInt->left->size)
+ arbInt->add * (end - begin);
}
</pre>

== Testarea ==
În final, am testat operațiile implementate anterior mai întâi scriind o funcție care afișează clar și detaliat structura internă a arborelui de intervale și apoi scriind un program care construiește și efectuează o serie de operații asupra unui arbore de intervale, pentru ca apoi să-l afișeze.

<pre>
void dump(const ArbInt* const arbInt, int offset = 0) {
if (!isEmpty(arbInt)) {
dump(arbInt->right, offset + 1);
for(int i = 1; i <= 5 * offset; i++)
printf(" ");
printf("%d,%d\n", arbInt->sum, arbInt->add);
dump(arbInt->left, offset + 1);
}
}

int main() {
int v[] = {1, 3, 4, 9, 9, 4, 3, 5};
const ArbInt* const arbInt1 = createArbInt(v, v + 8);
printf("%d\n", sumInterval(arbInt1, 0, 5));
printf("%d\n", sumInterval(arbInt1, 1, 8));
const ArbInt* const arbInt2 = addInterval(arbInt1, 2, 4, 4);
printf("%d\n", sumInterval(arbInt2, 3, 7));
dump(arbInt2);
const ArbInt* const arbInt3 = addInterval(arbInt2, 0, 1, 100);
printf("%d\n", sumInterval(arbInt3, 0, 8));
return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 16 ianuarie 2015

2015-06-23T21:05:18Z

Dan:

În acest curs am implementat operațiile clasice pe trei dintre structurile de date elementare: stiva, coada și heap-ul folosind paradigma programării funcționale.

== Stiva ==
Să se implementeze o stivă, cu operațiile '''emptyStack''', '''isEmpty''', '''push''', '''peek''', '''pop''' și '''reverse'''.
<pre>
#include <cstdio>
#include <cstdlib>
#include <cassert>

class Stack {
public:
const int data;
const Stack* previous;

Stack(const int data, const Stack* previous) :
data(data),
previous(previous) {
}
};

const Stack* const emptyStack() {
return NULL;
}

bool isEmpty(const Stack* const stack) {
return stack == emptyStack();
}

const Stack* const push(const Stack* const stack, int val) {
return new Stack(val, stack); // ok
}

int peek(const Stack* const stack) {
return stack->data;
}

const Stack* const pop(const Stack* const stack) {
return stack->previous;
}

const Stack* const reverse(const Stack* const stack,
const Stack* const answer = emptyStack()) {
if (isEmpty(stack))
return answer;
else
return reverse(stack->previous, push(answer, stack->data));
}
</pre>

== Coada ==
Să se implementeze o coadă, cu operațiile '''emptyQueue''', '''isEmpty''', '''push''', '''pop''' și '''peek'''.
<pre>
class Queue {
public:
const Stack* const first;
const Stack* const second;

Queue(const Stack* const first, const Stack* const second) :
first(first),
second(second) {
;
}
};

const Queue* const emptyQueue() {
return new Queue(emptyStack(), emptyStack());
}

bool isEmpty(const Queue* const queue) {
return queue == emptyQueue();
}

const Queue* const push(const Queue* const queue, int val) {
return new Queue(push(queue->first,val), queue->second);
}

const Queue* const pop(const Queue* const queue) {
if (isEmpty(queue->second))
return new Queue(emptyStack(), pop(reverse(queue->first)));
else
return new Queue(queue->first, pop(queue->second));
}

int peek(const Queue* const queue) {
if (isEmpty(queue->second))
return peek(reverse(queue->first));
else
return queue->second->data;
}
</pre>

== Heap-ul ==
Să se implementeze operațiile: '''emptyHeap''', '''isEmpty''', '''push''', '''peek''' și '''pop''' într-un Min Heap.
<pre>
class Heap {
public:
int data;
const Heap* const left;
const Heap* const right;

Heap(int data, const Heap* const left, const Heap* const right) :
data(data),
left(left),
right(right) {
;
}
};

const Heap* const emptyHeap() {
return NULL;
}

bool isEmpty(const Heap* const heap) {
return heap == emptyHeap();
}

const Heap* const push(const Heap* const heap, int val) {
if (isEmpty(heap)) {
return new Heap(val, emptyHeap(), emptyHeap());
} else if (heap->data < val) {
if (rand() % 2 == 0)
return new Heap(heap->data, heap->left, push(heap->right, val));
else
return new Heap(heap->data, push(heap->left, val), heap->right);
} else { // val < heap->data
if (rand() % 2 == 0)
return new Heap(val, heap->left, push(heap->right, heap->data));
else
return new Heap(val, push(heap->left, heap->data), heap->right);
}
}

int peek(const Heap* const heap) {
return heap->data;
}

const Heap* const pop(const Heap* const heap) {
assert(!isEmpty(heap));
if (isEmpty(heap->left) && isEmpty(heap->right))
return emptyHeap();
else if (isEmpty(heap->right))
return heap->left;
else if (isEmpty(heap->left))
return heap->right;
else if (heap->left->data < heap->right->data)
return new Heap(heap->left->data, pop(heap->left), heap->right);
else // heap->right->data < heap->left->data
return new Heap(heap->right->data, heap->left, pop(heap->right));
}
</pre>

== Testarea implementării ==
Să se testeze structurile de date implementate anterior.
<pre>
int main() {
printf("Stack: ");
const Stack* const s1 = emptyStack();
const Stack* const s2 = push(s1, 1);
printf("%d ", peek(s2));
const Stack* const s3 = push(s2, 2);
printf("%d ", peek(s3));
const Stack* const s4 = push(s3, 3);
printf("%d ", peek(s4));
const Stack* const s5 = pop(s4);
printf("%d ", peek(s5));
const Stack* const s6 = pop(s5);
printf("%d ", peek(s6));
const Stack* const s7 = push(s6, 4);
printf("%d ", peek(s7));
const Stack* const s8 = push(s7, 5);
printf("%d ", peek(s8));
const Stack* const s9 = pop(s8);
printf("%d ", peek(s9));
const Stack* const s10 = pop(s9);
printf("%d\n", peek(s10));

printf("Queue: ");
const Queue* const q1 = emptyQueue();
const Queue* const q2 = push(q1, 1);
printf("%d ", peek(q2));
const Queue* const q3 = push(q2, 2);
printf("%d ", peek(q3));
const Queue* const q4 = push(q3, 3);
printf("%d ", peek(q4));
const Queue* const q5 = pop(q4);
printf("%d ", peek(q5));
const Queue* const q6 = pop(q5);
printf("%d ", peek(q6));
const Queue* const q7 = push(q6, 4);
printf("%d ", peek(q7));
const Queue* const q8 = push(q7, 5);
printf("%d ", peek(q8));
const Queue* const q9 = pop(q8);
printf("%d ", peek(q9));
const Queue* const q10 = pop(q9);
printf("%d\n", peek(q10));

printf("Heap: ");
const Heap* const h1 = emptyHeap();
const Heap* const h2 = push(h1, 6);
printf("%d ", peek(h2));
const Heap* const h3 = push(h2, 4);
printf("%d ", peek(h3));
const Heap* const h4 = push(h3, 8);
printf("%d ", peek(h4));
const Heap* const h5 = pop(h4);
printf("%d ", peek(h5));
const Heap* const h6 = pop(h5);
printf("%d ", peek(h6));
const Heap* const h7 = push(h6, 7);
printf("%d ", peek(h7));
const Heap* const h8 = push(h7, 5);
printf("%d ", peek(h8));
const Heap* const h9 = pop(h8);
printf("%d ", peek(h9));
const Heap* const h10 = pop(h9);
printf("%d\n", peek(h10));
return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 12 decembrie 2014

2015-06-23T20:19:43Z

Dan: Created page with "În acest curs am prezentat restricțiile impuse de programarea funcțională și am implementat câteva operații și câțiva algoritmi pe liste simplu înlănțuite. == Re..."

În acest curs am prezentat restricțiile impuse de programarea funcțională și am implementat câteva operații și câțiva algoritmi pe liste simplu înlănțuite.

== Restricții ==
Este permisă inițializarea de variable:
<pre>
const int a = 7;
const int* const p = &a;
</pre>

Nu este permisă atribuirea de variabile:
<pre>
a = 9; // eroare
p = new int; // eroare
</pre>

Nu este permisă modificarea datelor adresate de un pointer:
<pre>
*p = 9; // eroare
</pre>

Nu este permisă atribuirea de variabile prin alți operatori:
<pre>
a++; // eroare
a--; // eroare
a += 2; // eroare
</pre>

Ca o consecință, structurile repetitive nu pot fi folosite:
<pre>
for (int i = 0; i < 10; ++i); // eroare

int i = 0;
while (i < 10) {
++i; // eroare
}
</pre>

Pentru a transforma limbajele C și C++ în limbaje funcționale vom declara toate variabilele constante. Singura excepție tolerabilă fiind atunci când citim datele cu ajutorul funcțiilor din familia scanf.

== Definirea unui element al unei liste simplu înlănțuite de întregi ==
<pre>
#include <cstdio>
#include <cstdlib>
#include <cassert>

class Nod {
public:
const int head;
const Nod *const tail;
Nod(const int val, const Nod *const tail) :
head(val), tail(tail) {}
};
</pre>

== Operații elementare ==
1. Să se scrie o funcție care creează o listă (de întregi) goală.
<pre>
const Nod* const emptyList() {
return NULL;
}
</pre>
2. Să se scrie o funcție care verifică dacă o listă dată este vidă.
<pre>
bool isEmpty(const Nod* const lista) {
return lista == NULL;
}
</pre>

3. Să se scrie o funcție care adaugă un element (un întreg) la începutul unei liste existente, creând o listă nouă.
<pre>
const Nod* const prepend(const int valoare, const Nod* const lista) {
return new Nod(valoare, lista);
}
</pre>

4. Să se afișeze pe ecran elementele unei liste date.
<pre>
void print(const Nod *const lista) {
if (!isEmpty(lista)) {
printf("%d ", lista->head);
print(lista->tail);
}
}
</pre>

== Alte operații ==
5. Să se adauge un element la sfârșitul unei liste date.
<pre>
const Nod* const append(const int valoare, const Nod* const lista) {
if (isEmpty(lista)) {
return prepend(valoare, emptyList());
} else {
return prepend(lista->head, append(valoare, lista->tail));
}
}
</pre>

6. Dându-se o listă nouă, să se creeze o listă nouă cu elementele primeia în ordine inversă.
<pre>
const Nod* const reverse(const Nod* const lista,
const Nod* const result = emptyList()) {
if (isEmpty(lista))
return result;
else
return reverse(lista->tail, prepend(lista->head, result));
}
</pre>

7. Să se creeze o listă nouă, cu elementele de pe poziții impare ale unei liste date.
<pre>
const Nod* const evenElements(const Nod* const lista);

const Nod* const oddElements(const Nod* const lista) {
if(isEmpty(lista))
return emptyList();
else
return prepend(lista->head, evenElements(lista->tail));
}
</pre>

8. Să se creeze o listă nouă, cu elementele de pe poziții pare ale unei liste date.
<pre>
const Nod* const evenElements(const Nod* const lista) {
if (isEmpty(lista))
return emptyList();
else
return oddElements(lista->tail);
}
</pre>

== Algoritmi pe liste ==
9. Să se aleagă aleator, echiprobabil, un element dintr-o listă.
<pre>
int rand(int max) {
return rand() % max;
}

const int pivot(const Nod* const lista, int lung = 1) {
if (isEmpty(lista))
return 0x80000000;
else{
int chosen = pivot(lista->tail, lung + 1);
if (chosen != (int)0x80000000)
return chosen;
else if (rand(lung) == 0)
return lista->head;
else
return 0x80000000;
}
}
</pre>

10. Să se interclaseze două liste sortate, într-una singură.
<pre>
const Nod* const interleave(const Nod* const lista1, const Nod* const lista2) {
if (isEmpty(lista1))
return lista2;
else if (isEmpty(lista2))
return lista1;
else if (lista1->head < lista2->head)
return prepend(lista1->head, interleave(lista1->tail, lista2));
else
return prepend(lista2->head, interleave(lista1, lista2->tail));
}
</pre>

11. Dându-se o listă și o valoare, să se separe în trei liste, una cu elementele mai mici, una cu elementele egale și una cu valoarea dată.
<pre>
template<class Type>
class Tuple3 {
public:
Type first;
Type second;
Type third;

Tuple3(Type first, Type second, Type third) :
first(first), second(second), third(third) {
;
}
};

Tuple3<const Nod* const> split(const int valoare, const Nod* const lista) {
if (isEmpty(lista))
return Tuple3<const Nod* const>(
emptyList(), emptyList(), emptyList());
else {
Tuple3<const Nod* const> impart = split(valoare, lista->tail);
if (lista->head < valoare)
return Tuple3<const Nod* const>(
prepend(lista->head, impart.first),
impart.second,
impart.third);
else if (lista->head == valoare)
return Tuple3<const Nod* const>(
impart.first,
prepend(lista->head, impart.second),
impart.third);
else
return Tuple3<const Nod* const>(
impart.first,
impart.second,
prepend(lista->head, impart.third));
}
}
</pre>

12. Dându-se două liste, să se obțină o listă nouă, cu elementele primeia înalintea elementelor celei de-a doua.
<pre>
const Nod* const concat(const Nod* const lista1, const Nod* const lista2) {
if (isEmpty(lista1))
return lista2;
else
return prepend(lista1->head, concat(lista1->tail, lista2));
}
</pre>

13. Dându-se o listă, să se obțină o nouă listă cu elementele primeia sortate folosind algoritmul Merge Sort.
<pre>
const Nod* const mergeSort(const Nod* const lista) {
if (isEmpty(lista) || isEmpty(lista->tail))
return lista;
else
return interleave(
mergeSort(oddElements(lista)),
mergeSort(evenElements(lista)));
}
</pre>

14. Dându-se o listă, să se obțină o nouă listă cu elementele primeia sortate folosind algoritmul Quick Sort.
<pre>
const Nod* const quickSort(const Nod* const lista) {
if(isEmpty(lista))
return emptyList();
else {
Tuple3<const Nod* const> imp = split(pivot(lista), lista);
if (isEmpty(imp.first) && isEmpty(imp.third))
return imp.second;
else
return concat(
concat(
quickSort(imp.first),
quickSort(imp.second)),
quickSort(imp.third));
}
}
</pre>

15. Să se testeze funcțiile implementate anterior.
<pre>
int main() {
print(quickSort(prepend(4, prepend(6, prepend(7, prepend(5, prepend(1, prepend(8, emptyList()))))))));
printf("\n");
print(mergeSort(prepend(4, prepend(6, prepend(7, prepend(5, prepend(1, prepend(8, emptyList()))))))));
return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 12 iunie 2015

2015-06-14T13:15:13Z

Dan:

În acest curs am prezentat structura de date numită Treap. Aceasta este o combinație între un arbore binar de căutare și un heap. Fiecare nod conține două informații: o valoare și o cheie (generată aleator) și, bineînțeles adresele fiului stâng și fiului drept. Pe baza acestor două informații, treap-ul are structura unui arbore binar de căutare în funcție de valorile nodurilor și, în același timp, structura unui heap în funcție de cheile nodurilor.

O observație interesantă este aceea că pentru o listă dată de perechi (valoare, cheie) există un treap și numai unul. Pe baza acestei demonstrații se poate demonstra că, dacă cheile sunt alese aleator, atunci adâncimea maximă a unui treap cu N noduri, pe cazul mediu (''expected value'') va fi '''O(log N)'''.

În continuare avem implementarea operațiilor de inserare și ștergere pe un treap persistent implementat în paradigma programării funcționale.

== Definirea nodului treap-ului==
Vom începe prin crearea unei clase pentru nodurile treap-urilor:

<pre>
#include <cstdio>
#include <cstdlib>
#include <ctime>

class Node {
public:
const Node* const left;
const Node* const right;
const int value;
const long long key;

Node(const Node* const left, const Node* const right,
const int value, const long long key) :
left(left),
right(right),
value(value),
key(key) {
;
}
};
</pre>

Pentru simplificarea implementării, vom defini un nod santinelă care să joace rolul de fiu al nodurilor care nu au unul din fii sau ambii fii.

<pre>
const Node* const NIL = new Node(NULL, NULL, 0, -1);
</pre>

== Definirea treap-ului ==

Singura informație conținută într-un treap va fi un pointer către nodul rădăcină.

<pre>
class Treap {
const Node* root;

Treap(const Node* const root) :
root(root) {
;
}
</pre>

== Implementarea operațiilor elementare ==
Pentru inserarea unei valori noi va trebui să avem posiblitatea creării unui nod nou cu o valoare dată și o cheie aleasă aleator.

<pre>
const Node* const createNode(const int value) const {
return new Node(
NIL,
NIL,
value,
(long long)rand() | ((long long)rand() << 31));
}
</pre>

Pentru a menține proprietatea de heap a treap-ului și, în consecință, pentru a-l echilibra, va trebui să avem la dispoziție operațiile de rotire la dreapta și la stânga:

<pre>
const Node* const rotateRight(const Node* const root) const {
const Node* const A = root->left;
const Node* const B = root;
const Node* const b = A->right;
return new Node(
A->left,
new Node(
b,
B->right,
B->value,
B->key),
A->value,
A->key);
}

const Node* const rotateLeft(const Node* const root) const {
const Node* const A = root;
const Node* const B = root->right;
const Node* const b = B->left;
return new Node(
new Node(
A->left,
b,
A->value,
A->key),
B->right,
B->value,
B->key);
}
</pre>

== Implementarea inserării ==
Acum putem implementa inserarea. Am ales o implementare recursivă: se inserează un nod deja creeat (''value'') într-un subarbore al treap-ului dat prin nodul său rădăcină (''root'').

Se disting 3 cazuri:
* Se inserează un nod într-un subarbore vid: rezultatul este noul nod;
* Se inserează un nod cu o valoare mai mică decât valoarea rădăcinii subarborelui: se inserează noul nod în fiul stâng al subarborelui;
* Se inserează un nod cu o valoare mai mare sau egală cu valoarea rădăcinii subarborelui: se inserează noul nod în fiul drept al subarborelui.

În ultimele două cazuri, după efectuarea inserăii trebuie avut grijă ca proprietarea de heap să se conserve. Iar dacă nu se conservă, trebuie efectuată una dintre rotații, după caz.
<pre>
const Node* const insert(const Node* const root, const Node* const value) const {
if (root == NIL) {
return value;
} else if (value->value < root->value) {
const Node* const newNode = new Node(
this->insert(root->left, value),
root->right,
root->value,
root->key);
if (newNode->key < newNode->left->key) {
return this->rotateRight(newNode);
} else {
return newNode;
}
} else {
const Node* const newNode = new Node(
root->left,
this->insert(root->right, value),
root->value,
root->key);
if (newNode->key < newNode->right->key) {
return this->rotateLeft(newNode);
} else {
return newNode;
}
}
}
</pre>

== Implementarea ștergerii ==
În continuare vom implementa șteregrea în mod recursiv: se caută nodul care trebuie șters și, odată găsit se disting 2 cazuri:
* nodul este frunză: se înlocuiește cu noul santinelă;
* nodul nu este frunză: se efectuează una dintre rotații, astfel încât fiul cu cheia mai mare să devină rădăcină iar nodul se șterge recusiv din noul fiu corespunzător.

<pre>
const Node* const erase(const Node* const root, int value) const {
if (root != NIL) {
if (value == root->value) {
if (root->left == NIL && root->right == NIL) {
return NIL;
} else {
if (root->left->key > root->right->key) {
const Node* const newRoot = rotateRight(root);
return new Node(
newRoot->left,
erase(newRoot->right, value),
newRoot->value,
newRoot->key);
} else {
const Node* const newRoot = rotateLeft(root);
return new Node(
erase(newRoot->left, value),
newRoot->right,
newRoot->value,
newRoot->key);
}
}
} else if (value < root->value) {
return new Node(
this->erase(root->left, value),
root->right,
root->value,
root->key);
} else { // root->value < value
return new Node(
root->left,
this->erase(root->right, value),
root->value,
root->key);
}
}
return NIL;
}
</pre>

== Afișarea structurii de date ==
Pentru a putea verifica corectitudinea implementării și pentru a putea identifica mai ușor eventualele greșeli de implementare, se recomandă implementarea unei funcții (recursive) care să afișeze structura treap-ului.

Parametrul ''offset'' are rolul de a stoca adâncimea nodului ''root'' pentru a putea afișa nodurile in mod indentat. Treap-ul va fi parcurs și afișat în inordine iar pentru un nod se vor afișa valoarea și cheia sa.

<pre>
void dump(const Node* const root, int offset = 0) const {
if (root != NIL) {
this->dump(root->left, offset + 1);
for (int i = 0; i < offset; ++i) {
printf(" ");
}
printf("%d\t %20lld\n", root->value, root->key);
this->dump(root->right, offset + 1);
}
}
</pre>

== Funcțiile publice ale treap-ului ==
Pentru a definitiva clasa Treap, vom implementa constructorul fără parametri (care creează un treap gol), funcțiile insert și erase (care realizează inserarea și ștergerea) și funcția dump (care afișează structura treap-ului).
<pre>
public:
Treap() {
this->root = NIL;
}

Treap* insert(int value) const {
return new Treap(this->insert(this->root, this->createNode(value)));
}

Treap* erase(int value) const {
return new Treap(this->erase(this->root, value));
}

void dump() const {
this->dump(this->root);
printf("\n");
}
};
</pre>

== Testarea implementării ==
Îm încheiere avem un cod de testare a funcțiilor structurii de date, care creează un treap gol, inserează în el 7 valori distincte și apoi șterge una dintre ele. În final, sunt afișate toate versiunile de treap create anterior, pentru a se putea verifica dacă operațiile sunt efectuate corect și dacă toate versiunile sunt stocate în memorie.

<pre>
int main() {
srand(time(NULL));

const Treap* const t0 = new Treap();
const Treap* const t1 = t0->insert(4);
const Treap* const t2 = t1->insert(2);
const Treap* const t3 = t2->insert(7);
const Treap* const t4 = t3->insert(9);
const Treap* const t5 = t4->insert(3);
const Treap* const t6 = t5->insert(5);
const Treap* const t7 = t6->insert(6);
const Treap* const t8 = t7->erase(6);

t0->dump();
t1->dump();
t2->dump();
t3->dump();
t4->dump();
t5->dump();
t6->dump();
t7->dump();
t8->dump();
return 0;
}
</pre>

Note de curs, probleme algoritmică, clasa IX/X, 5 iunie 2015

2015-06-14T09:56:33Z

Dan: Created page with "În acest curs am discutat problemele: * [http://acm.timus.ru/problem.aspx?space=1&num=1252 1252 - Sorting the Tombstones]; * [http://acm.timus.ru/problem.aspx?space=1&num=13..."

În acest curs am discutat problemele:

* [http://acm.timus.ru/problem.aspx?space=1&num=1252 1252 - Sorting the Tombstones];
* [http://acm.timus.ru/problem.aspx?space=1&num=1316 1316 - Electronic Auction].

Cercul de informatică, probleme algoritmică, liceul Tudor Vianu, clasa IX/X, anul 2014-2015

2015-06-14T09:53:37Z

Dan:

În continuare se regăsesc rezumatele cursurilor.

Semestrul I:
* [[Note de curs, probleme algoritmică, clasa IX/X, 3 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 10 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 24 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 31 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 7 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 14 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 28 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 5 decembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 12 decembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 16 ianuarie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 23 ianuarie 2015]]

Semestrul al II-lea:
* [[Note de curs, probleme algoritmică, clasa IX/X, 13 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 20 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 27 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 13 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 20 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 27 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 24 aprilie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 8 mai 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 5 iunie 2015]]
* [[Note de curs, probleme algoritmică, clasa IX/X, 12 iunie 2015]]

Note de curs, probleme algoritmică, clasa XI/XII, 12 iunie 2015

2015-06-14T09:51:43Z

Dan: Created page with "În acest curs am discutat problemele: * [http://www.infoarena.ro/problema/zidar Zidar]; * [http://www.infoarena.ro/problema/taxa Taxa]; * [http://www.infoarena.ro/problema/c..."

În acest curs am discutat problemele:

* [http://www.infoarena.ro/problema/zidar Zidar];
* [http://www.infoarena.ro/problema/taxa Taxa];
* [http://www.infoarena.ro/problema/cumpanit Cumpanit];
* [http://www.infoarena.ro/problema/ydist Ydist].

Cercul de informatică, probleme algoritmică, liceul Tudor Vianu, clasa XI/XII, anul 2014-2015

2015-06-14T09:46:43Z

Dan:

În continuare se regăsesc rezumatele cursurilor.

Semestrul I:
* [[Note de curs, probleme algoritmică, clasa XI/XII, 19 septembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 3 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 10 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 24 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 31 octombrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 7 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 14 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 28 noiembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 5 decembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 12 decembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 19 decembrie 2014]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 9 ianuarie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 16 ianuarie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 23 ianuarie 2015]]

Semestrul al II-lea:
* [[Note de curs, probleme algoritmică, clasa XI/XII, 13 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 20 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 27 februarie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 13 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 20 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 27 martie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 24 aprilie 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 8 mai 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 15 mai 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 22 mai 2015]]
* [[Note de curs, probleme algoritmică, clasa XI/XII, 12 iunie 2015]]

Note de curs, probleme algoritmică, clasa IX/X, 8 mai 2015

2015-05-25T00:39:16Z

Dan: Created page with "În acest curs am discutat probleme de la barajul din 2010: * [http://www.infoarena.ro/problema/permutare Permutare]; * [http://www.infoarena.ro/problema/nuke Nuke]."

În acest curs am discutat probleme de la barajul din 2010:

* [http://www.infoarena.ro/problema/permutare Permutare];
* [http://www.infoarena.ro/problema/nuke Nuke].