10. Динамично оптимиране - II

Числа на Фибоначи [8.3.1]

* Числа на Фибоначи: F(0) = F(1) = 1 и F(i) = F(i -1) + F(i - 2) за i > 1.

unsigned long fib(unsigned n) 
{  if (n < 2) return 1; 
   return fib(n - 1) + fib(n - 2); 
}

* Динамично програмиране - със запомняне на вече пресметнатите стойности:

#include <stdio.h> 
#define MAX 256 

unsigned n = 10; 
unsigned long m[MAX + 1];

unsigned long fibMemo(unsigned n) 
{ if (n < 2) m[n] = 1; 
  else if (0 == m[n]) m[n] = fibMemo(n - 1)+ fibMemo(n - 2); 
  return m[n];
}
int main() 
{ memset(m, 0, MAX*sizeof(*m)); 
  scanf("%u", &n); 
  printf("\n%u-тото число на Фибоначи e", %lu", n, fibMemo(n)); 
  return 0; 
}

Биномни коефициенти [8.3.2]

Нека C(n, k) е биномният коефициент "n над k" или комбинации без повторения от n елемента k-ти клас. 
Общата формула е: C(n, k) = n!/((n - k)! k!), а от триъгълника на Паскал имаме и рекурентна формула:

* Рекурсивен неефективен алгоритъм:

unsigned long binom(unsigned n, unsigned k)
{ if (k > n) return 0;
  if (k == 0 || k == n) return 1;
  return binom(n - 1, k - 1) + binom(n - 1, k); 
}

* Динамично програмиране - със запомняне на вече пресметнатите стойности. Не е необходимо да се пази цялата таблица C(n, k), а само един ред от таблицата - предишния.

#define MAX 200
unsigned long m[MAX];
unsigned long binomDynam(unsigned n, unsigned k)
{ unsigned i, j;
  for (i = 0; i <= n; i++)
  { m[i] = 1;
    if (i > 1)
    { if (k < i - 1) j = k; else j = i - 1;
      for (; j >= 1; j--) m[j] += m[j - 1];
    }
  }
  return m[k];
}

Най-дълга обща подредица [8.2.6]

Дадени са две редици (от числа или символи):

Търси се най-дълга редица Z = (z₁, z₂, ..., z_k), която е подредица на X  и Y едновременно. Z е подредица на  X, ако Z може да бъде получена чрез премахване на (0 или няколко) членове на X.

Най-напред ще търсим само дължината на най-дългата обща подредица. Ще приложим метода на динамичното оптимиране, като F(i, j) е търсената дължина за първите i члена на редицата X и първите j члена на редицата Y. Очевидно
    F(i,0) = 0 за всяко i, F(0, j) = 0 за всяко j.
    F(i, j) = F(i -1, j -1) + 1 за x_i = y_j,
    F(i, j) = max {F(i -1, j), F(i, j -1)} в противен случай.
Намираме последователно стойностите на F(i, j) и последната намерена стойност F(m,n) е решението на задачата.

Намирането на една най-дълга подредица (може да не е една) става по същия начин, като тръгваме от последния елемент и следим откъде идва максималната стойност.

// lsc.c
#include <stdio.h>
#include <string.h>
#define MAXN 100
#define MAX(a,b) (((a)>(b)) ? (a) : (b))

char F[MAXN][MAXN];
const char x[MAXN] = "acbcacbcaba";
const char y[MAXN] = "abacacacababa";
unsigned m,n;
/*
         "acb cacbcaba  " "a  cbcac bcaba"
         "a bacacacababa" "abacacacab aba"
solution "a b cac caba  " "a  c cac b aba"
*/
unsigned lcs_len(void)
{ unsigned i,j;
  for (i=0; i<=m; i++) F[i][0]= 0;
  for (j=0; j<=n; j++) F[0][j]= 0;
  for (i=1; i<=m; i++)
    for (j=1; j<=n; j++)
     if (x[i-1] == y[j-1]) F[i][j]=F[i-1][j-1]+1;
     else F[i][j] = MAX(F[i-1][j], F[i][j-1]);
return F[m][n];
}
void print(unsigned i, unsigned j)
{ if (i == 0 || j == 0) return;
  if (x[i-1] == y[j-1])
  { print(i-1,j-1);
    printf("%c", x[i-1]);
  }
  else if (F[i][j] == F[i-1][j]) print(i-1,j);
  else print(i,j-1);
}
int main()
{ m = strlen(x);
  n = strlen(y);
  printf("%u\n", lcs_len());
  print(m,n);
  return 0;
}