diff --git a/src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java b/src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java index ae9e29b..2c44b4a 100644 --- a/src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java +++ b/src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java @@ -5,13 +5,20 @@ import java.util.List; public class Chessboard { public static final int SIZE = 8; - private final int[][] gameBoard = new int[SIZE][SIZE]; + public static int currentSize; + private final int[][] gameBoard; private final List queensPosition = new ArrayList<>(); private static final String ANSI_RED = "\u001B[31m"; private static final String ANSI_RESET = "\u001B[0m"; public Chessboard() { - // Constructeur vide + this.gameBoard = new int[SIZE][SIZE]; + currentSize = SIZE; + } + + public Chessboard(int size) { + this.gameBoard = new int[size][size]; + currentSize = size; } public void placeQueen(int x, int y) { @@ -27,7 +34,7 @@ public class Chessboard { } public Boolean VerifAccessible(int x, int y) { - for (int i = 0; i < SIZE; i++) { + for (int i = 0; i < currentSize; i++) { int diagonaleAscendante = y - (x - i); int diagonaleDescendante = y + (x - i); if (gameBoard[i][y] != 0) { @@ -36,10 +43,10 @@ public class Chessboard { if (gameBoard[x][i] != 0) { return false; } - if (diagonaleAscendante >= 0 && diagonaleAscendante < SIZE && gameBoard[i][diagonaleAscendante] == 1) { + if (diagonaleAscendante >= 0 && diagonaleAscendante < currentSize && gameBoard[i][diagonaleAscendante] == 1) { return false; } - if (diagonaleDescendante >= 0 && diagonaleDescendante < SIZE && gameBoard[i][diagonaleDescendante] == 1) { + if (diagonaleDescendante >= 0 && diagonaleDescendante < currentSize && gameBoard[i][diagonaleDescendante] == 1) { return false; } } @@ -50,8 +57,8 @@ public class Chessboard { return queensPosition.size(); } public void printChessboard() { - for (int i = 0; i < SIZE; i++) { - for (int j = 0; j < SIZE; j++) { + for (int i = 0; i < currentSize; i++) { + for (int j = 0; j < currentSize; j++) { if (gameBoard[j][i] == 1) { System.out.print(ANSI_RED+"|♕|"+ANSI_RESET); } else{ diff --git a/src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java b/src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java index 70f7f56..c07c6ed 100644 --- a/src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java +++ b/src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java @@ -3,44 +3,67 @@ package fr.iut_fbleau.but3.dev6_2; public class EightQueensSolver { private Chessboard chessboard = new Chessboard(); + public Chessboard chessboard(){ + return chessboard; + } + public EightQueensSolver() { + } + public void setChessboard(Chessboard theChessboard) { + this.chessboard = theChessboard; } - public void main(String[] args){ + public static void main(String[] args){ + EightQueensSolver solver = new EightQueensSolver(); + System.out.println("Taille de l'echiquier : " + Chessboard.currentSize); - // Début de la résolution par méthode simplifiée - long startTimeSimSim = System.currentTimeMillis(); + //Chronometrage de la méthode à Victor + long time = 0; + for (int i = 0; i < 10; i++) { + solver.chessboard = new Chessboard(); + long startTime = System.currentTimeMillis(); + solver.Solver(0); + long endTime = System.currentTimeMillis(); + + time += endTime - startTime; + } + time /= 10; + + System.out.println("Temps moyen d'exécution Victor: " + (time) + " ms"); + solver.chessboard.printChessboard(); + + // Chronometrage de la méthode à Simon + time = 0; System.out.println("Début SimSim"); - System.out.println(SolverSim(0)); + for (int i = 0; i < 10; i++) { + solver.chessboard = new Chessboard(); + long startTime = System.currentTimeMillis(); + solver.SolverSim(0); + long endTime = System.currentTimeMillis(); + + time += endTime - startTime; + } + time /= 10; System.out.println("Fin SimSim"); - long endTimeSimSim = System.currentTimeMillis(); - System.out.println("Temps d'exécution SimSim: " + (endTimeSimSim - startTimeSimSim) + " ms"); - chessboard.printChessboard(); + System.out.println("Temps moyen d'exécution SimSim: " + (time) + " ms"); + solver.chessboard.printChessboard(); - chessboard = new Chessboard(); // Réinitialisation du plateau - - // Début de la résolution par méthode classique - long startTimeVictor = System.currentTimeMillis(); - System.out.println("Début Victor"); - System.out.println(Solver(0)); - System.out.println("Fin Victor"); - long endTimeVictor = System.currentTimeMillis(); - System.out.println("Temps d'exécution Victor: " + (endTimeVictor - startTimeVictor) + " ms"); - chessboard.printChessboard(); - + //Spoiler : c'est simsim qu'a la meilleure méthode :) } + - private Boolean Solver(int level) { - if (chessboard.getNumberOfQueen() == Chessboard.SIZE) { + // Méthode de résolution de victor + public Boolean Solver(int level) { + if (chessboard.getNumberOfQueen() == Chessboard.currentSize) { return true; } - for (int i = level*Chessboard.SIZE; i < Chessboard.SIZE * Chessboard.SIZE; i++) { - int x = i % Chessboard.SIZE; - int y = i / Chessboard.SIZE; + for (int i = level*Chessboard.currentSize; i < Chessboard.currentSize * Chessboard.currentSize; i++) { + int x = i % Chessboard.currentSize; + int y = i / Chessboard.currentSize; if (chessboard.VerifAccessible(x, y)) { chessboard.placeQueen(x, y); if (!Solver(y)) { @@ -53,18 +76,19 @@ public class EightQueensSolver { return false; } - private boolean SolverSim(int line){ - if(chessboard.getNumberOfQueen() == Chessboard.SIZE){ + // Méthode de résolution de Simon + public boolean SolverSim(int yPos){ + if(chessboard.getNumberOfQueen() == Chessboard.currentSize){ return true; } - for(int collumn = 0 ; collumn < Chessboard.SIZE ; collumn++){ - if(chessboard.VerifAccessible(collumn, line)){ - chessboard.placeQueen(collumn, line); - if(SolverSim(line+1)){ + for(int xPos = 0 ; xPos < Chessboard.currentSize ; xPos++){ + if(chessboard.VerifAccessible(xPos, yPos)){ + chessboard.placeQueen(xPos, yPos); + if(SolverSim(yPos+1)){ return true; } else{ - chessboard.removeQueen(collumn, line); + chessboard.removeQueen(xPos, yPos); } } } diff --git a/src/main/java/fr/iut_fbleau/but3/dev6_2/Etude.java b/src/main/java/fr/iut_fbleau/but3/dev6_2/Etude.java new file mode 100644 index 0000000..f9e8509 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev6_2/Etude.java @@ -0,0 +1,63 @@ +package fr.iut_fbleau.but3.dev6_2; + +public class Etude { + public static final int MAX_TIME = 1000; + + private Chessboard chessboard; + private int currentSize; + private EightQueensSolver solver; + public Etude() { + this.currentSize = 5; + this.solver = new EightQueensSolver(); + + } + + private void resetChessboard(){ + this.chessboard = new Chessboard(currentSize); + this.solver.setChessboard(this.chessboard); + } + + /** + * Etude de performance des différents solveurs sur des tailles croissantes de chessboards. + * Chaque taille est testée 10 fois et la moyenne du temps passé dessus par chaque solveur est indiquée en ms. + * La boucle de l'étude s'arrête lorsque le temps de résolution moyen dépasse les 1000ms. + * + * Un seul solveur est testé à la fois. Il suffit de commenter et décommenter une ligne au milieu de la méthode main pour qu'un autre solveur soit testé. + * Il vous reviens de noter les résultats de chaque solveur, aucune comparaison n'est faite dans ce code. + * + * Les chessboards de taille impaire sont bien plus rapides à résoudre que ceux de taille paire. + * Pour faire l'étude uniquement sur des tailles paires, une ligne est à décommenter à la fin de la méthode main. + */ + public static void _main(String[] args){ + Etude etude = new Etude(); + + int passedTime = 0; + while(passedTime < MAX_TIME){ + passedTime = 0; + + System.out.println("Taille de l'echiquier : " + etude.currentSize); + System.out.println("Début solveur"); + + for (int i = 0; i < 10; i++) { + long startTimeSimSim = System.currentTimeMillis(); + etude.resetChessboard(); + etude.solver.SolverSim(0); + //etude.solver.Solver(0); // décommenter cette ligne et commenter celle du dessus pour étudier l'autre solveur + long endTimeSimSim = System.currentTimeMillis(); + + passedTime += endTimeSimSim - startTimeSimSim; + } + passedTime /= 10; + + System.out.println("Fin solveur"); + System.out.println("Temps d'exécution moyen solveur: " + (passedTime) + " ms"); + + etude.chessboard.printChessboard(); + + + etude.currentSize ++; + // etude.currentSize ++; // décommenter cette ligne pour que seules les tailles de chessboard impaires soient testées + } + } + +} \ No newline at end of file