teeeeeeext ai

/*
Ce se da?
Identificam datele de intrare
Ce se cere?

** Suma a 2 numere **
input: x, y;
reguli: pozitive, naturale, pare
output: x+y;

SOLUTIE = Algoritm care rezolva orice instanta a problemei. Algoritm care ofera rezultatul corect, pentru orice input. Trebuie tratate si cazurile in care
rezultatul nu poate fi afisat.




*** Problema turnurilor din hanoi   // caz clasic: 3turnuri, 4 piese.

input:	- n turnuri
		- m piese

reguli:	- piese de marimi diferite
		- nu poate sta o piesa mare pe o piesa mica
		- pot muta o singura piesa.

output:


Modelarea problemei:
	Pas 1: identificarea unei stari a problemei.
		(3, x, y). 3-nr turnuri. x-unde se afla piesa 1. y-unde se afla piesa 2
		nu poate lipsi starea finala
		starea finala nu poate fi ca si starea initiala

	Pas 2: starea initiala. Transfera starea initiala in instanta.
		(n turnuri, m piese). Fac o lista ...
		tot timpul cunoaste o stare
		se opreste cand starea curenta = starea finala.

			stare initializare(n, m) {
				return (n, 1, 1, ..)
			}

			boolean getStareFinala(STARE) {
				if(STARE = (n, n, n, ...) )
					return false;
				return true;
			}


	Pas 3. Validarea tranzitiilor
		stare tranzitie(stare_curenta, piesa_x, piesa_y) {
			stare_curenta(x) = y;
			return stare_curenta;
		}

		boolean validare(stare_curenta, piesa_x, piesa_y) {
			if(stare_curenta(x) = y) return false;
			for(i=1; i<x; i++) {
				if(stare_curenta(i) == y) return false; // daca pot pune o piesa mare pe o piesa mica
				if(stare_curenta(i) == x) return false; // daca piesa are o piesa mai mica pe ea
			}
			return true;
		}

	Pas 4. Strategia // permite pc cum sa schimbe starea curenta
		void strategie ( stare ) {
			while(!st.finala(stare)) {
				choose x, y; // parametri tranzitiei
				if(validare(stare, x, y))
					stare_curenta = tranzitie(stare, x, y);
			}
		}

		posibilitati de a alege X, Y:
			1. random (2 optimizari:[
										(evitam cicluri. tinem minte starile vizitate anterior, si cand facem validarea tranzitiilor, verificam daca starea e starea vizitata anterior)
										(punem un contor. daca nu a gasit solutii intr-un numar de pasi, revine la starea initiala si continua de acolo)
									])
				aleg 0 < x < pieces si 0 < y < towers

			2. bkt ( metoda lenta. complexitate mare. incercat bkt sa NU fie recursiv *sad* )
				- pentru a defini pe rand ceva, trebuie sa fie in ordine.
				- din orice stare as fi, starile accesibile din st_curenta, sunt in ordine
				- daca am de ales intre starile alea, o aleg pe urmatoarea de dupa alegerea pe care am facut-o anterior. daca nu am mai facut nicio alegere, o iau pe prima
				# tine minte numarul alegii facut la pasul respectiv
				- daca nu mai am nicio stare accesibila, ma intorc inapoi si aleg celelalte stari
				la choose x,y, aleg in ordine.

			3. hillclimbing (  )
				- aseaza starile in spatiu, in asa fel incat st_iniala este jos, st_finala este sus
				- cautarea solutiei se face in de jos in sus.
				- cum ordonam starile? :
				# 2 probleme: daca esti intr-o stare, si avem 4 stari accesibile. evaluez scorul acelesi stari, si verific care e >= scorul starii_curente.
				RECOMANDARE: hillclimbing implementat cu random.
				cand alegem, calculam scor pt fiecare stare. pastram doar starile care au scor >= stare_curent, si aleg random.

			4. A*
				- cum privesc spatiul problemei? il impart in felii. ordonez/asez starile pe categorii


				•-------------------------------•
				|  RAN	|  BKT	|  HC	|	A*	|
				|-------+-------+-------+-------|
1 sol			|-> Y <-|	Y	|	N	|	Y	|
toate sol		|	N	|->	Y <-|	N	|	Y	|
sol optima		|	N	|	N	|	N	|-> Y <-|
				|		|		|		|		|
				•-------------------------------•

##	(3) De ales o functie de scor rapida.

				*/