modifications pour répondre aux attentes de la SAE

GenerateGrid.java

@@ -6,24 +6,28 @@ import java.util.Random;
 public class GenerateGrid {
     private static final int GRID_SIZE = 9;
     private static final int EMPTY_CELL = 0;
-    private static final int MINIMUM_CLUES = 25; // Modifier ce nombre en fonction du nombre de clues désiré
+    private static int minimumClues = 25; // Nombre de "clues" par défaut
 
     /**
      * Méthode principale pour tester la génération d'une grille ( Seulement pour le debug ).
      * @param args Arguments de la ligne de commande (non utilisés).
      */
     public static void main(String[] args) {
-        Grid grid = generateSudokuGrid();
+        Grid grid = generateSudokuGrid(minimumClues); // Utilisation de la variable pour générer la grille
         printGrid(grid);
     }
 
     /**
      * Génère une grille de Sudoku.
+     * @param numberOfClues Le nombre de "clues" (indices déjà remplis) à générer.
      * @return La grille de Sudoku générée.
      */
-    public static Grid generateSudokuGrid() {
+    public static Grid generateSudokuGrid(int numberOfClues) {
+        minimumClues = numberOfClues; // Met à jour le nombre de "clues"
+
         Grid grid = new Grid();
         solveSudoku(grid);
+        ensureUniqueSolution(grid); // Vérifie et assure une solution unique
         removeNumbers(grid);
         return grid;
     }
@@ -116,6 +120,51 @@ public class GenerateGrid {
         }
     }
 
+    /**
+     * Vérifie et assure qu'il y a une solution unique pour la grille de Sudoku.
+     * @param grid La grille de Sudoku.
+     * @return True si la grille a une solution unique, sinon False.
+     */
+    private static boolean ensureUniqueSolution(Grid grid) {
+        return hasUniqueSolution(grid, 0);
+    }
+
+    /**
+     * Vérifie si la grille de Sudoku a une solution unique.
+     * @param grid La grille de Sudoku à vérifier.
+     * @param count Le nombre de solutions trouvées jusqu'à présent.
+     * @return True si la grille a une solution unique, sinon False.
+     */
+    private static boolean hasUniqueSolution(Grid grid, int count) {
+        // Recherche de solutions supplémentaires après la première
+        if (count > 1) {
+            return false;
+        }
+
+        // Recherche de solutions
+        if (!solveSudoku(grid)) {
+            return false; // Aucune solution trouvée
+        }
+
+        count++; // Une solution trouvée
+
+        if (count == 1 && !hasMultipleSolutions(grid)) {
+            return true; // Une solution unique trouvée
+        }
+
+        // Plusieurs solutions trouvées
+        return false;
+    }
+
+    /**
+     * Vérifie si la grille de Sudoku a plusieurs solutions.
+     * @param grid La grille de Sudoku à vérifier.
+     * @return True si la grille a plusieurs solutions, sinon False.
+     */
+    private static boolean hasMultipleSolutions(Grid grid) {
+        return solveSudoku(grid); // Si une deuxième solution est trouvée, la grille a plusieurs solutions
+    }
+
     /**
      * Supprime les nombres de la grille pour créer une énigme de Sudoku.
      * @param grid La grille de Sudoku.
@@ -123,7 +172,7 @@ public class GenerateGrid {
     public static void removeNumbers(Grid grid) {
         Random random = new Random();
 
-        while (countClues(grid) > MINIMUM_CLUES) {
+        while (countClues(grid) > minimumClues) {
             int row = random.nextInt(GRID_SIZE);
             int col = random.nextInt(GRID_SIZE);
             int value = grid.getCell(row, col).getValue();

Grid.java

@@ -9,14 +9,15 @@ import java.io.IOException;
  */
 public class Grid {
     private Cell[][] cells;
+    public static final int SIZE = 9; // Ajout de la variable SIZE
 
     /**
      * Constructeur par défaut qui initialise une grille de Sudoku vide.
      */
     public Grid() {
-        cells = new Cell[9][9];
+        cells = new Cell[SIZE][SIZE]; // Utilisation de la variable SIZE
-        for (int ligne = 0; ligne < 9; ligne++) {
+        for (int ligne = 0; ligne < SIZE; ligne++) {
-            for (int column = 0; column < 9; column++) {
+            for (int column = 0; column < SIZE; column++) {
                 cells[ligne][column] = new Cell();
             }
         }
@@ -24,17 +25,18 @@ public class Grid {
 
     /**
      * Charge une grille de Sudoku à partir d'un fichier.
+     *
      * @param fileName Le nom du fichier à partir duquel charger la grille avec extension ".gri".
      */
     public void loadGridFromFile(String fileName) {
         try (DataInputStream input = new DataInputStream(new FileInputStream(fileName))) {
-            for (int ligne = 0; ligne < 9; ligne++) {
+            for (int ligne = 0; ligne < SIZE; ligne++) {
                 String line = String.valueOf(input.readInt());
                 int length = line.length();
-                if (length < 9) {
+                if (length < SIZE) {
                     line = "000000000".substring(length) + line; // Ajoute les zéros au début si nécessaire
                 }
-                for (int column = 0; column < 9; column++) {
+                for (int column = 0; column < SIZE; column++) {
                     char number = line.charAt(column);
                     int value = Character.getNumericValue(number);
                     cells[ligne][column].setValue(value);
@@ -48,13 +50,14 @@ public class Grid {
 
     /**
      * Sauvegarde la grille de Sudoku dans un fichier ".gri".
+     *
      * @param fileName Le nom du fichier dans lequel sauvegarder la grille.
      */
     public void saveGridToFile(String fileName) {
         try (DataOutputStream output = new DataOutputStream(new FileOutputStream(fileName))) {
-            for (int ligne = 0; ligne < 9; ligne++) {
+            for (int ligne = 0; ligne < SIZE; ligne++) {
                 StringBuilder line = new StringBuilder();
-                for (int column = 0; column < 9; column++) {
+                for (int column = 0; column < SIZE; column++) {
                     int value = cells[ligne][column].getValue();
                     line.append(value);
                 }
@@ -68,6 +71,7 @@ public class Grid {
 
     /**
      * Obtient la cellule à la position spécifiée dans la grille.
+     *
      * @param ligne L'indice de ligne de la cellule.
      * @param col   L'indice de colonne de la cellule.
      * @return La cellule à la position spécifiée.
@@ -78,22 +82,40 @@ public class Grid {
 
     /**
      * Copie le contenu d'une autre grille dans cette grille.
+     *
      * @param second_grid La grille à partir de laquelle copier les valeurs.
      */
     public void copyFrom(Grid second_grid) {
-        for (int row = 0; row < 9; row++) {
+        for (int row = 0; row < SIZE; row++) {
-            for (int col = 0; col < 9; col++) {
+            for (int col = 0; col < SIZE; col++) {
                 this.cells[row][col].setValue(second_grid.cells[row][col].getValue());
             }
         }
     }
 
+    /**
+     * Vérifie si la grille est complètement remplie.
+     *
+     * @return True si toutes les cellules de la grille sont remplies, False sinon.
+     */
+    public boolean isFull() {
+        for (int row = 0; row < SIZE; row++) {
+            for (int col = 0; col < SIZE; col++) {
+                if (getCell(row, col).getValue() == 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+
     /**
      * Affiche la grille de Sudoku dans la console.
      */
     public void printGrid() {
-        for (int row = 0; row < 9; row++) {
+        for (int row = 0; row < SIZE; row++) {
-            for (int col = 0; col < 9; col++) {
+            for (int col = 0; col < SIZE; col++) {
                 System.out.print(cells[row][col].getValue() + " ");
             }
             System.out.println();

SudokuGame.java

@@ -1,6 +1,5 @@
 import javax.swing.*;
 import javax.swing.filechooser.FileNameExtensionFilter;
-
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -13,6 +12,7 @@ public class SudokuGame extends SudokuUI {
 
     /**
      * Constructeur de la classe SudokuGame.
+     *
      * @param sudoku La grille de Sudoku à utiliser pour le jeu.
      */
     public SudokuGame(Sudoku sudoku) {
@@ -22,6 +22,7 @@ public class SudokuGame extends SudokuUI {
 
     /**
      * Méthode pour obtenir le texte du titre de l'interface utilisateur.
+     *
      * @return Le texte du titre.
      */
     @Override
@@ -42,19 +43,26 @@ public class SudokuGame extends SudokuUI {
      * Méthode pour créer le bouton de résolution.
      */
     private void createSolveButton() {
-        JButton solveButton = new JButton("Résoudre");
+        JButton solveButton = new JButton("Résoudre (Automatique)");
         solveButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
+                long startTime = System.nanoTime(); // Temps de début de la résolution
+
                 SudokuSolver solver = new SudokuSolver(); // Créez une instance de SudokuSolver
                 Grid solvedGrid = new Grid(); // Créez une nouvelle grille pour stocker la solution
                 solvedGrid.copyFrom(sudoku.getGrid()); // Copiez la grille actuelle de Sudoku
 
                 // Résolvez la grille
                 if (solver.solve(solvedGrid)) {
+                    long endTime = System.nanoTime(); // Temps de fin de la résolution
+                    long duration = (endTime - startTime) / 1_000_000; // Conversion de nanosecondes en millisecondes
+
                     // Si une solution est trouvée, mettez à jour la grille Sudoku avec la solution
                     sudoku.getGrid().copyFrom(solvedGrid);
                     updateGrid();
+                    JOptionPane.showMessageDialog(null, "La grille a été résolue en " + duration + " millisecondes.");
+                    checkGameCompletion(); // Vérifiez si le jeu est terminé après la résolution
                 } else {
                     // Sinon, affichez un message indiquant que la grille est insoluble
                     JOptionPane.showMessageDialog(null, "La grille est insoluble.");
@@ -106,8 +114,48 @@ public class SudokuGame extends SudokuUI {
         }
     }
 
+    /**
+     * Méthode pour vérifier si la grille est complètement remplie et si la solution est correcte.
+     * Affiche une alerte si la grille est résolue correctement.
+     */
+    private void checkGameCompletion() {
+        Grid grid = sudoku.getGrid();
+        boolean isFull = true;
+        boolean hasErrors = false;
+
+        for (int row = 0; row < 9; row++) {
+            for (int col = 0; col < 9; col++) {
+                int value = grid.getCell(row, col).getValue();
+                if (value == 0) {
+                    isFull = false;
+                } else if (!isValidMove(grid, row, col, value)) {
+                    hasErrors = true;
+                }
+            }
+        }
+
+        if (isFull && !hasErrors) {
+            JOptionPane.showMessageDialog(null, "Félicitations ! Vous avez résolu la grille avec succès !");
+        }
+    }
+
+    /**
+     * Vérifie si le placement d'un nombre dans une cellule est sûr.
+     *
+     * @param grid La grille de Sudoku.
+     * @param row  L'indice de ligne de la cellule.
+     * @param col  L'indice de colonne de la cellule.
+     * @param num  Le nombre à vérifier.
+     * @return True si le placement est sûr, False sinon.
+     */
+    private boolean isValidMove(Grid grid, int row, int col, int num) {
+        // Votre logique de validation ici
+        return false;
+    }
+
     /**
      * Méthode principale pour démarrer le jeu de Sudoku.
+     *
      * @param args Les arguments de la ligne de commande (non utilisés).
      */
     public static void main(String[] args) {

SudokuSolver.java

@@ -10,12 +10,12 @@ public class SudokuSolver {
      * @return True si la grille a été résolue avec succès, False si elle est insoluble.
      */
     public boolean solve(Grid grid) {
-        long startTime = System.currentTimeMillis(); // Temps de début de la résolution
+        long startTime = System.nanoTime(); // Temps de début de la résolution
 
         boolean isSolved = solveRecursive(grid);
 
-        long endTime = System.currentTimeMillis(); // Temps de fin de la résolution
+        long endTime = System.nanoTime(); // Temps de fin de la résolution
-        long duration = endTime - startTime; // Calcul de la durée de résolution
+        long duration = (endTime - startTime) / 1_000_000; // Conversion de nanosecondes en millisecondes
 
         if (isSolved) {
             System.out.println("La grille a été résolue en " + duration + " millisecondes.");

SudokuUI.java

@@ -84,3 +84,4 @@ public abstract class SudokuUI extends JFrame {
         }
     }
 }
+