Queens Problem: Only Works Up to 5

Question

Hello there,
I've been searching through the forums for help on this problem, and can't find someone who has done this similarly to me. I am working on the N queens problem, and have it working for 1-5. Once it hits 6 and above, it always returns false. This is my coding for it: package ass2;
public class Queens {
     // squares per row or column
     public int BOARD_SIZE = 6;
     private int board[];
     public Queens() {
          board = new int[BOARD_SIZE];
     public void clearBoard() {
          //Clears the board
          //Precondition: None
          //Postcondition: Sets all squares to EMPTY
          board = new int[BOARD_SIZE];
     public void displayBoard() {
          //Displays the board
          //Precondition: None
          //Postcondition: Board is written to standard output; zero is an empty
          //square, one is a square containing a queen.
          for (int counter = 0; counter < BOARD_SIZE; counter++) {
               for (int counter2 = 0; counter2 < BOARD_SIZE; counter2++) {
                    if (board[counter2] == counter) {
                         System.out.print("Q");
                    } else {
                         System.out.print("*");
               System.out.println("");
     public boolean placeQueens(int column) {
          //Places queens in columns of the board beginning at the column specified
          //Precondition: Queens are placed correctly in columns 1 through Column - 1
          //Postcondition: If a solution is found, each column of the board contains
          //one queen and the method returns true; otherwise, returns false (no solution
          //exists for a queen anywhere in column specified)
          if (column > BOARD_SIZE) {
               return true;
          } else {
               boolean queenPlaced = false;
               int row = 1; // number of square in column
               while (!queenPlaced && (row <= BOARD_SIZE)) { //if squares can be attacked
                    if (isUnderAttack(row, column)) {
                         ++row;
                    } else {
                         setQueen(row, column);
                         queenPlaced = placeQueens(column+1);
                         // if no queens is possible in next column
                         if (!queenPlaced) {
                              // backtrack: remove queen placed earlier and try next column
                              removeQueen(row, column);
                              ++row;
               return queenPlaced;
     public void setQueen(int row, int column) {
          //Sets a queen at square indicated by row and column
          //Precondition: None
          //Postcondition: Sets the square on the board in a given row and column to QUEEN
          board[column-1] = (row-1);
     public void removeQueen(int row, int column) {
          //Removes a queen at square indicated by row and column
          //Precondition: None
          //Postcondition: Sets the square on the board in a given row and column to EMPTY
          board[column-1] = 0;
     public boolean isUnderAttack(int row, int column) {
          //determines whether the square on the board at a given row and column is under attack
          //by any queens in the columns 1 through column-1
          //Precondition: Each column between 1 and column-1 has a queen placed in a square
          //at a specific row.  None of these queens can be attacked by any other queen
          //Postcondition: If the designated square is under attack, returns true; otherwise,
          //returns false.
          boolean underAttack = false;
          int start = 1;
          int result = 0;
               while ((!underAttack) && (start < column)) {
                    if (board[start-1] == (row-1)) {
                         underAttack = true;
                    start++;
          start = 1;
               while ((!underAttack) && (start < column)) {
                    try
                    result = (board[start-1] - (row - 1)) / ((start -1) - (column-1));
                    // result calculates the slope between the two points.
                    } catch(ArithmeticException e) {
                         result = 0;
                    if ((result == -1) || (result == 1)) {
                         underAttack = true;
                    start++;
          if (underAttack) {
               // System.out.println("Column: " + column + "Row: " + row);
               return true;
          } else {
          // System.out.println("Column: " + column + "Row: " + row);
          return false;
} The main method running it is simple and is: package ass2;
public class Assignment2 {
      * @param args
     public static void main(String[] args) {
          Queens aQueen = new Queens();
          System.out.println(aQueen.placeQueens(1));
          aQueen.displayBoard();
}Any suggestions would be greatly appreciated.
Steven
P.S. I know how annoying it is to see this topic again, sorry.

Answer 1

Hi, try in isUnderAttack(..)
double result = 0;
result = (double)(board[start-1] - (row - 1)) / (double)((start -1) - (column-1));