利用程序随机构造N个已解答的数独棋盘

程序代码：
package shudu;

import java.util.ArrayList;

class Point {
    public Point() {
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Point(int x, int y, int re) {
        this.x = x;
        this.y = y;
        this.freshTime = re;
    }

    // /**
    // * 当前point 集合所代表的数独的数
    // */
    // public int currentNum = 1;

    /**
     * 一个点在一个宫里面有9中可能的位置,此值为在每个宫中试探的次数
     */
    public int freshTime = 0;
    public int x;
    public int y;
    public ArrayList<Point> availablePoint = new ArrayList<Point>();

    static public Point[][] initPoint() {
        Point[][] p = new Point[9][9];
        for (int i = 0; i < p.length; i++) {
            for (int j = 0; j < p.length; j++) {
                p[i][j] = new Point();
            }
        }
        return p;
    }

    static public void initEachPoint(Point[] p) {
        for (int i = 0; i < p.length; i++) {
            p[i].x=-1;
            p[i].y=-1;
            p[i].freshTime=0;
            
        }
    }
}

public class Main {
    private int _step = 3;
    // private int _currentNum=1;
    private int[][] _rectangle = new int[9][9];
    // point 历史记录
    private int _history = -1;

    public Main() {
        for (int i = 0; i < this._rectangle.length; i++) {
            for (int j = 0; j < this._rectangle[i].length; j++) {
                this._rectangle[i][j] = 0;
            }
        }
    }

    public boolean isTheSame(Point[] p, int count) {
        int[] x = new int[] { -2, -2, -2, -2, -2, -2, -2, -2, -2, };
        int[] y = new int[] { -2, -2, -2, -2, -2, -2, -2, -2, -2, };
        for (int i = 0; i <=count; i++) {//唯一bug,<=写成<
            if (x[p[i].x] == -2) {
                x[p[i].x] = 0;
            } else {
                return true;
            }
            if (y[p[i].y] == -2) {
                y[p[i].y] = 0;
            } else {
                return true;
            }
        }
        return false;
    }

    public void print(int[][] a) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }

    public int random(int begin, int end) {
        return (int) (Math.random() * (end - begin) + begin);
    }

    /**
     * 
     * @param xPos
     *            参照x坐标
     * @param yPos
     *            参照y坐标
     * @param xCol
     *            实际x坐标
     * @param yCol
     *            实际y坐标
     * @return
     */
    public boolean isPosOutOfBoundry(int xPos, int yPos, int xCol, int yCol) {
        int xEnd = xPos + this._step;
        int yEnd = yPos + this._step;
        if ((xCol >= xPos && xCol < xEnd) && (yCol >= yPos && yCol < yEnd)) {
            return false;
        }
        return true;
    }

    public Point generateRandomXYPos(int xPos, int yPos) {
        // int xCol = random(xPos, xPos + this._step);
        // int yCol = random(yPos, yPos + this._step);
        Point point = new Point();
        // 选取某个宫中的点的位置时，此位置不可用的次数
        int num = 0;
        // 当前随机位置不可生成点
        for (int i = xPos; i < xPos + this._step; i++) {
            for (int j = yPos; j < yPos + this._step; j++) {
                if (this._rectangle[i][j] != 0) {
                    num++;
                } else {
                    point.availablePoint.add(new Point(i, j));
                }
            }
        }
        point.freshTime = num;
        return point;
    }

    public int[][] generate() {
        // 以步长为3增加的锚点
        int xPos, yPos;
        // 数独点的坐标
        int xCol, yCol;
        Point[][] p = Point.initPoint();
        // 对1-9每个数进行操作
        for (int i = 0; i < 2;) {
            // 初始化点集
            // 历史记录是上一次9个宫都满足时所记录的状态
            boolean needBack = false;
            this._history++;
            if (this._history >= 9) {
                this._history = 0;
            }
            Point.initEachPoint(p[this._history]);

            // p[this._history][count].currentNum = i + 1;

            for (xPos = 0; xPos < this._rectangle.length; xPos += this._step) {
                if (needBack) {
                    break;
                }
                for (yPos = 0; yPos < this._rectangle.length; yPos += this._step) {
                    // 宫
                    int count = ((xPos * this._step) + yPos) / this._step;
                    Point _pPoint = generateRandomXYPos(xPos, yPos);
                    p[this._history][count].freshTime = _pPoint.freshTime;
                    // 在某一个宫处9个小格都满足不了，只能回溯
                    if (_pPoint.freshTime >= 9) {
                        needBack = true;
                        break;
                    }
                    while (_pPoint.availablePoint.size() > 0) {
                        int k = random(0, _pPoint.availablePoint.size());
                        p[this._history][count].x = _pPoint.availablePoint.get(k).x;
                        p[this._history][count].y = _pPoint.availablePoint.get(k).y;
                        if (!this.isTheSame(p[this._history], count)) {
                            break;
                        }
                        _pPoint.availablePoint.remove(k);
                    }
                }
            }
            if (needBack) {
                this._history--;
                if (this._history < 0) {
                    this._history = 8;
                }
                // 清空上一次的，重新随机，，，（有可能会随机一模一样的值）
                for (int n = 0; n < p[this._history].length; n++) {
                    this._rectangle[p[this._history][n].x][p[this._history][n].y] = 0;
                }
                i--;
            } else {
                for (int n = 0; n < p[this._history].length; n++) {
                    this._rectangle[p[this._history][n].x][p[this._history][n].y] = i + 1;
                }
                i++;
            }
        }
        return this._rectangle;
    }

    public static void main(String[] args) {
        Main main = new Main();
        int[][] shudu = main.generate();
        main.print(shudu);
    }
}