數獨

題目描述

問題描述：數獨（Sudoku）是一款大衆喜好的數字邏輯遊戲。
玩家須要根據9X9盤面上的已知數字，推算出全部剩餘空格的數字，
而且知足每一行、每一列、每個粗線宮內的數字均含1-9，而且不重複。
輸入：
包含已知數字的9X9盤面數組[空缺位以數字0表示]
輸出：
完整的9X9盤面數組

輸入描述

包含已知數字的9X9盤面數組[空缺位以數字0表示]

輸出描述

完整的9X9盤面數組

輸入例子

0 9 2 4 8 1 7 6 3
4 1 3 7 6 2 9 8 5
8 6 7 3 5 9 4 1 2
6 2 4 1 9 5 3 7 8
7 5 9 8 4 3 1 2 6
1 3 8 6 2 7 5 9 4
2 7 1 5 3 8 6 4 9
3 8 6 9 1 4 2 5 7
0 4 5 2 7 6 8 3 1

輸出例子

5 9 2 4 8 1 7 6 3
4 1 3 7 6 2 9 8 5
8 6 7 3 5 9 4 1 2
6 2 4 1 9 5 3 7 8
7 5 9 8 4 3 1 2 6
1 3 8 6 2 7 5 9 4
2 7 1 5 3 8 6 4 9
3 8 6 9 1 4 2 5 7
9 4 5 2 7 6 8 3 1

算法實現

import java.util.Scanner;

/**
 * Declaration: All Rights Reserved !!!
 */
public class Main {
    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data3.txt"));
        while (scanner.hasNext()) {
            int[][] sudoku = new int[9][9];

            for (int i = 0; i < 9; i++) {
                sudoku[i] = new int[9];
            }

            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++) {
                    sudoku[i][j] = scanner.nextInt();
                }
            }

            System.out.println(solve(sudoku));
        }

        scanner.close();
    }

    /**
     * 解決數獨問題
     *
     * @param sudoku 數獨棋盤
     * @return 結果
     */
    private static String solve(int[][] sudoku) {
        boolean[] f = {false};
        // 未處理前
//        System.out.println(sudokuToString(sudoku));
        solve(sudoku, 0, f);

        return sudokuToString(sudoku);
    }

    private static String sudokuToString(int[][] sudoku) {
        StringBuilder b = new StringBuilder(256);
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                b.append(sudoku[i][j]).append(' ');
            }

            b.setCharAt(b.length() - 1, '\n');
        }

        return b.substring(0, b.length() - 1);
    }

    /**
     * 從第row行開始解決數獨問題
     *
     * @param sudoku 數獨劃棋盤
     * @param finish 是否已經完成
     * @param r      開始處理的行
     */
    private static void solve(int[][] sudoku, int r, boolean[] finish) {

        // 若是已經完成就
        if (finish[0] || r > 8) {
            return;
        }

        int row = r;
        int col = 0;
        boolean find = false;

        // 從r行開始找第一個未處理的格子
        for (int i = r; i < 9 && !find; i++) {
            for (int j = 0; j < 9; j++) {
                if (sudoku[i][j] == 0) {
                    row = i;
                    col = j;
                    find = true;
                    break;
                }
            }
        }

        // 找到末處理的
        if (find) {

            boolean[] used = new boolean[10];

            // 標記第row行，第col列已經使用過的數字
            for (int i = 0; i < 9; i++) {
                used[sudoku[row][i]] = true;
                used[sudoku[i][col]] = true;
            }

            // 數獨劃棋盤的方格
            // (0, 0),(0, 1),(0, 2)
            // (1, 0),(1, 1),(1, 2)
            // (2, 0),(2, 1),(2, 2)

            // 標記[row, col]在第幾個方格中
            int x = row / 3;
            int y = col / 3;

            for (int i = x * 3; i < (x + 1) * 3; i++) {
                for (int j = y * 3; j < (y + 1) * 3; j++) {
                    used[sudoku[i][j]] = true;
                }
            }

            // used中末被標記的說明能夠使用，下標爲0的不使用
            for (int i = 1; i < used.length; i++) {
                // 未被標記，說明sudoku[row][col]能夠爲i
                if (!used[i]) {
                    sudoku[row][col] = i;
                    used[i] = true;

                    // 處理下一個未填寫的位置
                    solve(sudoku, row, finish);

                    // 若是找到方案就返回
                    if (finish[0]) {
                        return;
                    }

                    // 現場還原
                    sudoku[row][col] = 0;
                    used[i] = false;
                }
            }


        }
        // 沒有找到未處理的，說明已經完成了解決方案
        else {
            finish[0] = true;
            return;
        }
    }
}