Laborator 4: Programare Dinamică

• Enunt

Fie un produs matricial $M = M_1 M_2 ... M_n$. Putem pune paranteze in mai multe moduri si vom obtine acelasi rezultat (inmultire asociativa), dar este posibil sa obtinem numar diferit de inmultiri scalare .

Matricea $M_i$ are (prin conventie), dimensiunile $d_{i-1} d_{i}$.

• Cerinta

Se cere sa se gaseasca o parantezare optima de matrice (PODM), adica sa se gaseasca o parantezare care sa minimizeze numarul de inmultiri scalare.

• Recurenta

Se construieste o dinamica de tipul:

• $dp[i][j]$ = numarul minim de inmultiri scalare cu care se poate obtine produsul $M_i * M_{i+1} * ... *{M_j}$
  • $dp[i][i] = 0 $
    • NU avem nici un efort daca nu avem ce inmulti
  • $dp[i][i+1] = d_{i-1} d_{i} d_{i+1}$
    • daca inmultim 2 matrice de dimensiuni $d_{i-1} * d_{i}$ si $d_{i} * d_{i + 1}$, avem costul $d_{i-1} d_{i} d_{i-1}$
  • $dp[i][j] = min(dp[i][k] + dp[k+1][j] + d_{i-1} d_{k} d_{j})$, unde $k = i : j - 1$
    • daca avem de efectuat sirul de inmultiri $M_i ... M_j$, atunci putem pune paranteze oriunde si sa facem inmultirile astfel $(M_i ... M_k) (M_{k+1} ... M_{j})$
      • costul minim pentru $(M_i ... M_k)$ este $dp[i][k]$
      • costul minim pentru $(M_{k+1} ... M_j)$ este $dp[k + 1][j]$
      • vom avea in final de inmultit 2 matrice de dimensiune $d_{i-1} * d_{k}$ si $d_{k} * d_{j}$, care are costul $d_{i-1}d_{k}d_{j}$
      • insumam cele 3 costuri intermediare

• Complexitate

Intrucat solutia presupune fixarea capetelor unui subinterval (i, j), apoi alegerea unui intermediar (k), complexitatea este data de aceste 3 cicluri.

• complexitate temporala: $T = O(n^3)$
• complexitate spatiala: $M = O(n^3)$

Puteti rezolva si testa problema PODM pe infoarena.

• Enunt

Se da o expresie booleana exprimata prin stringurile true, false, and, or, xor.

• Cerinta

Numarati modurile in care se pot aseza paranteze astfel incat rezultatul sa fie true. Se respecta regulile de la logica (tabelele de adevar pentru operatiile AND, OR, XOR).

• Exemplu

Fie expresia: true and false xor true. Exista doua modalitati de parantezare asftel incat rezultatul sa fie true.

• Hint

Complexitate temporală dorita este $O(n ^ 3)$. Gasiti vreo asemanare cu problema PODM?

• definitie : b este inversul modular a lui a in raport cu MOD daca $ a * b = 1 (modulo \ MOD)$
• utilizare : $ \frac{a}{b} \ \% \ MOD = ((a \ \% \ MOD) * (invers(b) \ \% \ MOD)) \ \% \ MOD $
• calculare : deoarece la PA aceasta discutie are sens doar in contextul posibilitatii implementarii unei recurente DP in care folosim resturile doar pentru a evita overflow/imposibilitatea de a retine rezultatul pe tipurile standard de tip int (adica nu ne intereseaza sa dam o metoda generala pentru invers modular), vom simplifica problema - MOD este prim!!!
• Mica teorema a lui Fermat: Daca p este un numar prim si a este un număr intreg care nu este multiplu al lui p, atunci $a^{p-1} = 1 (modulo \ p)$.
  • din definitia inversului modular, reiese ca a si b nu sunt multipli ai lui MOD
  • introducand notatiile noastre in teorema si prelucrand obtinem
    • $a ^ {MOD - 1} = 1 (modulo \ MOD) <=> a * (a ^{MOD-2}) = 1 (modulo \ MOD)$
    • deci inversul modular al lui a (in aceste conditii specifice) este $b = a ^ {MOD -2 }$

$n = 1$ sau $n = 2$ sau $n = 3$

Raspuns: 1 (un singur gard)

