Algoritmi

randomizați

Grupa: Profesor coordonator:

10LF381 Alexandra Băicoianu

Autor:
Creangă Răzvan – Marian

1
Cuprins:
Definiție și Clasificare ................................................................................................................................. 3
I) Algoritmi de tip Monte Carlo ................................................................................................................... 3
II) Algoritmi de tip Las Vegas ..................................................................................................................... 6
III) Avantaje ................................................................................................................................................. 7
IV) Dezavantaje ............................................................................................................................................ 8
V) Rolul proiectului: .................................................................................................................................... 8
Bibliografie: ................................................................................................................................................. 9

2
 Definiție și Clasificare

Un algoritm aleatoriu poate fi privit ca un algoritm nedeterminist care are o distribuție de

probabilitate pentru fiecare alegere nedeterministă.
Un algoritm aleatoriu este un algoritm determinist care are la intrare o secvență de biți
aleși aleatoriu.
Un algoritm aleatoriu poate fi văzut ca o mulțime de algoritmi determiniști, din care,
pentru o intrare dată, se alege unul într-un mod aleatoriu. Pentru o intrare dată x, execuțiile
algoritmului aleatoriu pot diferi în funcție de secvența de biți aleși aleatoriu Aceste diferențe se
proiectează atât în complexitate cât și în ieșiri: Timpul de execuție sau datele de ieșire pot fi
considerate ca variabile aleatorii.
Există două tipuri de algoritmi randomizați:
 Algoritmi Monte Carlo;
 Algoritmi Las Vegas.

I) Algoritmi de tip Monte Carlo

Algoritmii sau metodele Monte-Carlo sunt o clasa de algoritmi care se bazează pe

aleatorism pentru a găsi soluția la o anumită problemă. Sunt folosiți adesea in simulări
computerizate din fizică și matematică. În informatică acești algoritmi sunt utilizați atunci când
nu se cunosc algoritmi determiniști eficienți pentru rezolvarea unei probleme.
La ce folosește aleatorismul? Să ne amintim ca în general complexitatea unei probleme
este definită luând in considerare cea mai defavorabila instanța a sa. De exemplu, problema
comis voiajorului care este NP-completa. Acest lucru nu înseamnă ca nu putem rezolva nicio
instanță a ei in timp polinomial, ci ca exista instanțe pentru care algoritmii cunoscuți nu au prea
mari șanse sa se termine curând.
Acest lucru este adevărat si pentru alte clase de algoritmi, de exemplu quicksort, are
pentru majoritatea vectorilor de intrare o complexitate de O(n logn). Daca însă datele sunt prost
distribuite(de exemplu vectorul este deja sortat) acesta face 𝑛2 comparații. Atunci o soluție
pentru a evita cazul cel mai nefavorabil ar fi ca datele de intrare sa fie amestecate aleator de la
început astfel încât probabilitate ca, quicksort sa se afle in cazul cel mai defavorabil O(𝑛2 ) sa fie
foarte mica. Acest lucru nu garantează ca nu se va ajunge in acest cel mai nefavorabil caz, însă
probabilitatea ca el sa se întâmple este redusa.

3
 Acesta este un exemplu de folosire a aleatorismului pentru a îmbunătății performanta
medie a unui algoritm. Câteodată câștigul este și mai mare, pentru că putem rezolva probleme
NP-complete foarte rapid folosind aleatorismul. De obicei avem însă un preț de plătit. Când
folosim algoritmi din clasa prezentat mai jos, putem risca să nu primim răspunsul corect.

Un exemplu de problemă în care se poate utiliza un algoritm de tip Monte Carlo poate fi
aproximarea valorii lui PI după cum urmează:
Ideea este să generăm două puncte random (x și y) într-un plan 2D ce are ca domeniu un
pătrat cu dimensiunea de o unitate. Să ne imaginăm un cerc de aceeași dimensiune, înscris în
pătratul inițial. Trebuie să calculam raportul dintre numărul punctelor generate în interiorul
cercului și numărul total de puncte generate. Pentru o mai buna înțelegere a ideii, se poate
observa Figura 1.

Figura 1

Algoritmul inițializează circle_points, square_points și interval cu 0, se setează un număr

de generări random a două puncte (x, y) din intervalul [0, 1], apoi calculează distanța punctului
față de origine după formula: d = x*x + y*y. Dacă distanța este mai mică sau egală cu 1, se
incrementează numărul de puncte ale cercului. Se incrementează și numărul de puncte ale
pătratului, iar la final se calculează și se afișează valoarea pe care o are pi după formula
următoare: pi = 4*(circle_points/square_points). Algoritmul este prezentat mai jos, după cum
urmează:

4
#include <iostream>

// Defines precision for x and y values. More the

// interval, more the number of significant digits
#define INTERVAL 10000
using namespace std;

int main()
{
int interval, i;
double rand_x, rand_y, origin_dist, pi;
int circle_points = 0, square_points = 0;

// Initializing rand()
srand(time(NULL));

// Total Random numbers generated = possible x

// values * possible y values
for (i = 0; i < (INTERVAL * INTERVAL); i++) {

// Randomly generated x and y values

rand_x = double(rand() % (INTERVAL + 1)) / INTERVAL;
rand_y = double(rand() % (INTERVAL + 1)) / INTERVAL;

// Distance between (x, y) from the origin

origin_dist = rand_x * rand_x + rand_y * rand_y;

// Checking if (x, y) lies inside the define

// circle with R=1
if (origin_dist <= 1)
circle_points++;

// Total number of points generated

square_points++;

5
 // estimated pi after this iteration
pi = double(4 * circle_points) / square_points;

// For visual understanding (Optional)

cout << rand_x << " " << rand_y << " " << circle_points
<< " " << square_points << " - " << pi << endl << endl;

// Pausing estimation for first 10 values (Optional)

if (i < 20)
getchar();
}

// Final Estimated Value

cout << "\nFinal Estimation of Pi = " << pi;

return 0;
}

