#include<iostream>

/// PAGE 1

#include<fstream>
using namespace std;

/// PROMBLEMA 1 => CERINTA: Aflati secventa de suma maxima dintr-un vector de
numere intregi si determinati indicii de inceput si final ai acesteia.
ifstream fin("ssmax.in");
ofstream fout("ssmax.out");
int main ()
{
int smax,s,i,n,a[100],st,dr,x,y;
fin>>n;
for (i=1;i<=n;i++)
fin>>a[i];
s=a[1]; st=1; dr=1;

/// citire
/// initializari

if (s<0) s=0;
else

smax=s;

/// st si dr sunt auxiliare , iar x

si y mentin solutiile

for (i=2;i<=n;i++)
{
s+=a[i];
if (s>smax)
{ smax=s; x=st; y=i; }
if (s<0)
{ s=0; st=i+1; dr=i+1; }
}
fout<<"secventa de suma maxima este "<<smax;
fout<<" iar aceasta incepe cu termenul al "<<x<<"-lea"<<" si se termina cu
termenul al "<<y<<"-lea.";
fin.close();
fout.close();
return 0;}

#include<iostream>

/// PAGE 2

#include<fstream>
using namespace std;

/// PROMBLEMA 2 => CERINTA: Determina daca o secventa are un element

majoritar si afiseaza de cate ori apare acest in cadrul secventei.
ifstream fin("el-maj.in"); ofstream fout("el-maj.out");
int main ()
{

int a[100],i,n,k,cnt,x;
fin>>n;
for (i=1;i<=n;i++)
fin>>a[i];
cnt=1; x=a[1];

/// initializari

for (i=2;i<=n;i++)
{
if (a[i]==x) cnt++;
else

cnt--;

if (cnt<0)

x=a[i];

}
k=0;
for (i=1;i<=n;i++)
if (x==a[i])

k++;

if (k>=n/2+1)
fout<<"in aceasta serie exista un element majoritar, "<<x<<", si
apare de "<<k<<" ori"<<endl;
else
fout<<"in aceasta serie nu exista un element majoritar, dar
exista un element mai/la fel de frecvent decat majoritatea, "<<x<<", si apare de
"<<k<<" ori"<<endl;
fin.close();
fout.close();
return 0;
}

#include<iostream>

/// PAGE 3

#include<fstream>
using namespace std;
#define Nmax 30000

/// PROMBLEMA 3 => CERINTA: Construiti un vector de numere natural cu primele

30000 numere naturale prime pintr-o metoda eficienta din punct de vedere al
timpului de executie.
ifstream fin("eratosthene.in"); ofstream fout("eratosthene.out");
int main ()
{

int a[Nmax],ok,i,j,k,prime[Nmax],n;
/// Vom folosi metoda Ciurului lui Erathostene, cunoscuta inca din antichitate
for (i=1;i<=Nmax;i++)
a[i]=0;

/// a[i]=0 daca i e prim, si a[i]=1 daca i nu e prim;

for (i=3;i<=Nmax;i=i+2)
{

if (a[i]==0)
{

for (j=i*i;j<=Nmax;j=j+i*2)

a[j]=1; }

}
k=0; prime[++k]=2;
for (i=3;i<=Nmax;i=i+2)
if (a[i]==0)

prime[++k]=i;

n=k;
fout<<"Numerele prime mai mici ca 30000 sunt:"<<endl;
for (i=1;i<=n;i++)
{
fout<<prime[i]<<" ";
if (i%10==0) fout<<endl;
}
fin.close();
fout.close();
return 0;
}

#include<iostream>
#include<fstream>

/// PAGE 4

using namespace std;

/// PROMBLEMA 4 => CERINTA: Din fisierul de intrare se citesc perechi n de

numere de forma x si y. Calculati pentru fiecare pereche cel mai mare divisor
comun printr-o metoda eficienta din punct de vedere al timpului de executie.
ifstream fin ("euclid.in");
ofstream fout("euclid.out");
int main ()
{
int n,i,r,a,b,x,y;
fin>>n;
for (i=1;i<=n;i++)
{
fin>>x>>y;
a=x; b=y;
/// Vom folosi binecunoscutul algoritm al lui Euclid
while (b!=0)
{
r=a%b;
a=b;
b=r;
}
fout<<a<<"\n";
}
fin.close();
fout.close();
return 0;
}

Numele problemei: diferenta ; Sursa: Olimpiada de Informatica Iasi 2015

/// PAGE 5

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1638
Marius este pasionat de ptrate perfecte. ntr-o matrice T cu n linii i m coloane, Marius a scris numere naturale
nenule. Apoi construiete o alt matrice NR, tot cu n linii i m coloane. Elementul NR[i][j] = numrul de perechi de
ptrate perfecte a cror diferen este egal cu T[i][j] (1in, 1jm).
1 n 100
1 m 100
Numerele din matricea T sunt numere naturale nenule 40000.
Cunoscndu-se numerele n, m i matricea T, s se afieze matricea NR, printr-o metoda eficienta din punct de
vedere al memoriei folosite si a timpului de executie a programului.
#include<fstream>
#include<algorithm>
#include<iostream>
using namespace std;
int patrate[20005], n, m, v[40005];
void Patrate()
{
int i;
for (i=1;i<=20001;i++)
patrate[i]=i*i;
}
int NrPerechi(int dif)
{
int i, j, cnt, x;
cnt = 0;
i = 0; j = 1;
while ( patrate[j]-patrate[j-1] <= dif)
{
x = patrate[j]-patrate[i];
if (x==dif)
{ cnt++; i++; j++;}
else
if (x<dif) j++;

else i++;
}
return cnt;
}
void CitireAfisare()
{ int i, j, x, y;
ifstream fin ("diferenta.in");
ofstream fout ("diferenta.out");
fin>>n>>m;
for (i=1;i<=n;i++)
{ for (j=1;j<=m;j++)
{

fin>>x;
if (v[x] == 0)

{
y=NrPerechi(x); v[x] = y;
}
else y = v[x];
fout<<y<<" ";
}
fout<<"\n";
}
fin.close(); fout.close();
}
int main()
{
Patrate();
CitireAfisare();
return 0;
}

