Matrice, trajet

int ta_fonction()
{
if (tab[x + 1][y] && tab[x + 1][y] == '1')
{
if (x+1 = la dernière ligne de ton tableau)
	SUCCESS !
else
	rappel ta fonction avec tes nouvelles coordonnées
}

else if (tab[x - 1][y] && tab[x - 1][y] == '1')
{
if (x-1 = la dernière ligne de ton tableau)
	SUCCESS !
else
	rappel ta fonction avec tes nouvelles coordonnées
}

else if (tab[x][y - 1] && tab[x][y - 1] == '1')
{
	rappel ta fonction avec tes nouvelles coordonnées
}
else if (tab[x][y + 1] && tab[x][y + 1] == '1')
{
	rappel ta fonction avec tes nouvelles coordonnées
}
return (0);
}

public int estGagnant(){
		//Renvoit 0 si pas de gagnant, gagnant si on connecte les 2 bords
		//		  1 si Jaune gagne

		
		int resultat = -1;
		int j=0;
		
		int condition = 0;
		
		//Piles
		Pile pileI = new Pile();
		Pile pileJ = new Pile();
		Pile sommetSave = new Pile();
		 
		//On scan la première ligne pour trouver les 'j', on stocke les coordonnées dans les 2 piles
		for(int i=0;i<nbCases;i++){
			if(this.plateau[i][j] == 'j'){
				pileI.empiler(i);
				pileJ.empiler(j);
				sommetSave.empiler(i);
			}
		}
		//1er scan terminé
		
		while(condition == 0){
			//Case courante

			int iCourant = pileI.sommet();
			int jCourant = pileJ.sommet();
			int test=0;
			
			//Si case en dessous et jaune ET derniere ligne, partie gagnée pour Jaune !
			if((this.plateau[iCourant][jCourant+1] == 'j') && (jCourant+1 == nbCases)){
				return 1;
			}
			
			//Si une case a coté de la courante est jaune, on empile
			if((this.plateau[iCourant+1][jCourant] == 'j')
			&& (!dejaPresent(pileI,pileJ,iCourant+1,jCourant))){ //Case a droite de la courante
				test++;
				pileI.empiler(iCourant+1);
				pileJ.empiler(jCourant);
			}
			if(this.plateau[iCourant][jCourant+1] == 'j'
			&& (!dejaPresent(pileI,pileJ,iCourant,jCourant+1))){ //Case en bas de la courante
				test++;
				pileI.empiler(iCourant);
				pileJ.empiler(jCourant+1);
			}
			if(this.plateau[iCourant-1][jCourant] == 'j'
			&& (!dejaPresent(pileI,pileJ,iCourant-1,jCourant))){ //Case à gauche
				test++;
				pileI.empiler(iCourant-1);
				pileJ.empiler(jCourant);
			}
			if(this.plateau[iCourant][jCourant-1] == 'j'
			&& (!dejaPresent(pileI,pileJ,iCourant,jCourant-1))){ //Case au-dessus
				test++;
				pileI.empiler(iCourant);
				pileJ.empiler(jCourant-1);
			}
			
			//Si on enregistre 2 données, on sauvegarde le(s) sommet(s)
			while(test > 1){
				sommetSave.empiler(sommetSave.sommet()-(test+1));
				test--;
			}
			
			//Si pas de nouveau chemin
			if(test == 0){
				//Si en plus pas de résultat sauvegardé
				if(sommetSave.estVide()){
					condition = 1;
				}
				else{
					pileI.setSommet(sommetSave.sommet());
					pileJ.setSommet(sommetSave.sommet());
					sommetSave.depiler();
				}
			}
		}
		
		return resultat;
	}
	public boolean dejaPresent( Pile a, Pile b, int i, int j){
		//Fonction qui recherche dans a et b si i et j sont déja présent
		boolean result = false;
		while(a.estVide()){
			if((a.sommet() == i) && (b.sommet() == j))
				result = true;
			a.depiler();
			b.depiler();
		}
		return result;
	}

#include <stdio.h>
#include <stdlib.h>

#define LIGNE 8
#define COLON 7

int matrice [LIGNE][COLON] =
{ { 0, 0, 0, 0, 1, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 0 },
  { 0, 0, 0, 0, 0, 1, 0 },
  { 0, 0, 0, 0, 1, 1, 0 },
  { 0, 0, 0, 0, 1, 0, 0 },
  { 0, 0, 0, 1, 1, 1, 0 },
  { 0, 0, 1, 1, 0, 1, 0 },
  { 0, 0, 0, 0, 1, 1, 0 } };

