Модификация многоклассового массива

Три вопроса за три дня (если бы я мог решить свои проблемы в одиночку), и сегодня все еще о моем проекте судоку. Я работаю над созданием игры Судоку на Java и работаю с другими людьми, которые программировали различные части проекта, и прямо сейчас мы пытаемся объединить класс решателя Судоку с классом JFrame, что делает все это красивым (Или это будет в какой-то момент), но прямо сейчас у меня проблема с тем, как работают мои 2D-массивы (скорее, нет). Ниже приведен код, в котором я вызываю решатель и передаю его множеству методов:

public class FenetreGrille extends JFrame implements ActionListener{

public static int [][] NOMBRES_DEBUT;
public static int [][] GRILLE_MODIF = new int[9][9];
public int [][] GRILLE_FINALE = new int[9][9];

public static final int TAILLE = 9;                                 
public static int TAILLECASE = 60;
public static int COTEGRILLE ;

public FenetreGrille(int [][] t){
    NOMBRES_DEBUT = t;
    GRILLE_MODIF = NOMBRES_DEBUT;
    GRILLE_FINALE = NOMBRES_DEBUT;
    COTEGRILLE = TAILLE * TAILLECASE;

    SudokuBackTrack sbt = new SudokuBackTrack(GRILLE_FINALE);
    // Here is the problem ^^^^^
    // More code below that shouldn't be important...
}

А вот и класс SudokuBackTrack:

public class SudokuBackTrack{

public static int[][] grille;
public static int[][] grilleResolu;
public static int[][] grillePos;

public static boolean[][] existeSurLigne = new boolean[9][9];
public static boolean[][] existeSurColonne = new boolean[9][9];
public static boolean[][] existeSurBloc = new boolean[9][9];

public final static int taille = 9;

public static ArrayList<Case> valParCase;

public SudokuBackTrack(int[][] t) {
    grille = t;
    grilleResolu = grille;
    valParCase = listeValPossibles(grilleResolu);
    tableauxExistence(grilleResolu);
    backtracking(0, grilleResolu);
}

public static ArrayList<Case> listeValPossibles(int[][] temp) {
    ArrayList<Case> t = new ArrayList<Case>();

    for (int i=0; i<9; i++){
        for (int j=0; j<9; j++){
            if (temp[i][j] == 0) {
                int pos = i*taille+j;
                t.add(valeursPossibles(pos, temp));
            }
        }
    }
    Collections.sort(t);
    return t;
}

public static Case valeursPossibles(int pos, int[][] t) {
    int i = pos/9;
    int j = pos%9;
    int valPossibles = 9;

    for(int s=1; s<=9; s++) {
        if (!absentSurLigne(s, i, t) || !absentSurColonne(s, j, t) || !absentDansBloc(s, i, j, t)) {
            valPossibles--;
        }
    }
    Case a = new Case(pos, valPossibles);
    return a;
}

public static boolean absentSurLigne(int k, int i, int[][] t) {
    for (int j=0; j < 9; j++) {
        if (t[i][j] == k) {
            return false;
        }
    }
    return true;
}

public static boolean absentSurColonne(int k, int j, int[][] t) {
    for (int i=0; i < 9; i++) {
        if (t[i][j] == k) {
            return false;
        }
    }
    return true;
}

public static boolean absentDansBloc(int k, int i, int j, int[][] t) {
    int _i = i-(i%3);   // ou encore : _i = 3*(i/3);
    int _j = j-(j%3);   // ou encore : _j = 3*(j/3);
    for (i=_i; i < _i+3; i++) {
        for (j=_j; j < _j+3; j++) {
            if (t[i][j] == k) {
                return false;
            }
        }
    }
    return true;
}

public static void tableauxExistence(int[][] t) {
    for (int i=0; i < 9; i++) {
        for (int j=0; j < 9; j++) {
            existeSurLigne[i][j] = existeSurColonne[i][j] = existeSurBloc[i][j] = false;
        }
    }

    int k;
    for (int i=0; i < 9; i++) {
        for (int j=0; j < 9; j++) {
            if ((k = t[i][j]) != 0) {
                existeSurLigne[i][k-1] = existeSurColonne[j][k-1] = existeSurBloc[3*(i/3)+(j/3)][k-1] = true;
            }
        }
    }
}

public static boolean backtracking(int index, int[][] t) {

    if (index == valParCase.size()) {
        return true;
    }

    int i = (valParCase.get(index).position)/9;
    int j = (valParCase.get(index).position)%9;

    for(int k = 0; k < 9; k++) {
        if (!existeSurLigne[i][k] && !existeSurColonne[j][k] && !existeSurBloc[3*(i/3)+(j/3)][k]){
            // Ajoute k aux valeurs enregistrées
            existeSurLigne[i][k] = existeSurColonne[j][k] = existeSurBloc[3*(i/3)+(j/3)][k] = true;

            if (backtracking(index+1, t)){
                // Ecrit le choix valide dans la grille
                t[i][j] = k+1;
                return true;
            }
            // Supprime k des valeurs enregistrées
            existeSurLigne[i][k] = existeSurColonne[j][k] = existeSurBloc[3*(i/3)+(j/3)][k] = false;
        }
    }

    t[i][j] = 0;
    return false;
}

Как упоминалось выше, моя проблема заключается в том, что когда я создаю экземпляр своего класса SudokuBackTrack с использованием 2D-массива GRILLE_FINALE, все мои 2D-массивы NOMBRES_DEBUT, GRILLE_MODIF и GRILLE_FINALE становятся решенными сетками судоку, тогда как все, что я хочу, это чтобы GRILLE_FINALE стал решенной версией, а не все 3. Я пробовал отлаживать коды, но ничего не нашел, а поскольку это смесь кодов от разных людей, я не знаю, как каждый из них создавал свои части. Я изменил типы атрибутов и пробовал всевозможные причудливые вещи, но не работал, и у меня нет идей и, в основном, времени ... Заранее спасибо и извините за огромный вопрос и код.