【华为OJ】【106-Sudoku-Java】

【华为OJ】【算法总篇章】

---

【华为OJ】【106-Sudoku-Java】

【工程下载】

---

题目描述

问题描述：数独（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;

/**
 * Author: 王俊超
 * Time: 2016-05-05 20:56
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * 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;
        }
    }
}