Generowanie wypełnionego sudoku

Cześć, macie jakiś pomysł na wygenerowanie rozwiązanego Sudoku (liczby nie mogą się powtórzyć w żadnym z dziewięciu kwadratów, ani w żadnym rzędzie i kolumnie). Jedyne co osiągnąłem od środy to coś takiego:

import java.util.*;

public class ReadyBoard {

    private static final List<Integer> numbers = new ArrayList<>();
    private static final List<String> elements = new ArrayList<>();
    private static final Random random = new Random();
    private static final String[] initialElements = {" 1 ", " 2 ", " 3 ", " 4 ", " 5 ", " 6 ", " 7 ", " 8 ", " 9 "};
    private static final int MAX_SQUARE_SIZE = 9;

    private static final Board readyBoard = new Board();
    private int randomElementNumber;
    private int randomPosition;
    private String playerMove;
    private boolean loopRun = true;

    public String[][] drawBoard() {
        generateSquareOne();
        for (int i = 0; i < readyBoard.newBoard().length; i++) {
            for (int j = 0; j < readyBoard.newBoard().length; j++) {
                System.out.print(readyBoard.newBoard()[i][j]);
            }
            System.out.println();
        }
        return readyBoard.newBoard();
    }

    private void generateSquareOne() {
        while (loopRun) {
            randomElementNumber = random.nextInt(initialElements.length);
            playerMove = "";
            playerMove = playerMove + initialElements[randomElementNumber];
            while (elements.contains(playerMove)) {
                randomElementNumber = random.nextInt(initialElements.length);
                playerMove = "";
                playerMove = playerMove + initialElements[randomElementNumber];
            }
            randomPosition = random.nextInt(initialElements.length);
            while (numbers.contains(randomPosition)) {
                randomPosition = random.nextInt(initialElements.length);
            }
            switch (randomPosition) {
                case 0:
                    readyBoard.newBoard()[1][1] = playerMove;
                    break;
                case 1:
                    readyBoard.newBoard()[1][2] = playerMove;
                    break;
                case 2:
                    readyBoard.newBoard()[1][3] = playerMove;
                    break;
                case 3:
                    readyBoard.newBoard()[2][1] = playerMove;
                    break;
                case 4:
                    readyBoard.newBoard()[2][2] = playerMove;
                    break;
                case 5:
                    readyBoard.newBoard()[2][3] = playerMove;
                    break;
                case 6:
                    readyBoard.newBoard()[3][1] = playerMove;
                    break;
                case 7:
                    readyBoard.newBoard()[3][2] = playerMove;
                    break;
                case 8:
                    readyBoard.newBoard()[3][3] = playerMove;
                    break;
            }
            numbers.add(randomPosition);
            elements.add(playerMove);
            if (numbers.size() == MAX_SQUARE_SIZE && elements.size() == MAX_SQUARE_SIZE) {
                loopRun = false;
            }
        }
    }

    //UZYWAJAC KOLEKCJI HASSET:
    //JEZELI ROZMIAR KAZDEGO Z KWADRATÓW NIE JEST RÓWNY 9
    //I ROZMIAR KAZDEGO RZEDU I KAZDEJ KOLUMNY TEZ NIE JEST ROWNY 9
    //I KTORYS Z KWADRATOW ZAWIERA PUSTE POLE: "   "
    //TO MA LOSOWAC LICZBY PONOWNIE
}

Bo jak miałbym zrobić to w ten sposób, to wyszło by mi zaraz z 1400 linii...

No sudoku to tam sie robilo tak ze generujesz wiersz z dziewiecioma cyframi (dowolnie poustawiane) i potem generujesz wiersz nizej przesuniety o 3 miejsca w prawo i potem generujesz trzeci wiersz na podstawie drugiego przesuwajac w prawo o 3, następnie linie 4 generujesz przesuwajaac o 1 to co bylo w lini trzeciej i potem znowu przesuwasz o 3 i kolejnhy o 3 i to samo o 1 i potem dwa wiersze o 3 i juz.

No i oczywiscie mozesz to przesuwac o rozne miejsa raz o 3 raz o 1 raz o 3 itd zeby sie gracz nie skumal jakie sortowanie uzyles w danej grze, moze byc oczywiscie losowe co kazda gra

Wynik będzie zawsze taki sam (trzeba popracować nad losowością):

• wstawiasz w pierwsze pole 1
• w drugie pole wstawiasz najniższą cyfrę, która może być wstawiona (spełnia warunki gry)
  ....
• dochodzisz do miejsca gdzie nie ma możliwości wstawienia czegokolwiek
• cofasz się do poprzedniego pola i wstawiasz następną możliwą wartość, jeżeli nie ma takiej wartości, lub wszystkie możliwości zostały już wykorzystane, to czyścisz i wykonujesz tą samą czynność na poprzednim polu itd.
• kontynuujesz proces uzupełniania kolejnych wartości, jak na początku.

Można dla każdego z wierszy ustalić np. losową kolejność elementów, z których będziesz próbować wstawiać wartości.

Może to coś pomoże https://www.101computing.net/backtracking-algorithm-sudoku-solver/

Najlepiej poszukać pod kątem sudoku+algorithm.