Differences

This shows you the differences between two versions of the page.

--- aa:lab:10 [2023/01/12 14:01]
dmihai
+++ aa:lab:10 [2025/01/23 14:10] (current)
dmihai
@@ Line 1: / Line 1: @@
-====== Loop invariants ======
+====== Recurențe ======
+/*
+<note important>
+Solutii:
-/* <note important>Solutii: https://drive.google.com/file/d/1KHhXOXUinJw2KbYnKqUGtr-dmRuAsbox/view?usp=sharing </note> */
+https://drive.google.com/file/d/11tR3YphFS73OF8QGvtorjf_dkRHPmo1y/view?usp=drivesdk
+</note>
+*/
-. Pentru următorii algoritmi, demonstrați corectitudinea, alegând corect precondiția, postcondiția și invariantul și demonstrând cele patru proprietăți (initialization, maintenance, postcondition, termination).
+<note important>
+Teorema Master se poate aplica pe recurente de forma:
-<code c>
+  * $ T(n) = a * T(\frac n b) + f(n); a \ge 1; b > 1 $
-// găsește indexul celui mai mic element din arr
-int find_min(int *arr, int n)
+In functie de $ f(n) $ apar urmatoarele cazuri:
-{
+  - $ f(n) = \Theta(n^c) ; c < \log_ba $                                  $ \Rightarrow T(n) = \Theta(n^{\log_ba}) $
-        int min_idx = 0;
+  - $ f(n) = \Theta(n^c * \log^kn); k \geq 0; c = \log_ba $               $ \Rightarrow T(n) = \Theta(n^{\log_ba}*\log^{k+1}n) $
-        int i = 1;
+  - $ f(n) = \Theta(n^c); c > \log_ba $                                   $ \Rightarrow T(n) = \Theta(f(n)) $
-        while (i < n) {
+</note>
-                if (arr[i] < arr[min_idx])
-                        min_idx = i;
-                i++;
-        }
-        return min_idx;
+. 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$
+. Fie următorul algoritm de căutare a unei valori ''v'' într-un array sortat ''arr'':
 <code c>
-// calculate the sum of all positive integers up to and including n
+int search(int arr[], int lo, int hi, int v)
-int integer_sum(int n)
 {
-        int i = 0;
+    int mid = (lo + hi) / 2;
-        int sum = 0;
+    if (arr[mid] == v)
-        while (i != n) {
+        return mid;
-                i++;
+    if (lo == hi)
-                sum += i;
+        return -1;
-        }
+    if (arr[mid] > v)
+        return search(arr, lo, mid, v);
+    else
+        return search(arr, mid, hi, v);
+}
-        return sum;
-}
 </code>
-<code c>
+  * Determinați relația de recurență a algoritmului de căutare prezentat.
-// calculează b la puterea e
+  * Demonstrați recurența utilizând Teorema Master.
-int pow(int b, int e)
+  * Demonstrați recurența utilizând Metoda Arborilor.
-{
+  * Demonstrați recurența utilizând Metoda Substituției.
-        int x = b;
-        int y = e;
-        int r = 1;
-        while (y > 0) {
-                if (y % 2 == 1)
-                        r = r * x;
-                y = y / 2;
+. Folosiți cele 3 metode (metoda arborilor, metoda substituției, teorema master) pentru a rezolva recurențele:
-                x = x * x;
-        }
-        return r;
+   * $ 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]]
+. Rezolvați următoarea recurență folosind metoda substituției: $math[T(n) = 2 T(\frac{n}{2}) + 1].
-</code>
+. Rezolvați următoarea recurență folosind metoda arborilor: $math[T(n) = T(] $math[n \over 4] $math[) + T(] $math[3n \over 4] $math[) + n].
-<code c>
-// inserează valoarea x în array-ul sortat arr (arr are un extra "slot" alocat la final)
-void insert(int *arr, int n, int x)
-{
-        int i = n;
-        while (i > 0 && arr[i - 1] > x) {
-                arr[i] = arr[i - 1];
-                i--;
-        }
-        arr[i] = x;
-}
-</code>
+<note>
+Soluțiile acestui laborator se găsesc [[https://ocw.cs.pub.ro/ppcarte/doku.php?id=aa:lab:sol:10|aici]]
+</note>