/**
 * Tar for seg hvert hele brett
 */
class Brett {
	private final int str;
    private final int boksX;
    private final int boksY;
	private Rute[][] ruter;
    private Rad[] rader;
    private Kolonne[] kolonner;
    private Boks[][] bokser;

    /** Initialiserer brettet */    
    Brett(int str, int boksX, int boksY) {
	    this.str = str;
        this.boksX = boksX;
        this.boksY = boksY;
        rader = new Rad[str];
        kolonner = new Kolonne[str];
        bokser = new Boks[str/boksX][str/boksY];
        ruter = new Rute[str][str];

        // Loop for å opprette rader, kolonner og bokser
        for (int x = 0; x < str-1; x++) {
            rader[x] = new Rad();
            kolonner[x] = new Kolonne();
        }
        for (int x = 0; x < str/boksX; x++) {
            for (int y = 0; y < str/boksY; y++) {
                bokser[x][y] = new Boks();
            }
        }

        // Loop for å opprette bokser
        for (int x = 0; x < str; x++) {
            for (int y = 0; y < str; y++) {
                // Fyller brettet med ruter.
                ruter[x][y] = new Rute(0, kolonner[x], rader[y], bokser[x / boksX][y / boksY]);
            }
        }

        // Fyll inn ruter ved siden av seg selv korrekt.
        for (int y = 0; y < str; y++) {
            for (int x = 0; x < str - 1; x++) {
                ruter[x][y].settNeste(ruter[x + 1][y]);
            }

            // Sørg for at vi går til neste rad på slutten.
            if (y < str - 1)  {
                ruter[str - 1][y].settNeste(ruter[0][y + 1]);
            // Pass på at siste rute på brettet får nullpeker ved siden av seg.
            } else {
                ruter[str - 1][y].settNeste(null);
            }
        }
	}
	
	/** Selve algoritmen for å finne løsninger */
	protected void finnLosninger() {
        System.out.println("Løsninger!");
	}
}

/**
 *  Tar seg av hver enkeltrute
 */
class Rute {
	private int ruteVerdi;
    private Rute nesteRute;

    private Kolonne egenKol;
    private Rad egenRad;
    private Boks egenBoks;

    Rute(int v, Kolonne k, Rad r, Boks b) {
        k.leggTil(this);
        r.leggTil(this);
        b.leggTil(this);

        this.ruteVerdi = v;
        this.egenKol = k;
        this.egenRad = r;
        this.egenBoks = b;
    }

    /** Setter verdi til ruta */    
	protected void settVerdi(int i) {
		ruteVerdi = i;
	}
    
    protected int hentVerdi() {
        return ruteVerdi;
    }

    /** Setter rutas neste rute */
    protected void settNeste(Rute r) {
        nesteRute = r;
    }

    /** Henter ruta ved siden av seg */
    protected Rute hentNeste() {
        return nesteRute;
    }

    /** Sjekker om vi er på siste rute */
    protected boolean harNeste() {
        if (nesteRute == null) return false;
        return true;
    }

    protected Kolonne hentKolonne() { return egenKol; }
    protected Rad hentRad() { return egenRad; }
    protected Boks hentBoks() { return egenBoks; }
	
    /** Algoritme for å sette siffer i ruta */
	protected boolean provAlleSifferMegOgResten() {
		return true;
	}

    public String toString() {
        return String.valueOf(ruteVerdi);
    }
}

/**
 * Super-klasse for boks, kolonne og rad.
 */
abstract class Underdel {
    ArrayList <Rute> ruter = new ArrayList<Rute>();

    protected void leggTil(Rute r) {
        ruter.add(r);
    }

    protected boolean sjekkTall(int i) {
        boolean erSatt = false;

        for (int x = 0; x < ruter.size(); x++) {
            Rute r = (Rute) ruter.get(x);

            if (r.hentVerdi() == i) erSatt = false;
        }

        return erSatt;
    }
}

class Boks extends Underdel {}
class Kolonne extends Underdel {}
class Rad extends Underdel {}