Explicatie: Se poate forma un singur gard in fiecare caz, dupa cum este ilustrat si in figura Garduri_123.

$n = 4$

Raspuns: 2

Explicatie: Se pot forma 2 garduri, in functie de cum asezam piesele, dupa cum este ilustrat si in figura Garduri_4. Observam ca de fiecare daca cand punem o piesa in pozitie orizontala, de fapt suntem obligati sa punem 4 piese, una peste alta!

$n = 5$

Raspuns: 3

Explicatie: Se pot forma 3 garduri, in functie de cum asezam piesele, dupa cum este ilustrat si in figura Garduri_5.

• daca dorim ca acest gard sa se termine cu 4 piese in pozitie orizontala (una peste alta - marcat cu rosu), atunci la stanga mai ramane de completat un subgard de lungime 1, in toate modurile posibile
• daca dorim ca acest gard sa se termine cu o piesa in pozitie verticala (marcat cu rosu), atunci la stanga mai ramane de completat un subgard de lungime 4, in toate modurile posibile

$n = 6$

Raspuns: 4

Explicatie: Se pot forma 4 garduri, in functie de cum asezam piesele, dupa cum este ilustrat si in figura Garduri_6.

• daca dorim ca acest gard sa se termine cu o piesa in pozitie verticala (marcat cu rosu), atunci la stanga mai ramane de completat un subgard de lungime 5, in toate modurile posibile
• daca dorim ca acest gard sa se termine cu 4 piese in pozitie orizontala (una peste alta - marcat cu rosu), atunci la stanga mai ramane de completat un subgard de lungime 2, in toate modurile posibile

#define MOD 1009
int gardurile_lui_Gigel(int n) {
    // cazurile de baza
    if (n <= 3) return 1;
    if (n == 4) return 2;
 
    vector<int> dp(n + 1); // pastrez indexarea de la 1 ca in explicatii
 
    // cazurile de baza
    dp[1] = dp[2] = dp[3] = 1;
    dp[4] = 2;
 
    // cazul general
    for (int i = 5; i <= n; ++i) {
        dp[i] = (dp[i - 1] + dp[i - 4]) % MOD;
    }
 
    return dp[n];
}