/// PAGE 6

Numele problemei: gradina ; Sursa: ONI 2013

/// PAGE 7

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1530
Pcal a reuit s duc la bun sfrit nelegerea cu boierul cruia-i fusese slug i, conform nvoielii, boierul trebuie
s-l rsplteasc dndu-i o parte din livada sa cu pomi fructiferi. Boierul este un om foarte ordonat, aa c livada sa
este un ptrat cu latura de N metri unde, pe vremuri, fuseser plantate N rnduri cu cte N pomi fiecare. Orice pom
fructifer putea fi identificat cunoscnd numrul rndului pe care se afl i poziia sa n cadrul rndului respectiv. Cu
timpul, unii pomi s-au uscat i acum mai sunt doar P pomi. Pcal trebuie s-i delimiteze n livad o grdin ptrat
cu latura de K metri. Cunoscnd dimensiunile livezii i grdinii, numrul pomilor din livad i poziia fiecruia,
determinai numrul maxim de pomi dintr-o grdin ptrat de latur K i numrul modurilor n care poate fi
amplasat grdina cu numrul maxim de pomi.
#include<fstream>
#include<algorithm>
using namespace std;
ifstream fin("gradina1.in");
ofstream fout("gradina1.out");
int a[1001][1001],s[1001][1001];
int k,ka,n,lin,col,x,maxim,i,j,p;
void Citire()
{
in>>n>>p>>k;
for (i=1; i<=p; i++)
{
in>>lin>>col;
a[lin][col]=1;
}
}
void Rezolva1()
{
s[1][1]=a[1][1];
for (i=2; i<=n; i++)
s[i][1]=s[i-1][1]+a[i][1];
for (i=2; i<=n; i++)
s[1][i]=s[1][i-1]+a[1][i];

for (i=2; i<=n; i++)

for (j=2; j<=n; j++)
s[i][j]=s[i][j-1]+s[i-1][j]+a[i][j]-s[i-1][j-1];
}
void Rezolva2()
{
maxim=-1;
ka=0;
for (i=k; i<=n; i++)
for (j=k; j<=n; j++)
{
x=s[i][j]-s[i-k][j]-s[i][j-k]+s[i-k][j-k];
if (maxim==x) ka++;
else if (maxim<x)
{
ka=1;
maxim=x;
}
}
}

void Afisare()

{ fout<<maxim<<"\n"<<ka; }
int main ()
{
Citire();
Rezolva1();
Rezolva2();
Afisare();
fin.close(); fout.close();
return 0; }

/// PAGE 8

Numele problemei: matrixel ; Sursa: XOR Vaslui 2013

/// PAGE 9

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1474
Fie o matrice de numere naturale cu L linii numerotate de la 1 la L i C coloane numerotate de la 1 la C. Din aceast
matrice se elimin P linii i Q coloane. S se afieze matricea rmas dup tergerea liniilor i coloanelor.
#include<fstream>
using namespace std;
ifstream fin("matrixdel.in");
ofstream fout("matrixdel.out");
int main ()
{
int L,C,P,Q,c,i,j,linie,coloana,a[101][101],k;
fin>>L; fin>>C;
for (i=1;i<=L;i++)
for (j=1;j<=C;j++)
fin>>a[i][j];
fin>>P;

// liniile care se sterg

for (c=1;c<=P;c++)
{
fin>>linie;
for (i=1;i<=C;i++)
a[linie][i]=-1;
}
in>>Q;
for (c=1;c<=Q;c++)

// coloanele care se sterg

{
fin>>coloana;
for (i=1;i<=L;i++)
a[i][coloana]=-1;
}
for (i=1;i<=L;i++)

/// PAGE 10
k=0;
for (j=1;j<=C;j++)
{

if (a[i][j]!=-1)
{ fout<<a[i][j]<<" ";
k++;
}

}
if (k!=0)

fout<<"\n";

}
fin.close();
fout.close();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
Nume problema: sirul; Sursa: OJI 2003;
Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=916
S considerm urmtorul ir:
a, b, ba, bab, babba, babbabab, ...