Output: Final Estimation of Pi = 3.16116

II) Algoritmi de tip Las Vegas

Evoluția unui algoritm care folosește numere aleatoare nu depinde numai de datele de
intrare ci si de numerele aleatoare pe care le generează. Dacă are “noroc” algoritmul poate
termina repede și bine, dacă nu ar putea chiar să nu ofere soluția corectă. Astfel se ajunge la o
nouă clasă de algoritmi probabilistici numiți algoritmi Las Vegas, care spre deosebire de cei
Monte-Carlo, mereu corecți, pot uneori greși. Vom defini acum algoritmi probabilistică pentru
probleme de decizie(la care răspunsul este “Da” sau “Nu).
Exista 2 clase de algoritmi probabilistici, dar ne concentrăm atenția numai asupra uneia
dintre ele. Vom defini tot odată clasa problemelor care pot fi rezolvate probabilistic în timp
polinomial, numite RP(Random Polynomial).
Definiție : O problemă de decizie este în RP dacă există un algoritm aleator A care
rulează într-un timp polinomial (𝑛𝑐 ,c oarecare) si care are următoarele proprietăți:
• Dacă răspunsul la o instanță I este “Da” atunci cu probabilitatea p > ½,
algoritmul va răspunde “Da”.

6
 •Dacă răspunsul este “Nu” atunci cu o probabilitate de 1 algoritmul va răspunde
“Nu”.
Aceasta probabilitate p este dată de numărul de șiruri aleatoare. Astfel atunci când rulăm
𝑐
un algoritm aleator pentru o instanță I avem la dispoziție 2𝑛 șiruri aleatoare de biți; pentru unele
din ele răspunsul fiind “da”, iar pentru altele “nu”. Pentru a calcula p-ul în cazul în care
răspunsul este “da” numărăm șirurile pentru care algoritmul răspunde afirmativ si împărțim acest
𝑐
număr la 2𝑛 . Pentru celălalt caz luăm opusul.
O tehnică pentru a scădea probabilitatea de a greși este de a rula respectivul algoritm de
mai multe ori pe aceleași date de intrare. Astfel daca executăm de 2 ori algoritmul, în cazul care
răspunsul este “nu” probabilitatea de a greși rămâne 0 .Pe de altă parte, ajunge ca algoritmul
să răspundă măcar odată “da” pentru a ști că răspunsul este „da” cu siguranță! Din cauza asta,
dacă probabilitatea de eroare este p pentru algoritm, executându-l de k ori probabilitatea coboară
la 𝑝𝑘 (nu uitați că p este subunitar, ba chiar sub 1/2). Această metodă se numește “boost'” în
engleză, și face dintr-un algoritm probabilist slab ca discriminare o unealtă extrem de puternică!
Pentru a scădea probabilitatea de eroare a unui algoritm care poate greși cu probabilitatea
p până sub o limită dorită s, se procedează astfel:

raspuns := nu
probabilitate := 1
p := 0.5
while(raspuns = nu && probabilitate > s)
raspuns = executa(algoritm)
probabilitate := probabilitate * p

III) Avantaje

 Algoritmii aleatori pot fi mai eficienți și mai ușor de implementat

 Pot fi foarte utili pentru acele probleme pentru care nu știm altă abordare tractabila din punct
de vedere practic
 O astfel de problemă este testul de primalitate pentru care
i) Avem un algoritm aleatoriu cu complexitate timp polinomiala,
ii) Nu se cunosc algoritmi determiniști polinomiali care să rezolve problema,
iii) Nu se știe dacă problema este in P sau (sau chiar daca este NP-completa sau nu)
 Deși sunt puține probleme cunoscute pentru care algoritmii aleatorii s-au aplicat cu succes,
deoarece aceste probleme sunt foarte importante, abordările aleatorii au devenit un
instrument standard în multe domenii din informatică

7
 IV) Dezavantaje

 Așa cum am mai spus, cazurile în care s-au aplicat cu succes sunt puține
 De fapt cazul tipic este acela când nu se cunoaște dacă “randomizarea” ajută sau nu
 De exemplu, nu se cunoaște niciun algoritm aleatoriu cu timp de execuție polinomial pentru
vreo problema NP-completă
 Întrebarea “este posibil să convertim un algoritm aleatoriu într-unul determinist fără să plătim
un preț prea mare privind resursele?” este încă deschisă

V) Rolul proiectului:

 aprofundarea cunoștiințelor legate de algoritmii randomizați,

 domeniile si condițiile în care aceștia sunt folosiți,
 înțelegerea utilității acestora.

8
Bibliografie:
 https://profs.info.uaic.ro/~dlucanu/cursuri/tpaa/resurse/rand-alg.pdf
 https://www.scribd.com/document/92538233/Algoritmi-Monte-Carlo
 https://www.geeksforgeeks.org/estimating-value-pi-using-monte-carlo/
 http://algopedia.ro/wiki/index.php/Clasele_9-10_lec%C8%9Bia_26_-
_22_apr_2015
 https://elearning.unitbv.ro/pluginfile.php/226426/mod_resource/content/1/In
troduction%20to%20Algorithms%20-%203rd%20edition.pdf
 Introduction to Algorithms – Thomas H. Cormen, Charles E. Leiserson,
Ronald L. Rivest, Clifford Stein (Masssachusetts Institute of Tehnology,
2009)

Vă mulțumesc pentru timpul acordat!