Mentionez ca am folosit expresia $dp[i] = (dp[i - 1] + dp[i - 4]) \ \% \ MOD$ in loc de $dp[i] = ((dp[i - 1] \ \% \ MOD) + (dp[i - 4] \ \% \ MOD)) \ \% \ MOD$, deoarece [e valorile anterior calcule in dp a fost deja aplicata operatia $%$.

Am plecat cu numerele $1, 1, 1, 2$ si la fiecare pas rezultatul stocat este $\ \% \ MOD$, deci tot ce este stocat deja in dp este un rest in raport cu MOD. NU mai era nevoie deci sa aplica % si pe termenii din paranteza.

Presupunand ca nu mai exista alte specificatii ale problemei si ca avand cele KMAX cazuri de baza (primele KMAX valori ar trebui stiute/deduse prin alte reguli), atunci un algoritm poate implementa recurenta de mai sus folosind 2 cicluri de tip for (for i = 1 : n, for k = 1 : KMAX …).

• complexitatea temporala : $ T =O(n * KMAX) = O(n) $
  • reamintim ca acea valoarea KMAX este o constant foarte mica in compartie cu n (ex. KMAX < 100)
• complexitatea spatiala : $ S = O(n) $
  • am presupus ca avem nevoie sa retinem doar tabloul dp

• ultima coloana contine toti coeficientii $c_k$ intrucat $dp[i] = \sum_{k=1}^{KMAX} c_k * dp[i - k]$
• celelalte coloane contin doar cate o valoare nenula
  • pe coloana j vom avea valoarea 1 pe linia $j+1$ ($j = 1 : KMAX - 1$)
    • cum obtinem, de exemplu, $dp[i - 1]$?
    • pai avem $dp[i-1]$ chiar si in starea $S_{i-1}$, deci trebuie sa il copiam in starea $S_i$
      • copierea se realizeaza prin inmultirea cu 1
      • daca $dp[i-1]$ era pe ultima pozitiei (pozitia k) in starea $S_{i-1}$, in noua stare $S_i$ este pe penultima pozitie (pozitia $k-1$)
        • deci s-a deplasat la stanga cu o pozitie!
  • in noua stare, noua pozitie este deplasata cu o unitate la stanga fata de starea precedenta
    • de aceea pe coloana $j$, vrem sa avem elementul 1 pe linia $j + 1$ ($j = 1 : KMAX - 1$)
    • cand inmultim $S_{i-1}$ cu coloana $C_j$ dorim sa
      • ce copiam?
        • valoarea $dp[i - KMAX + j]$ din $S_{i-1}$ in $S_{i}$
        • adica sa copiam a j-a valoare de pe linie
      • unde copiam?
        • de pe pozitia $j + 1$ pe pozitia $j$

Mai jos se afla o implementare simplista in C++ care cuprinde toate etapele pe care trebuie sa le realizati in cod, dupa ce stiti cum arata recurenta sub forma matriceala.

#define MOD  1009
#define KMAX 4
 
// C = A * B
void multiply_matrix(int A[KMAX][KMAX], int B[KMAX][KMAX], int C[KMAX][KMAX]) {
    int tmp[KMAX][KMAX];
 
    // tmp = A * B
    for (int i = 0; i < KMAX; ++i) {
        for (int j = 0; j < KMAX; ++j) {
            unsigned long long sum = 0; // presupun ca suma  incape pe 64 de biti
 
            for (int k = 0; k < KMAX; ++k) {
                sum += 1LL * A[i][k] * B[k][j];
            }
 
            tmp[i][j] = sum % MOD;
        }
    }
 
    //  C = tmp
    memcpy(C, tmp, sizeof(tmp));
}
 
// R = C^p
void power_matrix(int C[KMAX][KMAX], int p, int R[KMAX][KMAX]) {
    // tmp = I (matricea identitate)
    int tmp[KMAX][KMAX];
    for (int i = 0; i < KMAX; ++i) {
        for (int j = 0; j < KMAX; ++j) {
            tmp[i][j] = (i == j) ? 1 : 0;
        }
    }
 
    while (p != 1) {
        if  (p % 2 == 0) {
            multiply_matrix(C, C, C);     // C = C*C
            p /= 2;                       // ramane de calculat C^(p/2)
        } else {
            // reduc la cazul anterior:
            multiply_matrix(tmp, C, tmp); // tmp = tmp*C
            --p;                          // ramane de calculat C^(p-1)
        }
    }
 
    // avem o parte din rezultat in C si o parte in tmp
    multiply_matrix(C, tmp, R);           // rezultat = tmp * C
}
 
int garduri_rapide(int n) {
    // cazurile de baza
    if (n <= 3) return 1;
    if (n == 4) return 2;
 
    // construiesc matricea C
    int C[KMAX][KMAX] = { {0, 0, 0, 1},
                          {1, 0, 0, 0},
                          {0, 1, 0, 0},
                          {0, 0, 1, 1}};
   // vreau sa aplic formula S_n = S_4 * C^(n-4)
 
   // C = C^(n-4)
   power_matrix(C, n - 4, C);
 
   // sol = S_4 * C = dp[n] (se afla pe ultima pozitie din S_n,
   // deci voi folosi ultima coloana din C)
   int sol = 1 * C[0][3] + 1 * C[1][3] + 1 * C[2][3] + 2 * C[3][3];
   return sol % MOD;
}

In arhiva demo-lab04.zip gasiti o sursa completa in care se realizeaza:

• o verificare a faptului ca cele 2 implementari ( gardurile_lui_Gigel si garduri_rapide) produc aceleasi rezultate
• un benchmark in care cele 2 implementari sunt comparate
  • pe sistem uzual (laptop) s-au obtinut urmatoarele rezulate:

test case: varianta simpla
n = 100000000 sol = 119; time = 0.984545 s
test case: varianta rapida
n = 100000000 sol = 119; time = 0.000021 s
 
 
test case: varianta simpla
n = 1000000000 sol = 812; time = 9.662377 s
test case: varianta rapida
n = 1000000000 sol = 812; time = 0.000022 s

• se observa clar diferenta intre cele 2 solutii (am confirmat ceea ce spunea si teoria: $O(n) $ vs $O(log(n))$); aceasta tehnica imbunatateste drastic o solutie gasita relativ usor.