Problema nu a fost foarte grea avand in vedere ca exista o metoda destul
   de simpla si foarte eficienta de rezolvare.
   Aceasta era:
     - folosim o matrice auxiliara B (avand dimeniunile matricii A),
       B(i,j) retinand numarul maxim de pasi cu care am putut ajunge in
       punctul (i,j)
     - iterativ, cat timp mai exista modificari, pornim de la elementul
       cu valoarea cea mai mica (element neselectat pana la momentul
       respectiv) si incercam sa urcam in matrice. Daca am ajuns intr-un
       anumit punct (i,j) al matricii cu un numar de pasi mai mare decat
       numarul de pasi inregistrat in b(i,j), modificam valoarea lui b(i,j)
       si ne continuam "urcarea" in matrice; in caz contrar, ne oprim.

     Algoritmul in pseudocod este urmatorul:
     B=0 // B este matricea nula
     cat timp s-au mai facut modificari
       {
        selectez elementul de valoare minima (xmin,ymin)
        rec(xm,ym,0)
       }

     procedura recursiva rec este:
     rec(x,y,k) // k este numarul de pasi cu care am ajuns in punctul (x,y)
     {
      daca B(x,y)<k
      {
        B(x,y)=k;
        rec(x+1,y,k+1);
        rec(x-1,y,k+1);
        rec(x,y+1,k+1);
        rec(x,y-1,k+1);
      }
     }

     Acest algoritm are complexitatea medie O(n^3), desi poate ajunge pe
cazul cel mai nefavorabil la O(n^4).

     Algorimul optim de rezolvare este unul de complexitate O(n^2 log n).
Este un algoritm "destept", si ii felicit pe cei cativa care l-au gasit (care
nu sunt obligatoriu cei din capul clasamentului; asa ca, cei care au obtinut
punctaj maxim pe aceasta problema, fara a folosi unul din cei doi algoritmi
descrisi aici, sunt rugati sa-si posteze solutia pe lista).
     Algoritmul incepea prin sortarea elementelor matricii in ordine cresca-
toare a valorii elementelor.
     Apoi parcurgem aceste elemente sortate si pentru fiecare element (i,j)
realizam urmatoarele:
    {
      daca unul dintre cei 4 vecini este mai mic decat el atunci,
          daca B(i,j)<B(i+1,j)+1
               atunci B(i,j)=B(i+1,j)+1; // exemplu pentru vecinul "de sus"
      // matricea B are aceasi semnificatie ca si la primul algoritm
    }

    In acest caz nu este suficienta decat o singura parcurgere a vectorului
sortat, deoarece in mod sigur elementele mai mici decat elementul curent au
fost prelucrate inaintea acestuia (ceea ce nu se intampla si la primul
algoritm).
    Cam asta este.