摘要：首先在二維數組第一行隨機填充個數字，然后將這個數字隨機分布到整個二維數組中，然后使用求解數獨的算法對此時的數組進行求解，得到一個完整的數獨，然后按照用戶輸入的提示數量進行隨機挖洞，得到最終的數獨題目。

數獨的生成總體思路是挖洞法。
首先在二維數組第一行隨機填充1-9 9個數字，然后將這9個數字隨機分布到整個二維數組中，然后使用求解數獨的算法對此時的數組進行求解，得到一個完整的數獨，然后按照用戶輸入的提示數量進行隨機挖洞，得到最終的數獨題目。
這種方法理論上可以隨機生成(81!/72! = 9.5e+16)種不同的數獨題目，足夠人類玩上幾百年了。

求解數獨使用的是計算機最擅長的暴力搜索中的回溯法。并結合人求解數獨的思維過程增加了一點改進。
在每一層搜索中，首先計算每個格子可以填充的值的個數（我命名為不確定度），如果有格子不確定度為1，則直接填上數字就好，否則對不確定度最小的格子使用可能的數字逐個填充，并進入下一次遞歸。如果發現不確定度為0的格子，做說明之前的過程有問題，需要進行回溯。

package sudo;

import java.util.Scanner;
/**
 * @description 數獨生成和求解
 * @limit 支持從1-80的數字提示數量
 * @method 深度優先搜索/回溯法
 * @author chnmagnus
 */
public class Sudo {
    
    private int[][] data = new int[9][9]; //muti_array
    private int lef; //the number of zero in array
    private int tip; //the number of nozero_digit in array
    
    /**
     * 構造函數
     * 初始化變量
     */
    public Sudo(){
        lef = 0;
        for(int i=0;i<9;++i){
            for(int j=0;j<9;++j){
                data[i][j] = 0;
            }
        }
    }
    /**
     * 生成數獨
     * 方法：挖洞法
     */
    public void genSudo(){
        System.out.println("Please input the number of digits provided:");
        Scanner scan = new Scanner(System.in);
        tip = scan.nextInt();
        scan.close();
        /*將1-9 9個數字放在二維數組中隨機位置*/
        lef = 81 - 9; 
        for(int i=0;i<9;++i){
            data[0][i] = i+1;
        }
        for(int i=0;i<9;++i){
            int ta = (int)(Math.random()*10)%9;
            int tb = (int)(Math.random()*10)%9;
            int tem = data[0][ta];
            data[0][ta] = data[0][tb];
            data[0][tb] = tem;
        }
        for(int i=0;i<9;++i){
            int ta = (int)(Math.random()*10)%9;
            int tb = (int)(Math.random()*10)%9;
            int tem = data[0][i];
            data[0][i] = data[ta][tb];
            data[ta][tb] = tem;
        }
        /*通過9個數字求出一個可行解*/
        solveSudo();
        lef = 81 - tip;
        for(int i=0;i0)
                    System.out.print(data[i][j]+" ");
                else
                    System.out.print("* ");
            }
            System.out.print("
");
        }
        System.out.println("-----------------");
    }
    /**
     * 計算某格子的可填數字個數，即不確定度
     * @param r
     * @param c
     * @param mark
     * @return 不確定度
     */
    private int calcount(int r,int c,int[] mark){
        for(int ti=0;ti<10;++ti) 
            mark[ti] = 0;
        for(int i=0;i<9;++i){
            mark[data[i][c]] = 1;
            mark[data[r][i]] = 1;
        }
        int rs = (r/3)*3;
        int cs = (c/3)*3;
        for(int i=0;i<3;++i){
            for(int j=0;j<3;++j){
                mark[data[rs+i][cs+j]] = 1;
            }
        }
        int count = 0;
        for(int i=1;i<=9;++i){
            if(mark[i]==0)
                count++;
        }
        return count;
    }
    /**
     * 供solve調用的深度優先搜索
     * @return 是否有解的boolean標識
     */
    private boolean dfs(){
        if(lef==0) return true;
        int mincount = 10;
        int mini = 0,minj = 0;
        int[] mark = new int[10];
        /*找到不確定度最小的格子*/
        for(int i=0;i<9;++i){
            for(int j=0;j<9;++j){
                if(data[i][j]!=0) continue;
                
                int count = calcount(i,j,mark);
                if(count==0) return false;
                if(count
演示
以下四幅圖分別是輸出為0，20，60的程序運行結果。