Bottom up

Buenas noches, tengo un problema en el que basicamente se me pide encontrar la cadena mas larga de vecinos que esten ordenados en donde los elementos adyacentes de una matriz NXN tienen una diferencia de +1.

Ejemplo:

10 16 15 12
9 8 7 13
2 5 6 14
3 4 1 11

Para la anterior matriz la solucion seria S = <2,3,4,5,6,7,8,9,10>, se me pide basicamente desarrollar el backtracking pero para llegar al bactracking debo seguir una serie de pasos:
1) Sol recursiva ingenua
2) Memoizacion
3) Bottom-up
4) Backtracking

Mi problema es a la hora de implementar el bottom-up, se supone que debo quitar las recursiones por ciclos para que sea de forma iterativa, sin embargo, no he podido implementarlo de esa forma.

No se si porfa me puedan dar alguna idea para solucionarlo con Bottom-up.

Código

unsigned int naive(vec T, unsigned int i, unsigned int j) {
  unsigned int _max = 0;
  if (T.empty())
    return 0;
  else {
    if (i < T.size() - 1 and T[i][j] == T[i + 1][j] + 1)
      _max = max(_max, naive(T, i + 1, j));
    if (j < T.size() - 1 and T[i][j] == T[i][j + 1] + 1)
      _max = max(_max, naive(T, i, j + 1));
    if (i > 0 and T[i][j] - 1 == T[i - 1][j])
      _max = max(_max, naive(T, i - 1, j));
    if (j > 0 and T[i][j] - 1 == T[i][j - 1])
      _max = max(_max, naive(T, i, j - 1));
  }
  return _max + 1;
}

Código

unsigned int memo(vec T, vec &M, unsigned int i, unsigned int j) {
  unsigned int _max = 0;
  if (T.empty())
    return 0;
  if (M[i][j] != 0)
    return M[i][j];
  else {
    if (i < T.size() - 1 and T[i][j] == T[i + 1][j] + 1)
      _max = max(_max, memo(T, M, i + 1, j));
    if (j < T.size() - 1 and T[i][j] == T[i][j + 1] + 1)
      _max = max(_max, memo(T, M, i, j + 1));
    if (i > 0 and T[i][j] - 1 == T[i - 1][j])
      _max = max(_max, memo(T, M, i - 1, j));
    if (j > 0 and T[i][j] - 1 == T[i][j - 1])
      _max = max(_max, memo(T, M, i, j - 1));
    M[i][j] = _max + 1;
  }
 
  return M[i][j];
}

Las dos implementaciones anteriores son las que hice ingenuamente y con memoizacion