public class Board {
    /**
     * Creates an 8-by-8 board
     */
    public Board() {

    }

    /**
     * Creates an N-by-N board
     * @param dimension the dimension of the board, that is N.
     * @throws IllegalArgumentException if the given dimension is non-positive
     */
    public Board(int dimension) {

    }

    /**
     * Places the given piece to location (x, y). Also sets the position of the piece
     * to (x,y). Coordinates are 0-indexed. (0,0) is the top-left corner of the board.
     *
     * @param piece to be put on the board.
     * @param x the vertical coordinate of the location.
     * @param y the horizontal coordinate of the location.
     * @throws IndexOutOfBoundsException if x or y is out of the boundaries of the board.
     * @throws AlreadyOccupiedException if a piece already exists at location (x,y).
     */
    public void put(Piece piece, int x, int y) {

    }

    /**
     * Returns the piece at the given location.
     * @param x
     * @param y
     * @return the piece object at location (x,y), or null if no piece exists on that location.
     */
    public Piece getPieceAt(int x, int y) {
        return null;
    }

    /**
     * Returns whether this board is "valid" or not.
     * For a board to be valid, no piece should be able to attack another.
     *
     * @return true if the board is valid; false, otherwise.
     */
    public boolean isValid() {
        return false;
    }

    /**
     * Returns the list of the pieces that were put on this board.
     * The pieces should be ordered according to the order in which they were placed.
     * @return the list of pieces
     */
    public List<Piece> getPieces() {
        return null;
    }

    /**
     * Return a string representation of this board,
     * where pieces are shown according to their symbol.
     * Sample output of toString() for a 4-by-4 board:
     * +-+-+-+-+
     * |R| | |R|
     * +-+-+-+-+
     * | | | | |
     * +-+-+-+-+
     * | |Q| |B|
     * +-+-+-+-+
     * | | |K| |
     * +-+-+-+-+
     *
     * @return the string representation of this board
     */
    public String toString() {
        return null;
    }

    /**
     * @return the dimension of this board.
     */
    public int getDimension() {
        return 0;
    }

    /**
     * Returns a deep copy of this board where each contained piece
     * is also cloned.
     * @return the clone of this board.
     */
    public Board clone() {
        return null;
    }

    /**
     * Decide if the given object is equal to this board.
     * A board is equal to another board if they contain the same
     * type of pieces on the same locations.
     */
    public boolean equals(Object that) {
        return false;
    }

    /**
     * Decide if location (x,y) on this board is available.
     * A location is available if it is not occupied and cannot be attacked by any piece.
     */
    public boolean isAvailable(int x, int y) {
        return false;
    }

    /**
     * Returns the most recent piece put on this board.
     */
    public Piece getLastPiece() {
        return null;
    }

    /**
     * Removes the most recently placed piece from this board.
     */
    public void removeLastPiece() {

    }

    /**
     * Returns whether this board is covered or not.
     * A board is covered if there does not exist an available cell on the board.
     */
    public boolean isCovered() {
        return false;
    }
}

public abstract class Piece {
    /**
     * Returns true if this piece can attack, that is, can move to,
     * the given destination. Otherwise returns false.
     * A piece cannot attack its own location.
     *
     * @param i the vertical coordinate of the proposed destination on board
     * @param j the horizontal coordinate of the proposed destination on board
     * @throws IllegalArgumentException if i or j is negative.
     */
    public abstract boolean canAttack(int i, int j);

    /**
     * Sets the location of this piece to the cell at location x,y.
     *
     * @param x the vertical coordinate of the position
     * @param y the horizontal coordinate of the position
     * @throws IllegalArgumentException if x or y is negative.
     */
    public void setPosition(int x, int y) {

    }

    /**
     * @return the vertical, that is, the x coordinate, of this piece.
     */
    public int getX() {
        return 0;
    }

    /**
     * @return the horizontal, that is, the y coordinate, of this piece.
     */
    public int getY() {
        return 0;
    }

    /**
     * @return the clone of this piece.
     */
    public Piece clone() {
        return null;
    }

    /**
     * @return a one-character String as the symbol of this piece.
     */
    public abstract String getSymbol();
}

package chess;

public class DominationSolver {
    /**
     * Solves the domination problem for a board of the given dimension
     * using pieces of the given type. A board is "dominated" if all the cells
     * are either occupied or can be attacked by a piece on the board.
     * The problem must be solved using the minimum number of pieces.
     * The returned board is one of the possibly many solutions.
     * @param dimension a positive integer as the dimension of the board
     * @param piece the piece that will be cloned and put on the board for solving
     *              the problem.
     * @return a solution board, or null if a solution does not exist.
     * @throws IllegalArgumentException if the dimension is non-positive
     */
    public Board solve(int dimension, Piece piece) {
        return null;
    }
}

/**
 * @return the relative value of the piece
 */
public abstract int getValue();