debut phase2

Makefile

@@ -9,11 +9,11 @@
 
 all: phase1 phase2
 
-phase1: src/main.ml
-	ocamlc $^ -o build/a.out
+phase1: src/phase1.ml
+	ocamlc $^ -o build/phase1.out
 
-phase2: 
-	echo TODO
+phase2: src/phase2.ml
+	ocamlc $^ -o build/phase2.out
 
 clean:
 	rm -rf *.cmi *.cmo

src/main.ml → src/phase1.ml

 (*
- * fichier : main.ml
+ * fichier : phase1.ml
  * auteur : dubard loïc
  *)
 
@@ -116,7 +116,6 @@ let plus_courts_chemins s p c =
     in
     remplissage liste distances minimum
 
-(* TODO : ne pas oublier de supprimer les chemins qui n'arrive pas à puits *)
 
 (* test du dénombrement de l'ensemble des chemins possibles *)
 let _ = 

src/phase2.ml

+(*
+ * fichier : phase2.ml
+ * auteur : dubard loïc
+ *)
+
+ (*
+ * définition du type graphe qui est une map de liste dont les clés sont des string
+ *)
+module Graphe = Map.Make(String)
+module Arreteliste = Map.Make(String)
+module Clesliste = Set.Make(String)
+
+
+(*
+ * @ensures : vérification du nombre d'agruments
+ * @raises : erreur si le nombre d'aguments est différent de 1
+ *)
+let _ = if Array.length Sys.argv = 1
+    then failwith "Erreur : Veuillez ajouter un nom de fichier !\n"
+    else if Array.length Sys.argv > 2
+    then failwith "Erreur : Trop d'arguments !\n"
+    else Printf.printf "ouverture de : %s\n" Sys.argv.(1)
+
+(*
+ * @ensures : lit le fichier en entrée
+ * @raises : fail si le fichier n'est pas trouvé -> "No such file or directory"
+ *)
+let file = open_in Sys.argv.(1)
+let source = input_line file
+let puits = input_line file
+let n = input_line file
+
+
+(*
+ * [make_graphe n]  
+ * @ensures : retourne le "graphe" à n arrètes correspondant au fichier ouvert dans le channel file
+ *)
+let rec make_graphe n = 
+    let line = input_line file in
+    let l = String.split_on_char ' ' line in
+    match l with 
+    | [a ; b ; c] -> if n = 1
+        then (Graphe.add a (Arreteliste.add b c Arreteliste.empty) Graphe.empty)
+        else 
+            let g = make_graphe (n-1) 
+            in 
+            if (Graphe.mem a g)
+                then let l = Graphe.find a g in 
+                let f = Graphe.remove a g in
+                Graphe.add a (Arreteliste.add b c l) f
+                else Graphe.add a (Arreteliste.add b c Arreteliste.empty) g
+    | _ -> failwith("erreur dans le graphe !")
+
+(* 
+ * [liste_sommets g]
+ * @ensures : la listes des clés de la liste d'arrete g
+ *)
+ let liste_sommets g = 
+  let f k v a = k::a
+  in 
+  Arreteliste.fold f g []
+
+(* 
+ * [chemins s g] donne la liste de tous les chemins du graphe g partants de s, un chemin étant une liste de sommets
+ *)
+let rec chemins s g  = 
+  if (Graphe.mem s g) 
+  then 
+      let ng = Graphe.remove s g in
+      (*[f a] retourne la liste des chemins depuis a dans le graphe sans s *)
+      let f a = 
+          let l = chemins a ng in
+          (List.map (fun b -> if (List.mem a b) then b else a::b) l)
+      in
+      let toto = Graphe.find s g in
+      let tata = liste_sommets toto in
+      let titi = List.concat(List.map f tata) in
+      List.map (fun b -> if (List.mem s b) then b else s::b) titi
+  else [[s]]
+
+(*
+ * [filtre f t nl] pour une liste de chemins nl renvois uniquement la liste des chemins partants de f et arrivants à t 
+ * un chemin étant une liste de sommets
+ *)
+let rec filtre f t nl = match nl with
+  | [] -> []
+  | elt::ma -> if (List.nth elt 0) = f && (List.nth elt ((List.length elt)-1)) = t then elt::(filtre f t ma) else (filtre f t ma)
\ No newline at end of file