n șiruri deja sortate a1... an pentru care se cunosc
valorile acestora a1--> a11 a12... a1k1
		  . . . . . . . . . .
		  an-->an1 an2... ank1
1. Abordare trivial
2. Abordare naivă
( merge )
3. Abordare acceptată
( merge )
4. Abordare optimă
l1 , l2 -> l1+l2 deplasări în rezultat

siruri cu lungimi: 30, 10, 50, 10, 20
30+10 -> 40 + 50 -> 90 +10 -> 100 + 20 -> 120 deplasări

pt optim: interplasez cate două din cele mai scurte șiruri din cele pe
care le dețin la un moment dat:

10+10 -> 20+20 -> 40 +30 -> 70 +50 -> 120 deplasări

inițial organizez aj ca heap h w1+...+k1

pt i=1; la n-1
 arătam de 2 ori din heap
 introducem

Idee: efortul de reorganizare a unui heap este minim

NDG -> metode de reprezentare/conversii(12)
       parcurgeri DFS/BFS/aplicatii(5+1)
    -> cazuri particulare de NDG
C1 -> grafuri ( graf conex, aciclic în care conexitatea minimal
		asigurată, aciclicitatea maximal asigurată )
		Aplicații: Arborii minheap
C2 -> NDG ( grafuri nedirecționate ) ponderate -> Algoritmul lui Kruskal, Prim

D -> DG grafuri orientate -> Roy Ooyd
			  -> Roy Warshall
			  -> Riktha

	Heap-uri(grămezi)
  Heap-uri este un arbore binar în interiorul caruia orice nod are un nume și o informație astfel
încât sunt verificate proprietățiile.
1. Descendenții unui nod i, dacă exista se numesc 2*i și 2+1
2. Informația unui nod i este mai mică decât toți descendenții săi.( informația minimă se află in
rădacină )

  Construcția unui minheap:
Principiu:
- se pornește cu heap-ul singleton, la fiecare pas se inserează un câte nou nod într-un heap deja
existent
- fie pas i al inserției nodului i din cele deținute în heap-ul anterior creat
- se determină tatăl acestuia ( partea întreagă din i/2 ) apar situațiile
	a) relația tată-fiu este corectă și în acest moment consider heap-ul cu i elemente, trec la
		inserția următoare
	b) relația tată-fiu este incorectă, în acest caz -> interschimb informațiile tată fiu cu
							      scopul de a restabli corectitudinea
							      aleg fiu fostul tată cu intenția de a
								face un șir de verificări asupra
								 consistenței grămezilor heap-ului


Pseudocod
pt i=2 de la n execută
tată=int i/2
atâta timp cat v[tata]>v[i] și v[tată]>1
| dacă v[tată] > v[i] interschimb v[tată] cu v[i]
				  fiu=tată;
				   tată=int fiu/2


n=5
M={5|,1,9,14,2}
 			5
		/		\
		=		=
Vnou:[1][5][9][14][2]
			1
		/		\
		5		=
Vnou:[1][5][9][14][2]
	1,5,9