let rec resoud_naivement_aux ~printP ~liste_piece ~plateau ~icourant ~jcourant =
        myprint Verbeux_textuel ("\t$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
        myprint Verbeux_textuel ("\n#\nAppel a 'resoud_naivement_aux' avec  Indices : icourant="^(string_of_int icourant)^" et jcourant="^(string_of_int jcourant)^" !");
        myprint Verbeux_textuel "\t$\n\tLe plateau courant est :";
        if (Verbeux_textuel = Verbeux_textuel) then printP plateau;


(** ON FAIT UNE RECHERCHE A PRIORI TRES LONGUE. ICI ON S'ARRETE DES QU'ON A UNE SOLUTION. *)


        (try (est_valide_plateau plateau) with
                | Solution_trouvee -> raise (Solution_trouvee_arg(plateau));
                | Mauvais_tableau                -> ();
                | Erreur_compatibilite_h(_,_)        -> ();
                | Erreur_compatibilite_v(_,_)        -> ();
        );
(*        est_valide_plateau plateau;*)
(*        print_string (string_of_bool (est_valide_plateau plateau));*)
(*        read_line ();*)
        

(** Suppose que le plateau a la même taille que l'instance sur les trois paramètres c, n, m. En effet, cette fonction sera appelée ensuite avec un plateau vide créé par "creer_plateau_vide". *)


match liste_piece with
| []        ->
        myprint myverb ("\tLa liste de pièces est vide. On renvoit le plateau que l'on devait continuer de compléter. Il est sensé etre complet.");
        (* On a finit : on a placé toutes les pièces sur le plateau, le résultat est donc la liste contenant seulement le plateau courant. *)
        [plateau];
| _        ->
        myprint myverb ("\tLa liste de pièces n'est pas encore vide.");
        let liste_arguments_suivants = ref [] in
        let fauxi_ajoute piecex =
                (
                myprint myverb ("\t##\n\tAppel interne a 'fauxi_ajoute' avec la piece suivante :");
                if (myverb = Verbeux_textuel) then print_piece piecex;
                myprint myverb "\t$$\n\tLe plateau courant est :";
                if (myverb = Verbeux_textuel) then printP plateau;
                match        (est_rajoutable ~piece:piecex ~i:icourant ~j:jcourant ~pl:plateau) with
                | true -> 
                        myprint myverb ("\tLa piece est rajoutable.");
                        

(** On fait de la concaténation de listes : la complexité est très lourde (vraiment très lourde !) ! *)


                        liste_arguments_suivants := !liste_arguments_suivants @ [(argument_suivant ~printP:printP ~liste_piece:liste_piece ~plateau:plateau ~icourant:icourant ~jcourant:jcourant ~piece_choisie:piecex)];
                | false -> 
                        myprint myverb ("\tLa piece n'est pas rajoutable.");
                        ();
                )
        in
        List.iter fauxi_ajoute liste_piece;
        let fauxi_continue ( liste_piece_suivant, plateau_suivant, i_suivant, j_suivant) =
                myprint myverb ("\t###\n\tAppel interne a 'fauxi_continue' avec  Indices : icourant="^(string_of_int i_suivant)^" et jcourant="^(string_of_int j_suivant)^" !");
                (resoud_naivement_aux ~printP:printP ~liste_piece:liste_piece_suivant ~plateau:plateau_suivant ~icourant:i_suivant ~jcourant:j_suivant);
        in
        

(** On fait du List.concat : la complexité est très lourde (vraiment très lourde !) ! Je sais que pour améliorer, il faudrait utiliser des listes chainées. *)


        List.concat (List.map fauxi_continue !liste_arguments_suivants)