/**
 * Stores information relevant to solving the n queens problem of placing n
 * queens on an n-by-n board.
 * @author  Stuart Reges
 */

public class Board {
   private int[] board;  // stores board info
   private static final int UNASSIGNED = 100; // unassigned column

   /**
   * Constructs an empty size-by-size board.
   *
   * @param     size   the size of the board.
   * @exception IllegalArgumentException if size is less than 1.
   */
   public Board(int size) {
      if (size < 0)
         throw new IllegalArgumentException();
      board = new int[size];
      for (int i = 0; i < size; i++)
         board[i] = UNASSIGNED;
   }

   /**
    * Returns <tt>true</tt> if it is safe to place a queen at position (row,
    *         col).
    *
    * @param row of position to check.
    * @param col column of position to check.
    * @return <tt>true</tt> if it is safe to place a queen at position (row,
    *         col).
    * @exception IllegalArgumentException if row and col do not represent a
    *                                     legal board position.
    */
   public boolean safe(int row, int col) {
      // first reset row and col to array range (0..size-1)
      row--;
      col--;
   
      // next check that row, col are in bounds
      if (!legal(row, col))
         throw new IllegalArgumentException();
   
      // next check that the current column is empty
      if (board[col] != UNASSIGNED)
         return false;
   
      // now check for conflicts with other columns
      for (int currCol = 0; currCol < board.length; currCol++) {
         int distance = col - currCol;
         // check for diagonal conflict
         if (board[currCol] == row - distance)
            return false;
         // check for conflict in this row
         if (board[currCol] == row)
            return false;
         // check for other diagonal conflict
         if (board[currCol] == row + distance)
            return false;
      }
      return true;
   }

   /**
    * Places a queen at position (row, col).
    *
    * @param row row of position to check.
    * @param col column of position to check.
    * @exception IllegalArgumentException if it is not safe to place a queen
    *                                     at the given position.
    */
   public void place(int row, int col) {
      if (!safe(row, col))
         throw new IllegalArgumentException();
      board[col - 1] = row - 1;
   }

   /**
    * Removes the queen at position (row, col).
    *
    * @param row row of position to check.
    * @param col column of position to check.
    * @exception IllegalArgumentException if there is no queen at the given
    *            position.
    */
   public void remove(int row, int col) {
      if (!legal(row - 1, col - 1) || board[col - 1] != row - 1)
         throw new IllegalArgumentException();
      board[col - 1] = UNASSIGNED;
   }

   /**
    * Returns the size of the board.
    *
    * @return the size of the board.
    */
   public int size() {
      return board.length;
   }

   /**
    * Displays the current board to System.out.
    */
   public void print() {
      for (int row = 0; row < board.length; row++) {
         for (int col = 0; col < board.length; col++)
            if (board[col] == row)
               System.out.print(" Q ");
            else
               System.out.print(" - ");
         System.out.println();
      }
      System.out.println();
   }

   /**
    * returns the row of the queen placed in this column (0-based), returning
    *  UNASSIGNED if no placed queen in the column
    *
    * @param col column to check (0-based)
    */
   protected int getQueenRowForColumn(int col) {
      return board[col];
   }

   // post: returns true iff row and col are legal for this board
   private boolean legal(int row, int col) {
      return row >= 0 && row < board.length && col >= 0 && col < board.length;
   }
}