grote-lijnen.txt

Chronological backtracking:
-vul een vak in (probeer in volgorde 1,2..,8,9)
-check of dit voldoet aan alle constraints
-ga naar het volgende vakje (van links naar rechts en van boven naar beneden dat is dus rij voor rij)
-doe weer hetzelfde
-is er een constraint violation probeer de volgende waarde (het is depth first)
-is er weer een constraint violation en het huidige vakje heeft geen mogelijk waarden meer (waarde 9 leidde tot een constrain violation)
    Dan betekent dat we moeten backtracken ga terug tot je een parent vindt die nog wel waarde toekenningen over heeft
-Ga door tot je een oplossing hebt
-Volgens de opdracht beschrijven hoeven we hier geen consistentie onderhoud te doen(volgens mij)

Forward Checking:
-Na invullen van gefixeerde vakken Maak het probleem eerst knoop consistent
    Dat betekent voor elk niet gefixeerd vakje: verwijder alle onmogelijke waarden uit zijn domein
-Vul vakjes in in dezelfde volgorde als bij chronological backtracking
-Na elke invulling worden de domeinen van de vakjes aangepast
    Dus wanneer je een vakje wilt invullen
    Kijk je naar de waarden in het domein van dat vakje (wel nog steeds in oplopende volgorde)
-Na elke invulling van Vi(een vakje) worden alle andere Vj's(andere vakjes indezelfde rij, kolom en subgrid) consistent gemaakt met Vi
    Dat betekent pas de domeinen van Vj aan' (hier zijn i en j niet gerelateerd aan de sudoku coordinaten)
-in het algoritme wordt ook gesproken over constraint sets, maar het is denk ik het beste als we niet expliciet met constraint sets gaan werken
    Want dat zal voor onnodige overhead en ruimtegebruik zorgen

-FC met MCV:
-Hetzelfde als forward checking alleen de volgorde waarin je de vakjes invult is anders
-na elke invulling sorteer domeinen op basis van grootte, het vakje met het kleinste domein wordt als eerste gekozen

Datastructuren:
Voor chronological backtracking hoef je niet expliciet een search tree datastructure te gebruiken want je alles gewoon in van links naar rechts en van boven naar beneden.
Voor chronological backtracking hoef je alleen de waarde van het huidige vakje ongedaan te maken want je kijkt niet naar domeinen in dat algoritme. Dus je weet van welk vakje
vandaan komt en welke waarde je daar is uitgeprobeerd.

Voor forward checking kun je een search tree gebruiken, maar het hoeft niet. Stel je zit in Vi en je moet terug, dan moet je de ingevulde waarde van Vi verwijderen.
Maar je moet ook de domein veranderingen die Vi heeft veroorzaakt weer ongedaan maken. Stel dat er een Vi waarde 3 heeft en het blijkt dat die branch niet werkt. En je wilt terug.
Dan moet je de waarde 3 weer terug stoppen in de domeinen van alle Vj's. Maar het kan zijn een Vj 3 niet in zn domein heeft vanwege een ander vakje en niet vanwege Vi.
Dus je kunt niet zomaar aan alle Vj's 3 terug geven. Je kunt dus onthouden welk vakje een bepaalde waarde uit zijn domein heeft verwijderd. Dat kun je in een tree opslaan.
Maar het hoeft niet. Je kunt ook kijken voor elke Vj of 3 voorkomt in zijn rij, kolom of subgrid. Als dat niet zo is dan mag je 3 weer terug geven aan Vj. 
Ik heb in de comments van StateOperator.cs hier meer over uitgelegd

Classes:
-Vakje:
    -bool gefixeerd of niet
    -ingevulde waarde (0 t/m 9, 0 = leeg)
    -Domein = set van mogelijke waarden
    -coordinaten (i = rij-index, j = kolom-index)

-Sudokugrid
    -misschien beter niet meer met een subgrid class werken want we gaan nu vooral rij voor rij af
    -bevat een twee dimensionale array van vakjes (op rij basis)
    -Een functie die alle vakjes terug geeft die in dezelfde rij, kolom en subgrid bevinden van een bepaald vakje

-SudokuOperator
    -Een method die een successor state genereerd, dus een vakje invult en de domeinen aanpast
    -Een method die alles één stap terugdraait, dus de meeste recente invulling en domeinveranderingen terug draait

De inhoud van de volgende classen moeten nog nader bepaald worden
-Een class voor het chronological backtracking

-Een class voor het forwardchecking algoritme

-Een class voor het FC-MCV algoritme