Cerin: Scriei un program care s determine care este cel de-al n-lea termen al irului. Se citeste n-ul dintr-un
fisier.
#include<fstream>
#include<cstdio>
#include<cstring>
using namespace std;
ifstream fin("sirul.in");
ofstream fout("sirul.out");
int main ()
{ int n,i;
fin>>n;

char x[150],y[150],aux[150];

/// PAGE 11

x[0]='a'; x[1]=0; /// initilizari

y[0]='b'; y[1]=0; /// initializari
if (n==1) fout<<x;

/// cazuri particulare

if (n==2) fout<<y;

/// cazuri particulare

else
{
for (i=3;i<=n;i++)
{
strcpy(aux,y); /// aux = b
strcat(y,x);

/// y = ba

strcpy(x,aux); /// x = b
}
}

fout<<y<<"\n";

fin.close();
fout.close();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
Numele problemei: ucif; Sursa: OJI 2005;
Fie n un numr natural i s suma urmtoare:
s = 11+ 22 + 33 + + nn
Cerin: Scriei un program care s afieze ultima cifr a lui s.
#include<fstream>
using namespace std;
ifstream fin("ucif.in");
ofstream fout("ucif.out");
int main ()
{
int s,n,i,a,aux,j;
fin>>n; s=0;

for (i=1;i<=n;i++)
{
a=i%10; aux=1;
for (j=1;j<=i;j++)
{
aux=(aux*a)%10;
}
s=s+aux;
}

/// PAGE 12

fout<<s%10;
fin.close();
fout.close();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////

Numele problemei: figura; Sursa: ONIG 2010;

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1035
Dintr-o foaie de matematic pe care se afl DxD ptrele aranjate n D linii i D coloane a fost decupat o figur.
Figura decupat este compact (nu are guri) i este format din N ptrele de pe foaie.

Cerin: Scriei un program care s determine perimetrul figurii decupate.

#include<fstream>
using namespace std;
ifstream fin("figura.in");
ofstream fout("figura.out");
int a[22][22];
int main ()
{
int D,n,P,i,y,x,j;
fin>>D; fin>>n; P=0;
for (i=1;i<=n;i++)
{ in>>y; in>>x;
a[y+1][x+1]=1;}
for (i=1;i<=D+2;i++)
{
for (j=1;j<=D+2;j++)
{
if (a[i][j]==1)
{
if (a[i-1][j]==0)
P++;
if (a[i+1][j]==0)
P++;
if (a[i][j-1]==0)
P++;
if (a[i][j+1]==0)
P++;
}
}
}
fout<<P;
fin.close();
fout.close();
return 0;
}

Numele problemei: ecp; Sursa: XOR 2015

/// PAGE 13

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1624
O expresie corect parantezat (prescurtat ecp) este un sir format din caracterele (,),[,],{,} si care se formeaz dup
urmtoarele reguli:

(), [],{} sunt ecp

dac A este ecp, atunci (A), [A] si {A} sunt ecp

dac A si B sunt ecp, atunci AB este ecp

Exemple de ecp: ({}{}[(())]), ((([]))), {({()}[])}. Exemple de siruri care nu sunt ecp: ([]], {(}). Costul unei ecp
se calculeaz astfel:

() este o ecp de cost 2

[] este o ecp de cost 3

{} este o ecp de cost 5

dac A este ecp de cost k, atunci (A) are costul 22*k, [A] are costul 33*k, iar {A} are costul 55*k

dac A si B sunt ecp de costuri k si p, atunci expresia AB este o ecp de cost k*p.

De exemplu, costul expresiei ()[(()){}()] este 2*33*(22*(2)*5*2)=25*33*51=4320.

Cerin: Dndu-se o expresie correct parantezata, s se determine costul acesteia.

#include <fstream>
using namespace std;
int main()
{
int doi,trei,cinci;
char a[1001];
int i,n;
ifstream fin("ecp.in");
fin>>a;
doi=trei=cinci=0;
for (i=0;a[i+1]!=0;i++)
{
if (a[i]=='(' && a[i+1]!=')')
doi=doi+2;
else if (a[i]=='(')
doi++;
if (a[i]=='[' && a[i+1]!=']')
trei=trei+3;
else if (a[i]=='[')
trei++;
if (a[i]=='{' && a[i+1]!='}')
cinci=cinci+5;
else if (a[i]=='{')
cinci++;
}

ofstream fout("ecp.out");
fout << doi << " " << trei << " " << cinci<< "\n";
fout.close();
return 0;
}
Numele problemei: foto; Sursa: OMI Iasi 2014
///PAGE 14
Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1574
#include <fstream>
#include <algorithm>
using namespace std;
int a[105][105], n, m, cnt, cntmax;
void Citire()
{ int i, j;
ifstream fin ("foto.in");
fin>>n>>m;
for (i=1;i<=n;i++)
for (j=1;j<=m;j++)
fin>>a[i][j];
fin.close();
}
// bordeaza cu 1 matricea a
void Bordare()
{
int i;
for (i=0;i<=m+1;i++)
a[0][i]=a[n+1][i]=1;
for (i=0;i<=n+1;i++)
a[i][0]=a[i][m+1]=1;
}
void Fill(int i, int j)
{
if (a[i][j] == 0)
{
cnt++;
a[i][j] = 1;
Fill (i+1, j);
Fill(i-1, j);
Fill (i, j+1);
Fill (i, j - 1);
}
}
void CalculZerouri()
{
int i, j;
cntmax = 0;
for (i=1; i <= n; i++)
for (j = 1; j <= m; j++)
if (a[i][j] == 0)
{
cnt = 0;
Fill (i, j);
cntmax=max(cntmax,cnt);
}
ofstream fout("foto.out");
fout<<cntmax<<"\n";
fout.close();
}
int main()
{
Citire();
Bordare();
CalculZerouri();

return 0;

Numele problemei: pizza; Sursa: .campion 2007

/// PAGE 15
Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=160
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
ifstream fin("pizza.in");
ofstream fout("pizza.out");
int main ()
{
int i,n,x,y,k1,k2,k3,transport,r;
char x1,zero,y2;
in>>n; k1=0;k2=0;k3=0;
transport=0;
for (i=1;i<=n;i++)
{
fin>>x1; fin>>zero; fin>>y2;
x=x1-'0'; y=y2-'0';
if (x==1&&y==2)
k1++;
if (x==1&&y==4)
k2++;
if (x==3&&y==4)
k3++;
}
n=0;
if (k1%2==0) n=n+k1/2;
else
{
n=n+k1/2; transport=1; // ramane jumatate }
if (k2>k3)
// au aparut k3 pizza si raman de grupat k2-k3 sferturi
{
if (transport==0)
{
n=n+k3;
r=(k2-k3)%4;
if (r==0) n=n+(k2-k3)/4;
else n=n+(k2-k3)/4+1;
}
if (transport==1)
{
n=n+k3;
r=(k2-k3)%4;
if (r==0) n=n+(k2-k3)/4+1;
else if (r==1 || r==2) n=n+(k2-k3)/4+1;
else n=n+(k2-k3)/4+2;
}
}
if (k2==k3)
{
n=n+k3;
if (transport==1)
n++;
}
if (k3>k2)
{
if (transport==0)
n=n+k3;
else

n=n+k3+1;
}
fout<<n<<"\n";
fin.close();
fout.close();
return 0;
}

Numele problemei: text; Sursa: OJI 2010;

/// PAGE 16

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1082
#include <fstream>
#include <cstring>
using namespace std;
char cuv[20001][22];
int d[20001], urm[20001], n;
int t[30];
// t[ch]=p: pozitia p in cuv a cuvantului care incepe cu litera // ch si care are d[p]
maxim
void Citire()
{
ifstream fin ("text3.in");
n=1;
while (fin>>cuv[n])
n++;
n--;
fin.close();
}
void LIS()
{
int i, maxim, poz, j, p;
char ch;
d[n] = 1;
urm[n] = n+1;
p = cuv[n][0] - 'a';
t[p] = n;
for (i = n - 1; i >= 1; i--)
{
ch = cuv[i][strlen(cuv[i]) - 1];
maxim = 0;
j = ch - 'a';
poz = t[j];
if (poz == 0) {d[i] = 1; urm[i] = n + 1;}
else { d[i] = 1 + d[poz]; urm[i] = poz; }
j = cuv[i][0] - 'a';
if (d[i] > d[t[j]]) t[j] = i;
}
}
void Afisare()
{
int i, m, poz;
ofstream fout("text3.out");
fout << n << "\n";
m = d[1]; poz = 1;
for (i = 2; i <= n; i++)
if (d[i] > m) {m = d[i]; poz = i;}
fout << (n - m) << "\n";
while (poz != n + 1)
{
fout << cuv[poz] << "\n";
poz = urm[poz];
}

fout.close();}
int main()
{
Citire();
LIS();
Afisare();
return 0;
}
Numele problemei: dir; Sursa: OJI 2007;
/// PAGE 17
Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=839
#include<fstream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[1605], st[1002][35], f[102][260];
int n;
void SortareLexico()
{
int i,j;
char aux[260];
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++)
{
if (strcmp(f[j],f[i]) > 0)
/// se face interschimbare
{
strcpy (aux, f[i]);
strcpy (f[i],f[j]);
strcpy (f[j], aux);
}
}
}
}
void Afisare()
{
int i;
ofstream fout("dir.out");
fout<<n<<"\n";
for (i=1;i<=n;i++)
fout<<f[i]<<"\n";
/// lets count
fout.close();
}
int main()
{
int top, k, i,j;
char folder[35];
char fisier[35];
char cale[260];
ifstream fin("dir.in");
fin >> s;
top = 0;
for (i = 0; s[i] != 0; )
{
if ('A'<= s[i] && s[i] <= 'Z')
{
k = 0;
while (s[i] != 0 && s[i] != ')' && s[i] != '(' && s[i] !=
',')

{
folder[k++] = s[i];
i++;
}
folder[k] = 0;
top++;
strcpy(st[top],folder);
}
else if ('a'<= s[i] && s[i] <= 'z')

/// PAGE 18

{
k = 0;
while (s[i] != 0 && s[i] != ')' && s[i] != '(' && s[i] !=
',')
{
fisier[k++] = s[i];
i++;
}
fisier[k] = 0;
//st=F1, F2, F3
strcpy(cale,st[1]);
strcat(cale,"\\");
for (j = 2;j<=top; j++)
{
strcat(cale,st[j]);
strcat(cale,"\\");
}
strcat(cale,fisier);
n++;
strcpy(f[n],cale);
}
else if (s[i] == '(') i++;
else if (s[i] == ',') i++;
else if (s[i] == ')')
{
i++;
top--;
}
}
SortareLexico();
Afisare();
/// f=matricea care retine totu bine
/// hai sa o sortam
return 0;
}
////////////////////////////////////////////////////////////////////////////////////
Numele problemei: vistiernic; Sursa: OMI Iasi 2013
Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1487
#include<fstream>
using namespace std;
ifstream fin("vistiernic.in");
ofstream fout("vistiernic.out");
int main()
{
int n,k,i,nr,t;
fin>>n;k =0; t=0;
for(i=1;i<=n;i++)
{
fin>>nr;
while((nr%5==0)||(nr%2==0))
{if(nr%5==0)
{ nr=nr/5; k++; }

if(nr%2==0)
nr=nr/2; t++; } }

}
if(t>=k) fout<<k;
else
fout<<t;
fin.close();
fout.close();
return 0; }
Numele problemei: parantezare; Sursa: FMI No Stress 2012
Link:

http://www.infoarena.ro/problema/parantezare

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string.h>
using namespace std;
int n,vect[100005],aux,q[100005],i,j,k,aux2,len,cnt,cap;
char a[100005];
ifstream fin("parantezare.in");
ofstream fout("parantezare.out");
void Citire()
{
fin>>a; fin>>n;
}
void Afisare()
{
for (i=1;i<=n;i++)
{
in>>aux2;
fout<<q[aux2]<<" ";
}
fin.close();
fout.close();
}
void Rezolva ()
{
len=strlen(a);
cap=0;
for (i=0;i<=len-1;i++)
{
if (a[i]=='(')
{
vect[++cap]=i;
}
else if (a[i]==')')
{
aux=vect[cap];
q[aux]=i;
cap--;
}
}
}
int main()
{
Citire();
Rezolva();

/// PAGE 19

Afisare();
return 0;
}

Numele problemei: muzeu; Sursa: Happy Coding 1

Link: http://www.infoarena.ro/problema/muzeu

#include <fstream>
#include <queue>
using namespace std;
struct coord
{
int x,y;
};
queue <coord> q;
char a[255][255];
int b[254][254], n;
void Citire()
{
ifstream fin("muzeu.in");
int i;
fin>>n;
fin.get();
for (i=1;i<=n;i++)
fin.getline(a[i]+1, 252);
fin.close();
}
void Bordare()
{
int i;
for (i=0; i<=n+1; i++)
a[i][0]=a[0][i]=a[n+1][i]=a[i][n+1]='#';
}
void Lee()
{
int i,j;
coord w, w1;
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
if (a[i][j] == '#') b[i][j] = -2;
else if (a[i][j] == '.') b[i][j] = -1;
else // a[i][j] == 'P'
{
b[i][j]=0;

/// PAGE 20

w.x = i; w.y = j;
q.push(w);
}
while (!q.empty())
{
w = q.front();
q.pop();
/// PAGE 21
for (i=0;i<4;i++)
{
w1.x=w.x+dx[i];
w1.y=w.y+dy[i];
if (a[w1.x][w1.y] != '#' && (b[w1.x][w1.y] > b[w.x][w.y]+ 1 ||
b[w1.x][w1.y] == -1))
{
b[w1.x][w1.y] = b[w.x][w.y]+ 1;
q.push(w1);
}
}
}
}
void Afisare()
{
ofstream out("muzeu.out");
int i,j;
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++)
{
out<<b[i][j]<<" ";
}
out<<"\n";
}
out.close();
}
int main ()
{
Citire();
Bordare();
Lee();
Afisare();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
Numele problemei: palindrom; Sursa: Grigore Moisil 2009 Clasele 5-8
Link: http://www.infoarena.ro/problema/palindrom2

Se consider un ir de caractere format din litere mici ale alfabetului englez. Transformai
irul ntr-un palindrom de lungime minim prin inserarea de caractere doar la sfritul irului.
Lungimea irului este cel mult 1 000.
Exemplu: aabac

-> aabacabaa;

#include<fstream>

#include<cstring>
#include<iostream>
using namespace std;
ifstream fin ("palindrom2.in");
ofstream fout ("palindrom2.out");
int main ()
{
int n,i,j,st,dr;
int ok,gasit;
char s[1000];

/// PAGE 22

fin>>s;
n=strlen(s);
gasit=0;
for (i=0;i<n && gasit==0;i++)
{
st=i;dr=n-1;
ok=1;
while (st<=dr && ok==1)
{
if (s[st]==s[dr])
{ st++; dr--; }
else
ok=0;
}
}

if (ok==1) gasit=1;

fout<<s;
for (j=i-2;j>=0;j--)
fout<<s[j];
fout<<"\n";
fin.close();
fout.close();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
Numele problemei: lacusta; Sursa: OJI 2005 Clasa a X a
Link: http://www.infoarena.ro/problema/lacusta
Se considera o matrice dreptunghiulara cu m linii si n coloane, cu valori naturale. Traversam matricea
pornind de la coltul stanga-sus la coltul dreapta-jos. O traversare consta in mai multe deplasari. La
fiecare deplasare se executa un salt pe orizontala si un pas pe verticala. Un salt inseamna ca putem
trece de la o celula la oricare alta aflata pe aceeasi linie, iar un pas inseamna ca putem trece de la o
celula la celula aflata imediat sub ea. Exceptie face ultima deplasare (cea in care ne aflam pe ultima
linie), cand vom face doar un salt pentru a ajunge in coltul dreapta-jos, dar nu vom mai face si pasul
corespunzator. Astfel traversarea va consta din vizitarea a 2m celule. Scrieti un program care sa
determine suma minima care se poate obtine pentru o astfel de traversare.
Exemplu: Pentru n,m si matricea de mai jos, se va afisa drumul de suma minima 28.
4 5
3 4 5 7 9

6 6 3 4 4
6 3 3 9 6
6 5 3 8 2

#include<fstream>
#include<algorithm>
#include<cstring>
using namespace std;
short a[260][260];
int L, C, b1[260], b2[260];
inline void Citire()
{
int i,j;
ifstream fin ("lacusta.in");
fin>>L>>C;
for (i=1;i<=L;i++)
{
for (j=1;j<=C;j++)
fin>>a[i][j];
}
fin.close();
}
inline void Calculeaza()
{
ofstream fout("lacusta.out");
int i, j, minim, k;
b1[1]=100000;
for (j=2;j<=C;j++)
b1[j]=(int)a[1][1]+a[1][j]+a[2][j];
for (i=3;i<=L;i++)
{
for (j=1;j<=C;j++)
{
minim=1000000;
for (k=1;k<=C;k++)
if (k!=j)
minim=min(b1[k],minim);
b2[j]=minim+a[i][j]+a[i-1][j];
}

for (j=1;j<=C;j++)
b1[j]= b2[j];

minim=100000;
for (j=1;j<=C-1;j++)
minim=min(b1[j],minim);
minim+=a[L][C];
fout<<minim<<"\n";
fout.close();

/// PAGE 23

}
int main ()
{
Citire();
Calculeaza();
return 0;
}
Numele problemei: sudest; Sursa: OJI 2006 Clasa a X a

/// PAGE 24

Link: http://www.infoarena.ro/problema/sudest
Fermierul Ion detine un teren de forma patrata, impartit in NxN patrate de latura unitate, pe care cultiva cartofi.
Pentru recoltarea cartofilor fermierul foloseate un robot special proiectat in acest scop. Robotul porneste din
patratul din stanga sus, de coordonate (1,1) si trebuie sa ajunga in patratul din dreapta jos, de coordonate (N,N).
Traseul robotului este programat prin memorarea unor comenzi pe o cartela magnetica. Fiecare comanda specifica
directia de deplasare (sud sau est) si numarul de patrate pe care le parcurge in directia respectiva. Robotul strange
recolta doar din patratele in care se opreste intre doua comenzi. Din pacate, cartela pe care se afla programul s-a
deteriorat si unitatea de citire a robotului nu mai poate distinge directia de deplasare, ci numai numarul de pasi pe
care trebuie sa-i faca robotul la fiecare comanda. Fermierul Ion trebuie sa introduca manual, pentru fiecare
comanda, directia de deplasare. Scrieti un program care sa determine cantitatea maxima de cartofi pe care o poate
culege robotul, in ipoteza in care Ion specifica manual, pentru fiecare comanda, directia urmata de robot. Se va
determina si traseul pe care se obtine la recolta maxima.

#include <fstream>
#include <queue>
using namespace std;
struct coord
{
int x, y, nr;
// nr retine la al catelea pas am ajuns acolo
};
queue <coord> q;
int a[105][105], b[105][105], n, tx[205],ty[205];
int c[205],k;
void Citire()
{
int i, j;
ifstream fin("sudest.in");
fin>>n;
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
fin>>a[i][j];
fin>>k;
for (i=1;i<=k;i++)
fin>>c[i];
fin.close();
}
inline int Interior(int i, int j)
{
if (i > n) return 0;
if (j > n) return 0;
return 1;

}
void Lee()
{
int i, pas;
coord w, w1;
int dx[]={1,0};
int dy[]={0,1};
/// PAGE 25
w.x=1;
w.y=1;
w.nr = 1;
b[1][1] = a[1][1];
q.push(w);
while (!q.empty())
{
w=q.front();
q.pop();
pas = c[w.nr];
for (i=0;i<2;i++)
{
w1.x=w.x+dx[i]*pas;
w1.y=w.y+dy[i]*pas;
w1.nr=w.nr+1;
if (Interior(w1.x,w1.y) && b[w1.x][w1.y] < b[w.x][w.y] + a[w1.x]
[w1.y])
{
b[w1.x][w1.y] = b[w.x][w.y]+ a[w1.x][w1.y];
if (w1.x * w1.y != n*n) q.push(w1);
}
}
}

void Afisare()
{
ofstream fout("sudest.out");
fout << b[n][n] << "\n";
int i, j, p, pas;
i = j = n;
tx[k+1] = ty[k+1] = n;
for (p = k; p >= 1; p--)
{
pas = c[p];
if (i-pas < 1) j = j - pas;
else if (j - pas < 1) i = i - pas;
else if (b[i-pas][j] > b[i][j-pas])
i = i - pas;
else j = j - pas;
tx[p] = i;
ty[p] = j;
}
for (i = 1; i <= k + 1; i++)
fout << tx[i] << " " << ty[i] << "\n";
fout.close();
}

int main()
{
Citire();
Lee();
Afisare();
return 0;
}

Numele problemei: padure; Sursa: Stelele Informaticii 2006, clasele 9-10

/// PAGE 26

Link: http://www.infoarena.ro/problema/padure
Daca va intrebati ce mai face printul Algorel, acum puteti afla. El se afla pierdut undeva prin Padurea Magica si
cauta cu disperare drumul inapoi spre castelul sau. Padurea Magica poate fi reprezentata ca o matrice cu N linii
si M coloane, pentru fiecare celula din padure stiindu-se tipul copacilor care o acopera (numar natural mai mic
decat 104). O celula este acoperita numai cu copaci de acelasi tip. Printul Algorel se afla undeva in celula (pl,
pc) (pl reprezinta linia, pc coloana) iar castelul se afla situat in celula (cl, cc). Printul Algorel se poate deplasa in
cele patru directii: Nord, Sud, Est si Vest, dar nu poate sa iasa din padure fiindca dincolo de padure e taramul
Spanului cel Rau. In drumul sau catre castel, el trebuie sa plateasca Paduralului Magician un diamant pentru fiecare
trecere dintr-o celula in alta in care se schimba tipul copacilor (adica daca cele doua celule sunt acoperite cu tipuri
diferite de copaci). Pentru trecerile intre celule acoperite de acelasi tip de copaci el nu plateste nimic. Cum
diamantele sunt resursa cea mai importanta in regat, el vrea sa stie numarul minim de diamante pe care trebuie
sa-l plateasca pentru a ajunge la castel. Prima linie a fisierului padure.in se afla 6 numere
naturale N M pl pc cl cc, cu semnificatia de mai sus. Urmatoarele N linii contin cate M numere naturale separate
prin spatii, reprezentand tipul copacilor care acopera fiecare celula din Padurea Magica.
Fisierul de iesire padure.out trebuie sa contina pe prima linie un singur numar intreg D reprezentand numarul
minim de diamante pe care Algorel este nevoit sa-l plateasca pentru a ajunge la castel.

#include<fstream>
#include<queue>
using namespace std;
int a[1003][1003],b[1003][1003];
int xs,xf,ys,yf,n,m;
struct coord
{ int x,y;
};
queue <coord> q;
void Citire()
{ int i,j;
ifstream fin("padure.in");
fin>>n>>m>>xs>>ys>>xf>>yf;
for (i=1;i<=n;i++)
for (j=1;j<=m;j++)
fin>>a[i][j];
fin.close();
}
void Bordare()
{ int i;
for (i=0;i<=m+1;i++) a[0][i]=a[n+1][i]=-1;
for (i=0;i<=n+1;i++) a[i][0]=a[i][m+1]=-1;
}
void Lee()
{
int i,cost;
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
coord w,w1;
w.x=xs;

w.y=ys;
b[w.x][w.y]=1;
q.push(w);
while (!q.empty())
{
w=q.front();
q.pop();
for (i=0;i<4;i++)
/// PAGE 27
{
w1.x=w.x+dx[i];
w1.y=w.y+dy[i];
cost = 0;
if (a[w1.x][w1.y] != a[w.x][w.y]) cost = 1;
if (a[w1.x][w1.y]!=-1 && ( b[w1.x][w1.y] > b[w.x][w.y] + cost ||
b[w1.x][w1.y]==0 ))
{
b[w1.x][w1.y] = b[w.x][w.y] + cost ;
q.push(w1);
}
}
}
}
void Afisare()
{ ofstream fout("padure.out");
fout<<(b[xf][yf]-1)<<"\n";
fout.close();
}
int main ()
{ Citire();
Bordare();
Lee();
Afisare();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
Numele problemei: par; Sursa: Algoritmiada 2009, Runda 3
Link:

http://www.infoarena.ro/problema/par

Ioana tocmai a invatat la scoala despre paranteze rotunde si despre siruri parantezate corect. Un sir
este parantezat corect daca este construit conform regulilor:

<sir parantezat corect> = <sirul vid>

<sir parantezat corect> = "(" + <sir parantezat corect> + ")"
<sir parantezat corect> = <sir parantezat corect> + <sir parantezat corect>

Fiierul de intrare par.in contine pe prima linie numarul natural N, avand semnificatia din enunt. Pe a
doua linie urmeaza N caractere reprezentand sirul de paranteze furnizat de Andrei.

n fiierul de ieire par.out se va afisa un singur numar, reprezentand numarul minim de inversari ce
trebuie efectuat pentru ca la sfarsit sirul sa fie corect parantezat. In cazul in care nu exista solutie se
va afisa doar numarul -1.

#include<fstream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int n, i, dif, cnt;
char a[5005];
ifstream fin("par.in");
ofstream fout("par.out");

/// PAGE 28

int main()
{
in>>n;
if (n%2==1)
{ fout<<"-1\n";
fout.close();
return 0;
}

fin>>a;
cnt=0; dif=0;
for (i=0;i<n;i++)
if (a[i]=='(')
dif++;
else
{
dif--;
if (dif<0) { cnt++; dif = 1;}

cnt += (dif / 2);

fout<<cnt<<"\n";
fin.close();
fout.close();
return 0;
}
//////////////////////////////////////////////////////////////////////////////////

Numele problemei: betasah; Sursa: OJI 2013

Link:

http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1503

Jocul betaah se joac folosindu-se doar piese asemntoare damelor clasicului ah, numite tot dame. Suprafaa de joc are o
form triunghiular i este format din N(N+1)/2 ptrate identice dispuse pe N rnduri i N coloane. Rndurile se numeroteaz de
sus n jos, de la 1 la N. Coloanele se numeroteaz de la stnga la dreapta, de la 1 la N. Primul rnd conine un singur ptrat, al
doilea rnd conine dou ptrate alturate,..., al N-lea rnd conine N ptrate alturate, ca n suprafeele de joc cu N=6 din figurile de
mai jos. Din cele N(N+1)/2 ptrate, K sunt gri, iar restul sunt albe. Poziia fiecrui ptrat de pe suprafaa de joc este dat de rndul
i coloana n care acesta este situat. Pe suprafaa de joc sunt aezate D dame n D ptrate albe distincte, ocupndu-le. ntr-un
ptrat alb poate fi aezat o singur dam, iar ntr-un ptrat gri nu poate fi aezat nicio dam. Poziia unei dame pe suprafaa de

joc este dat de poziia ptratului alb n care este aezat dama.
Damele pot accesa orice ptrat alb neocupat situat pe direciile: vertical, orizontal sau diagonal, numerotate de la 1 la 8 n figura
b). Accesul pe o direcie se face trecnd din ptrat alb n ptrat alb (doar ptrate albe neocupate) pn la ntlnirea unui ptrat gri
sau a unui ptrat alb ocupat de o alt dam sau pn la terminarea suprafeei de joc.
Numim ptrat accesibil orice ptrat alb neocupat (de pe suprafaa de joc) care ar putea fi accesat de cel puin una din cele D dame.
De exemplu, pentru suprafaa de joc din figura c) numrul de ptrate accesibile (marcate cu X) de pe suprafa este 11; pentru
suprafaa de joc cu N=6, D=3 i K=4 din figura d) numrul de ptrate accesibile de pe suprafa este 13. n figura e) sunt marcate cu
X ptraele accesibile fiecrei dame de pe suprafaa de joc din figura d). Scriei un program care s citeasc numerele naturale N D
K, poziiile damelor i ale ptratelor gri pe suprafaa de joc i care s determine:
a) numrul maxim M de ptrate albe coninute de un rnd al suprafeei de joc;
b) numrul P de ptrate accesibile de pe suprafaa de joc.

