====== Recurențe ======
/*
<note important>
Solutii:

https://drive.google.com/file/d/11tR3YphFS73OF8QGvtorjf_dkRHPmo1y/view?usp=drivesdk
</note>
*/

<note important>
Teorema Master se poate aplica pe recurente de forma:

  * $ T(n) = a * T(\frac n b) + f(n); a \ge 1; b > 1 $

In functie de $ f(n) $ apar urmatoarele cazuri:
  - $ f(n) = \Theta(n^c) ; c < \log_ba $                                  $ \Rightarrow T(n) = \Theta(n^{\log_ba}) $ 
  - $ f(n) = \Theta(n^c * \log^kn); k \geq 0; c = \log_ba $               $ \Rightarrow T(n) = \Theta(n^{\log_ba}*\log^{k+1}n) $
  - $ f(n) = \Theta(n^c); c > \log_ba $                                   $ \Rightarrow T(n) = \Theta(f(n)) $   
</note> 


1. Folosiți Teorema Master pentru a rezolva următoarele recurențe:

   * $ T_1(n) = 4T_1(n/4) + 1$
<hidden Exemplu de cod cu aceasta recurenta>
<code c>
// O metoda destul de ineficienta de calcul al sumei elementelor unui vector
int sum(int arr[], int lo, int hi) {
    if(lo == hi)
        return arr[lo];
    int x = (hi - lo) / 4;
    return  sum(arr, lo, lo + x) +  
            sum(arr, lo + x + 1, lo + 2 * x) + 
            sum(arr, lo + 2 * x + 1, lo + 3 * x) +  
            sum(arr, lo + 3 * x + 1, hi);
}
</code>
</hidden>
   * $ T_2(n) = 4T_2(n/2) + n^2$
   * $ T_3(n) = 8T_3(n/2) + 2n^4$

2. Fie următorul algoritm de căutare a unei valori ''v'' într-un array sortat ''arr'':

<code c>
int search(int arr[], int lo, int hi, int v)
{
    int mid = (lo + hi) / 2;  
    if (arr[mid] == v)
        return mid;
    if (lo == hi)
        return -1;
    if (arr[mid] > v)
        return search(arr, lo, mid, v);
    else
        return search(arr, mid, hi, v);
}

</code>

  * Determinați relația de recurență a algoritmului de căutare prezentat.
  * Demonstrați recurența utilizând Teorema Master.
  * Demonstrați recurența utilizând Metoda Arborilor.
  * Demonstrați recurența utilizând Metoda Substituției.

3. Folosiți cele 3 metode (metoda arborilor, metoda substituției, teorema master) pentru a rezolva recurențele:

   * $ T_a(n) = 2T_a(n-1) + 1$
   * $ T_b(n) = T_b(n-1) + 1$
   * $ T_c(n) = 2T_c(n/2) + \log(n)$
   * $ T_d(n) = T_d(n/9) + T_d(8n/9) + n$
   * $ T_e(n) = T_e(2n/3) + 1$
   * $ T_{Strassen}(n) = 7T_{Strassen}(n/2) + n^2 $\\
Aceasta recurenta descrie [[https://en.wikipedia.org/wiki/Strassen_algorithm| Algoritmul Strassen]]
   * $ T_{Karatsuba}(n) = 3T_{Karatsuba}(n/2) + 1 $\\
Aceasta recurenta descrie [[https://en.wikipedia.org/wiki/Karatsuba_algorithm| Algoritmul Karatsuba]]
   * $ T_{Quicksort}(n) = T_{Quicksort}(n-1) + O(n) $\\
Aceasta recurenta descrie [[https://en.wikipedia.org/wiki/Quicksort| Algoritmul Quicksort]]

4. Rezolvați următoarea recurență folosind metoda substituției: $math[T(n) = 2 T(\frac{n}{2}) + 1].

5. Rezolvați următoarea recurență folosind metoda arborilor: $math[T(n) = T(] $math[n \over 4] $math[) + T(] $math[3n \over 4] $math[) + n].


<note>
Soluțiile acestui laborator se găsesc [[https://ocw.cs.pub.ro/ppcarte/doku.php?id=aa:lab:sol:10|aici]]
</note>