Originariamente inviato da xglobusx
si è vero non ho spiegato tutto.
va bene qualsiasi percorso (uno solo se ne sono 2 o più), si può passare più volte sulla stessa casella e ci si può muovere in tutte le direzioni, ma non in diagonale.
la somma deve fare 250 e tale percorso esiste sicuramente, almeno uno.
Ok, allora innanzitutto io sono riuscito a scrivere la funzione (ed è più semplice e lineare della tua) ... naturalmente non la posto per ovvi motivi ...

Vediamo però di fare alcune considerazioni: questo è un classico problema di ricerca in "profondità". Che si risolve molto bene appunto con una funzione ricorsiva.

Senza avere altre specifiche più precise legate alla ottimizzazione della ricerca come ad esempio "cercare il percorso più breve" oppure "cercare il percorso per cui non si ripassa sulla stessa casella" o altre specifiche del genere, si rischia di ottenere la soluzione più "stupida" e banale. Quella più "grezza" cioè.

Spiego meglio: la funzione deve essere tale per cui se con la somma del valore della cella referenziata in quel momento non si raggiunge 250, allora bisogna "provare" con altre celle.
Ora, escludendo come hai detto i movimenti in diagonale, risulta che da una cella puoi muoverti in 4 direzioni, con la eccezione di bordi e angoli, per cui rispettivamente si possono avere solo 3 o 2 movimenti.

Ora ... le chiamate in modo ricorsivo per provare altre celle le si dovrà fare in un certo ordine, no? Immaginiamo ad esempio:

codice:
if (posso_andare_a_destra) { func (..... r, c+1, ...); }
if (posso_andare_in_basso) { func (..... r+1, c, ...); }
if (posso_andare_a_sinistra) { func (..... r, c-1, ...); }
if (posso_andare_in_alto) { func (..... r-1, c, ...); }
Cosa succede con una cosa del genere? Che partendo da (0,0) il primo path sarà sempre quello di andare a destra ... finché o si è raggiunta la colonna più a destra o la somma calcolata più in profondità va oltre 250 e quindi si "torna indietro" cercando altre strade.

Nella mia funzione ho voluto far stampare il path che ha avuto successo. Essendo in ricorsione, la prima cella stampata è l'ultima trovata:

codice:
[0][5] = 6    (sum=250)
[1][5] = 4    (sum=244)
[1][6] = 45   (sum=240)
[1][5] = 4    (sum=195)
[1][6] = 45   (sum=191)
[0][6] = 75   (sum=146)
[0][5] = 6    (sum=71)
[0][4] = 41   (sum=65)
[0][3] = 5    (sum=24)
[0][2] = 1    (sum=19)
[0][1] = 17   (sum=18)
[0][0] = 1    (sum=1)
Cosa noti? che la funzione ha fatto la cosa più stupida, ovvero partendo da [0][0] è andato sempre verso destra. L'ultimo valore nell'angolo [0][7] (54) non l'ha preso perché più in profondità deve aver superato 250. Quindi è andato sulla riga sotto e si è messo a "ballare" tra la cella [1][5] e [1][6]. Arrivato prossimo a 250, la prima cella che ha trovato che forniva il totale di 250 è stata la cella [0][5].

Questo è successo in sostanza perché non sono stati inseriti criteri di ottimizzazione e perché la visita nelle altre celle adiacenti è "pilotata" con una sequenza precisa nel codice.