/// PAGE 29

Fiierul de intrare betasah.in conine:

- pe prima linie cele trei numere naturale N D K, separate prin cte un spaiu, cu semnificaia din enun;
- pe linia i+1 dou numere naturale nenule xi yi, separate printr-un singur spaiu, reprezentnd poziia damei i pe suprafaa de
joc (rndul xi i coloana yi), pentru i=1,2,3,,D;
- pe linia D+1+j dou numere naturale nenule zj tj, separate printr-un singur spaiu, reprezentnd poziia ptratului gri j pe
suprafaa de joc (rndul zj i coloana tj), pentru j=1,2,3,,K.
Fiierul de ieire betasah.out va conine pe prima linie numrul natural M i pe a doua linie numrul natural P, cu semnificaia din
enun.

#include<fstream>
#include <stdio.h>
#include <string.h>
#include <time.h>
using namespace std;
int a[1004][1004],n,d,k,i,L,C,x[130],y[130],maxim,cnt,nt,j;
int aux1,aux2;
void Citire()
{
ifstream fin("betasah.in");
in>>n>>d>>k;
for (i=1;i<=d;i++)
{
in>>L>>C;
y[i]=L;x[i]=C;
a[L][C]=69;
}
for (i=1;i<=k;i++)
{
in>>L>>C;
a[L][C]=1;
}
maxim=-1;
for (i=1;i<=n;i++)
{
nt=0;
for (j=1;j<=i;j++)
{
if (a[i][j]==0||a[i][j]==69) nt++;
}
if (maxim<nt) maxim=nt;
}
fin.close();
}
void Rezolva1()
{
a[0][0]=1;
a[n+1][0]=1;
a[n+1][n+1]=1;

// sets the limits of the matrice

for (i=1;i<=n;i++)
{
a[i][i+1]=1;
a[i][0]=1;
a[n+1][i]=1;
}
for (i=0;i<=n+1;i++)
{
for (j=i+1;j<=n+1;j++)
a[i][j]=1;
}

/// PAGE 30

}
void Rezolva2()
{
///end that shift
cnt=0;
for (i=1;i<=d;i++)
{
///NORD
aux1=y[i]; aux2=x[i]; aux1--;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1--;
}
///SUD
aux1=y[i]; aux2=x[i]; aux1++;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1++;
}
///EST
aux1=y[i]; aux2=x[i]; aux2++;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux2++;
}
///VEST
aux1=y[i]; aux2=x[i]; aux2--;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux2--;
}
///NE
aux1=y[i]; aux2=x[i]; aux1--; aux2++;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1--; aux2++;
}

///NV
aux1=y[i]; aux2=x[i]; aux1--; aux2--;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1--; aux2--;
}

///SE
aux1=y[i]; aux2=x[i]; aux1++; aux2++;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1++; aux2++;
}
///SV
aux1=y[i]; aux2=x[i]; aux1++; aux2--;
while (a[aux1][aux2]!=1&&a[aux1][aux2]!=69)
{
if (a[aux1][aux2]==0) cnt++;
a[aux1][aux2]=2;
aux1++; aux2--;
}
}
}
void Afisare()
{
ofstream fout("betasah.out");
fout<<maxim<<"\n"<<cnt;
fout.close();
}
int main()
{
Citire();
Rezolva1();
Rezolva2();
Afisare();
return 0;
}

/// PAGE 31