int recursive (int matrice[][COLON], int colon, int nbLigne, int nbColon)
{
  if (!matrice[0][colon])
    return 0;  // Non trouvable
  // Recherche du '1' le plus à gauche
  while ( (colon) && matrice[0][colon-1])
    colon--;
  for (; (colon<nbColon) && matrice[0][colon]; colon++)
    if( (nbLigne == 1) || recursive(&matrice[1], colon, nbLigne-1, nbColon))
      return 1;   // Trouvé
  return 0;  // Non trouvé
}

int main()
 {
   int i, retour;
   for (i=0; i<COLON; i++)
     if( (retour = recursive(matrice, i, LIGNE, COLON)) )
     {
       printf("Trouvé départ=%d arrivée=%d!\n", i+1, retour);
       return (EXIT_SUCCESS);
     }
  printf("Non trouvé !\n");
  return (EXIT_FAILURE);
}

{ { 0, 1, 0, 0, 0, 0, 0 },
  { 0, 1, 0, 0, 0, 0, 0 },
  { 0, 1, 1, 0, 1, 1, 1 },
  { 0, 0, 1, 1, 1, 0, 1 },
  { 0, 0, 0, 0, 0, 0, 1 },
  { 0, 0, 0, 0, 1, 1, 1 },
  { 0, 0, 0, 1, 1, 0, 0 },
  { 0, 0, 0, 1, 0, 0, 0 } }

		int resultat = 0;
		int j=0;
		
		int condition = 0;
		
		//Piles
		Pile pileI = new Pile();
		Pile pileJ = new Pile();
		Pile sommetSave = new Pile();
		 
		//On scan la première ligne pour trouver les 'j', on stocke les coordonnées dans les 2 piles
		int var = 0;
		for(int i=0;i<nbCases;i++){
			if(this.plateau[i][j] == 'j'){
				pileI.empiler(i);
				pileJ.empiler(j);
				sommetSave.empiler(var);
				var++;
			}
		}
		
		int passage = 1;
		while(condition == 0){
			
			System.out.println("Passage dans la boucle no :"+passage);			
			
			int iCourant = pileI.sommet();
			int jCourant = pileJ.sommet();
			int test=0;
			
			//Si une case a coté de la courante est jaune, on empile
			if(iCourant<nbCases){
				if((this.plateau[iCourant+1][jCourant] == 'j')
				&& (!dejaPresent(pileI,pileJ,iCourant+1,jCourant))){ //Case a droite de la courante
					System.out.println("Case a droite detect");
					test++;
					pileI.empiler(iCourant+1);
					pileJ.empiler(jCourant);
				}
			}
			if(jCourant<nbCases){
				if(this.plateau[iCourant][jCourant+1] == 'j'
				&& (!dejaPresent(pileI,pileJ,iCourant,jCourant+1))){				//Case en bas de la courante
					//Case Gagnante
					System.out.println("jCourant+1 : "+jCourant);
					System.out.println("iCourant+1 : "+iCourant);
					if(jCourant+2 == nbCases){
						System.out.println("Jaune Gagne");
						condition = 1;
						resultat =  1;
					}
					System.out.println("Case en bas detect");
					test++;
					pileI.empiler(iCourant);
					pileJ.empiler(jCourant+1);
				}
			}
			if(iCourant>0){
				if(this.plateau[iCourant-1][jCourant] == 'j'
				&& (!dejaPresent(pileI,pileJ,iCourant-1,jCourant))){ //Case à gauche
					System.out.println("Case a gauche detect");
					test++;
					pileI.empiler(iCourant-1);
					pileJ.empiler(jCourant);
				}
			}
			if(jCourant > 0){
				if(this.plateau[iCourant][jCourant-1] == 'j'
				&& (!dejaPresent(pileI,pileJ,iCourant,jCourant-1))){ //Case au-dessus
					System.out.println("Case au dessus detect");
					test++;
					pileI.empiler(iCourant);
					pileJ.empiler(jCourant-1);
				}
			}
			
			System.out.println("Test : "+test);
			//Si on enregistre 2 données, on sauvegarde le(s) sommet(s)
			while(test > 1){
				sommetSave.empiler(sommetSave.sommet()-(test+1));
				System.out.println("Test 6");
				test--;
			}
			
			//Si pas de nouveau chemin
			if(test == 0){
				//Si en plus pas de résultat sauvegardé
				if(((sommetSave.sommet)-1) == 0){
					System.out.println("sommetSave vide, plus rien a analyser");
					condition = 1;
					//pain = 31;
				}
				else{
					sommetSave.depiler();
					System.out.println("Test 8");
					System.out.println("On setSommet a : "+sommetSave.sommet());
					pileI.setSommet(sommetSave.sommet());
					pileJ.setSommet(sommetSave.sommet());
					System.out.println("la new coordonnee est : ("+pileI.sommet()+","+pileJ.sommet()+")");
				}
			}
			passage++;
		}
		
		return resultat;