public class Position {
	
	/** Nom de la colonne. */
	private final char col;
	
	/** Numéro de la ligne. */
	private final int lig;
	
	/**
	 * Constructeur
	 * @param col est le nom de la colonne de la position
	 * @param lig est le numéro de la ligne de la position
	 */
	public Position(char col, int lig) {
		this.col = col;
		this.lig = lig;
	}

	public char getCol() {
		return col;
	}

	public int getLig() {
		return lig;
	}

	@Override
	public String toString() {
		return  Character.toString(col) +lig ;
	}

}

public class Echiquier {

	/** Les pieces de l'échiquier. */
	private Piece[][] tPieces;

	public Echiquier() {
		tPieces = new Piece[8][8];
	}

}

	public boolean placer(Piece pi, Position po) {
		if (po.getLig() > 0 && po.getLig() <= 8) {
			try {
				tPieces[po.getLig() - 1][convertir(po.getCol())] = pi;
				return true;
			} catch (Exception e) {
				return false;
			}

		} else { return false; }
	}

	private int convertir(char c) throws Exception {
		switch (c) {
		case 'a':
			return 0;
		case 'b':
			return 1;
		case 'c':
			return 2;
		case 'd':
			return 3;
		case 'e':
			return 4;
		case 'f':
			return 5;
		case 'g':
			return 6;
		case 'h':
			return 7;
		default:
			throw new Exception("Colonne inconnue");
		}
	}

	/**
	 * Recupération d'une pièce à partir d'une position
	 * @param po est la position
	 * @return la pièce située à la position po
	 */
	public Piece get(Position po){
		if(po.getLig() > 0 && po.getLig() <= 8){
			try {
				return tPieces[po.getLig() - 1][convertir(po.getCol())];
			} catch (Exception e) {
				return null;
			}
		} else {
			return null;
		}
	}
	

public String toString(){
		// Entete pour les colonnes
		String result = "  a b c d e f g h  \n";
		
		// On parcourt toutes les lignes de l'échiquier
		for(int lig=7; lig >= 0; lig --){
			// On affiche le numéro de la ligne
			result += lig;
			
			// Pour chaque ligne on parcourt les colonnes
			for(int col=0; col < 8; col++){
			  Piece pi = tPieces[lig][col];
			  // S'il n'y a pas de pièces sur la position
			  if(pi == null){
				  // Si la somme ligne + colonne est paire => case blanche
				  if((lig + col) % 2 == 0){
					  result += " .";
				  } else {
					  // la case est noire
					  result += " *";
				  }
				  
			  } else {
				  // S'il existe une pièce, on l'affiche
				  result += " " + pi;
			  }
				
			}
			result += " " + lig + "\n";
		}
		result += "  a b c d e f g h  \n";
		return result;
	}

public abstract class Piece {
	
	/** true is la pièce est noire, false sinon. */
	public boolean black;
	
	public Piece(boolean black){
		this.black = black;
	}
	
	public abstract String toString();
	
	/**
	 * 
	 * @param p1 position de départ
	 * @param p2 position d'arrivée
	 * @return vrai si la piece peut être déplacée de p1 vers p2
	 */
	public abstract boolean déplacable(Position p1, Position p2);
	
	
	/**
	 * Déplace la pièce de p1 vers p2 sur l'échiquier e.
	 * @param p1 position de départ
	 * @param p2 position d'arrivée
	 * @param e est l'échéquier
	 */
	public abstract void déplacer(Position p1, Position p2, Echiquier e);
}

public class Roi extends Piece{
	
	public Roi(boolean black) {
		super(black);
	}

	@Override
	public String toString() {
		if(black){ return "R"; }else { return "r"; }
	}

	@Override
	public boolean déplacable(Position p1, Position p2) {
        try {
	       return  Math.abs(p2.getLig() - p1.getLig()) <= 1 
	       || Math.abs(Echiquier.convertir(p2.getCol())
                              - Echiquier.convertir(p1.getCol())) <= 1;
        } catch (Exception e) {
	        return false;
	}	
	}

	@Override
	public void déplacer(Position p1, Position p2, Echiquier e) {
		if(this.déplacable(p1, p2)){
			e.placer(null, p1);
			e.placer(this, p2);
		}
	}
}

import java.util.HashMap;
import java.util.Map;

public class Echiquier2 {
	
	private Map<Position, Piece> mapPieces;
	
	public Echiquier2(){
		mapPieces = new HashMap<Position, Piece>();
	}

	
	/**
	 * Recupération d'une pièce à partir d'une position
	 * @param po est la position
	 * @return la pièce située à la position po
	 */
	public Piece get(Position po){
		return mapPieces.get(po);
	}
}

public class ExceptionPosition extends Exception{
	
	public ExceptionPosition(String message){
		super(message);
	}

}

        /**
	 * Déplacer la pièce de p1 vers p2.
	 * @param p1 est la position de départ
	 * @param p2 est la position d'arrivée
	 * @param e est l'échiquier
	 * @throws ExceptionPosition lorsque le déplacement n'est pas possible
	 */
	public void déplacer2(Position p1, Position p2, Echiquier e) 
                                                        throws ExceptionPosition {
		if(this.déplacable(p1, p2)){
			e.placer(null, p1);
			e.placer(this, p2);
		} else {
			throw new ExceptionPosition(
                            this + " ne peut pas être déplacée de "+p1+ " vers "+p2);
		}
	}


        /**
	 * Recupération d'une pièce à partir d'une position
	 * @param po est la position
	 * @return la pièce située à la position po
	 */
	public Piece get2(Position po) throws ExceptionPosition{
		Piece piece = mapPieces.get(po);
		if(piece == null){
			throw new ExceptionPosition(
                                " Il n'y pas de pièce sur la position "+po);
		}
		return piece;
	}

	/**
	 * Identifie la CC d’un sommet.
	 * 
	 * @param e le sommet considéré
	 * @return le plus petit no contenu dans la liste de sommets avec lesquels e
	 *         est connexe
	 */
	public int findCC(int e) {
		List<Integer> sommetsConnectes = connectedComponents.get(e);
		return Collections.min(sommetsConnectes);
	}
	

        /** Calcule l’union des CC de 2 sommets. Après l’union, les CC des 2 sommets indiqueront les mêmes nos. 
	 * @param v Le premier sommet
	 * @param u Le second sommet
	 */
	public void unionCC(int u, int v) {
            ArrayList<Integer> union = new ArrayList<Integer>(connectedComponents.get(u));
		
	    for(Integer sommet : connectedComponents.get(v)){
	    	if(!union.contains(sommet)){
	    		union.add(sommet);
	    	}
	    }
		
		connectedComponents.put(u, union);
		connectedComponents.put(v, union);
	}

	public static int[] sort(int[] tab){
		int indice = (int) Math.log(tab.length);
		if(quasiSorted(indice, tab)){
			return mergeSort(tab);
		}else {
			return quickSort(tab, 0, tab.length -1);
		}
	}

public static int findPermutationBound(int[ ] tab){
		
		int permutationBound = 0;
		
		for(int i = 0; i<tab.length; i ++){
			
			int value = tab[i];
			int precedent = 0;
			
			for(int j=0; j<tab.length; j ++){
				
				// On cherche l'entier qui précède tab[i]
				if(j != i && tab[j] > precedent && tab[j] <= value){
					precedent = j;
				}
			}
			
			int ecart = precedent-i;
			
			if(ecart > permutationBound){
				permutationBound = ecart;
			}
		}
		
		return permutationBound;
	}
	
	

Complexité au pire O(n2)