历届试题 九宫幻方

/*

标题：九宫幻方

    小明最近在教邻居家的小朋友小学奥数，而最近正好讲述到了三阶幻方这个部分，三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中，使得每一行、每一列和每一条对角线的和都是相同的。

    三阶幻方又被称作九宫格，在小学奥数里有一句非常有名的口诀：“二四为肩，六八为足，左三右七，戴九履一，五居其中”，通过这样的一句口诀就能够非常完美的构造出一个九宫格来。

4 9 2
3 5 7
8 1 6

    有意思的是，所有的三阶幻方，都可以通过这样一个九宫格进行若干镜像和旋转操作之后得到。现在小明准备将一个三阶幻方（不一定是上图中的那个）中的一些数抹掉，交给邻居家的小朋友来进行还原，并且希望她能够判断出究竟是不是只有一个解。

    而你呢，也被小明交付了同样的任务，但是不同的是，你需要写一个程序~

输入格式：
输入仅包含单组测试数据。
每组测试数据为一个3*3的矩阵，其中为0的部分表示被小明抹去的部分。
对于100%的数据，满足给出的矩阵至少能还原出一组可行的三阶幻方。

输出格式：
如果仅能还原出一组可行的三阶幻方，则将其输出，否则输出“Too Many”（不包含引号）。

样例输入
0 7 2
0 5 0
0 3 0

样例输出
6 7 2
1 5 9
8 3 4

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
 */


import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int N = 9;
    static int[] a;
    static boolean[] used;
    static int count = 0;
    static int[] records;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        a = new int[N];
        used = new boolean[N];
        records = new int[N];
        for (int i = 0; i < N; i++) {
            int t = sc.nextInt();
            a[i] = t;
            if (t != 0) used[i] = true;
        }
        sc.close();
        dfs(0);
        if (count == 1) {
            p(records);
        } else if (count > 1) {
            System.out.println("Too Many");
        }
    }


    static void dfs(int k) {
        if (k < N) {
            if (used[k]) {
                if (k < 8) {
                    dfs(k + 1);
                } else if (k == 8 && check(a)) {
                    records= Arrays.copyOfRange(a,0,N);
                    count++;
                }
            } else {
                for (int i = 1; i <= 9; i++) {
                    a[k] = i;
                    boolean flag = false;
                    for (int j = 0; j < N; j++) {
                        if (j != k && i == a[j]) {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag) {
                        if (k < 8) {
                            dfs(k + 1);
                        } else if (k == 8 && check(a)) {
                            records= Arrays.copyOfRange(a,0,N);
                            count++;
                        }
                    }
                }
                a[k] = 0;
            }

        }
    }

    static boolean check(int a[]) {
        for (int i = 0; i < N; i++)
            if (a[i] == 0) return false;
        int t1 = a[0] + a[1] + a[2];
        int t2 = a[3] + a[4] + a[5];
        int t3 = a[6] + a[7] + a[8];

        int t4 = a[0] + a[3] + a[6];
        int t5 = a[1] + a[4] + a[7];
        int t6 = a[2] + a[5] + a[8];
        int t7 = a[0] + a[4] + a[8];
        int t8 = a[2] + a[4] + a[6];
        if (t1 == t2 && t1 == t3 && t1 == t4 && t1 == t5 && t1 == t6 && t1 == t7 && t1 == t8) {
            return true;
        }
        return false;
    }

    static void p(int[] a) {
        for (int i = 1; i < a.length + 1; i++) {
            System.out.print(a[i - 1] + " ");
            if (i % 3 == 0) {
                System.out.println();
            }
        }
    }
}