# Génération de la grille

- Tableau de tableau de caractères
- On suppose un choix aléatoire entre A et Z pour chacune des NxN cases (mais on pourra
dans un second temps pondérer les probabilités etc…).
- Initialisation :
  On utilise
   Array.init : int -> (int -> 'a) -> 'a array
  ```
    Array.init n (fun _ ->
        Array.init n (fun _ ->
            Renvoyer un caractère aléatoire entre A et Z
        )
    )
  ```


# Affichage de la grille
(facile)

# Résolution

On souhaite afficher tous les mots que l'on peut former sur la grille
à partir des règles du Boggle et qui sont aussi présents dans un fichier
de référence (`french_simple.txt`).

On suppose tous les mots sans accents et en majuscule (caractères A - Z).

On construit un trie contenant les mots du dictionnaires (dico).

- On utilise un tableau de booléens pour marquer les visités
- (ou) Table de hachage des coordonnées (i,j) des visités
- (ou) un Set (ABR) des coordonnées (i,j) des visités

```

let rec trouver_mots f trie visite grille mot (i, j) =
    let c = grille.(i).(j) in
    let mot = c :: mot in
    let Node (_, l) = trie in
    let trie_c = le sous trie dans l associé à c in (* si aucun s'arrêter *)
    let Node (b, _) = trie_c in
    if b then f mot (* afficher le mot courant *)

   (* let visite2 = ajouter (i,j) dans visite in *)
    ajouter (i, j) dans visite
    pour chaque voisin de i,j de coordonnée i', j' qui n'est pas dans visite
        (* on s'arrête si la boucle est vide, i.e. plus de voisins non visités *)
        trouver_mots trie_c visite grille mot (i', j')

    retirer (i, j) de visite

let main () =

for i = 0 to n - 1 do
    for j = 0 to n - 1 do
        trouver_mots affiche_mot dico ensemble_vide grille  [] (i,j)
    done
done
```