O problema com o algoritmo proposto é que ele identifica um quadrante da
matriz original que possui um pico.  Infelizmente, as chamadas
recursivas podem descartar o quadrante onde existe um pico.  Vamos
considerar a matriz abaixo (cortesia do Eduardo Campi), onde a linha e a
coluna central estão marcadas com tralhas (#):

0 0 0 0 0 1 0 0 1 0 0
0 0 0 0 0 1 0 0 1 0 0
0 0 0 0 0 1 1 1 1 1 1
0 0 0 0 0 1 0 0 2 3 0
0 0 0 0 0 1 7 1 1 4 0
1 1 1 1 1 1 6 1 1 5 1 #
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
          #

O maior elemento da cruz central é o 6, que não é pico pois tem um 7
como vizinho.  Logo, sabemos que o quadrante superior direito da matriz
contém um pico (por exemplo, 7).  O algoritmo será chamado
recursivamente na submatriz do canto superior esquerdo:

0 0 1 0 0
0 0 1 0 0
1 1 1 1 1 #
0 0 2 3 0
7 1 1 4 0
    #

Onde o máximo da cruz central é o 2, que não é pico pois tem um 3 como
vizinho.  Neste caso, o algoritmo proposto irá continuar recursivamente
sobre a submatriz no canto inferior direito:

3 0
4 0

Que não contém pico na matriz original.  O problema é que o pico está na
submatriz no canto inferior esquerdo:

0 0
7 1

Para resolver o problema, basta modificar o algoritmo para calcular o
maior elemento encontrado até um certo ponto e sempre continuar
recursivamente na submatriz que contém o maior elemento encontrado até
o momento.  A submatriz com o maior elemento encontrado até o momento
garantidamente possui um pico.

No caso, como 7 é maior do que 3, o algoritmo deve continuar
recursivamente na matriz

0 0
7 1,

em vez de

3 0
4 0.