应用回溯法或分支限界法解决，并完成java完整代码：在填写第 i 个位置时，如果满足上述约束条件，则继续填写第 i+1 个位置；如果 1~20 个数都无法填写到第 i 个位置，则取消对第 i 个位置的填写，回溯到第 i-1 个位置。

回溯算法（Backtracking）是一种搜索策略，常用于解决那些涉及寻找所有解决方案的问题，例如八皇后问题、数独等。在这个场景下，你可以创建一个递归函数来尝试填充数字，如果发现当前选择导致无法满足约束，则回溯到前一个位置。

下面是一个简单的Java实现，假设我们有一个数组`grid`代表数独网格，`n`表示每个数独区域的大小（这里假设为3），`isSafe`函数检查当前位置是否安全，即该位置周围是否存在已填数字且不在同一行、列或宫格：

public class SudokuSolver {
    private int[][] grid;
    private boolean[] visited;
    private int row, col;

    public SudokuSolver(int[][] grid) {
        this.grid = grid;
        visited = new boolean[9];
        solve(0, 0);
    }

    private void solve(int row, int col) {
        if (col == n * n) { // 如果一行填完，开始下一行
            row++;
            col = 0;
        }

        // 检查当前位置是否合法
        if (!isSafe(row, col)) {
            return; // 回溯，尝试下一个位置
        }

        for (int num = 1; num <= 9; num++) {
            if (!visited[num] && isSafeToPlace(row, col, num)) {
                visited[num] = true; // 标记当前数字已被选择
                grid[row][col] = num; // 填充数字

                // 继续递归填充下一个位置
                solve(row, col + 1);

                // 回溯，如果无法填充下一个位置，则撤销当前选择
                if (row * n + col >= n * n) {
                    visited[num] = false; // 取消当前数字的选择
                    grid[row][col] = 0; // 清除当前位置
                }
            }
        }
    }

    // 其他辅助函数...
}

// 使用示例:
int[][] gridExample = {{5, 3, 0, 0, 7, 0, 0, 0, 0},
                       {6, 0, 0, 1, 9, 5, 0, 0, 0},
                       {0, 9, 8, 0, 0, 0, 0, 6, 0},
                       {8, 0, 0, 0, 6, 0, 0, 0, 3},
                       {4, 0, 0, 8, 0, 3, 0, 0, 1},
                       {7, 0, 0, 0, 2, 0, 0, 0, 6},
                       {0, 6, 0, 0, 0, 0, 2, 8, 0},
                       {0, 0, 0, 4, 1, 9, 0, 0, 5},
                       {0, 0, 0, 0, 8, 0, 0, 7, 9}};
SudokuSolver solver = new SudokuSolver(gridExample);