华为OD机试 - 三阶积幻方（Java 2024 E卷 100分）

news2024/9/30 20:48:39

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（E卷+D卷+A卷+B卷+C卷）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

九宫格是一款广为流传的游戏，起源于河图洛书。

游戏规则 Q 是：1到9的九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之和都等于15。

在金庸名著《射雕英雄传》中黄蓉曾给九宫格 Q 的一种解法，口诀：戴九履一，左三右七，二四肩背，八六为足，五居中央。解法如图所示。

在这里插入图片描述

现在有一种新的玩法，给九个不同的 Q 数字，将这九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之积相等（三阶积幻方）。其中一个三阶幻方如图：

在这里插入图片描述
解释：每行、每列以及两个对角线上的三数之积相等，其为216，该示例的每个三数积均为216，满足三阶积幻方的要求。排列后的九个数字中：第1-3个数字为方格的第一行，第4-6个数字为方格的第二行，第7-9个数字为方格的第三行。

二、输入描述

九个不同的数字，每个数字之间用空格分开。

0 < 数字 < 10⁷。

0 排列后满足要求的每行，每列以及两个对角线上的三数之积 < 2^31-1。

三、输出描述

九个数字所有满足要求的排列，每个数字之间用空格分开。

每行输出一个满足要求的排列。

要求输出的排列升序排列，即：对于排列 A(A1,A2,A3…A9) 和排列 B(B1,B2,B3…B9)，从排列的第 1 个数字开始，遇到 Ai < Bi，则排列 A < 排列 B (1 <= i <= 9)。

说明：用例保证至少有一种排列组合满足条件。

四、测试用例

测试用例1：

1、输入

75 36 10 4 30 225 90 25 12

2、输出

10 36 75 225 30 4 12 25 90
10 225 12 36 30 25 75 4 90
12 25 90 225 30 4 10 36 75
12 225 10 25 30 36 90 4 75
75 4 90 36 30 25 10 225 12
75 36 10 4 30 225 90 25 12
90 4 75 25 30 36 12 225 10
90 25 12 4 30 225 75 36 10

3、说明

五、解题思路

为了求解这个问题，我们需要生成输入的九个不同数字的所有排列组合，并检查每个排列是否满足三阶积幻方的条件。具体步骤如下：

读取输入：使用 Scanner 读取九个不同的数字，并存储在一个数组中。
生成排列：通过回溯算法生成所有可能的九个数字的排列组合。由于九个数字的全排列数量为 9! = 362,880，因此在时间允许的范围内，这种方法是可行的。
验证幻方条件：
- 将排列的前九个数字放入 3×3 的格子中。
- 计算每一行、每一列以及两条对角线的三个数字的乘积。
- 检查这些乘积是否都相等。如果相等，则该排列满足三阶积幻方的条件。
收集有效排列：将所有满足条件的排列存储在一个列表中。
排序：根据题目要求，对所有有效排列按升序进行排序。排序的规则是从第一个数字开始，依次比较各个位置的数字大小。
输出结果：按排序后的顺序输出每个有效排列，数字之间用空格分隔。

通过这种方法，我们可以确保找到所有满足条件的排列，并按照要求进行输出。

六、Java算法源码

public class OdTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取九个不同的数字
        int[] numbers = new int[9];
        for (int i = 0; i < 9; i++) {
            numbers[i] = scanner.nextInt();
        }
        scanner.close();

        List<int[]> validPermutations = new ArrayList<>();
        boolean[] used = new boolean[9];
        int[] current = new int[9];

        // 生成所有排列
        permute(numbers, used, current, 0, validPermutations);

        // 排序所有有效的排列
        validPermutations.sort(new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                for (int i = 0; i < 9; i++) {
                    if (a[i] != b[i]) {
                        return a[i] - b[i];
                    }
                }
                return 0;
            }
        });

        // 输出所有有效的排列
        for (int[] perm : validPermutations) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 9; i++) {
                sb.append(perm[i]);
                if (i != 8) sb.append(" ");
            }
            System.out.println(sb.toString());
        }
    }

    // 回溯生成所有排列
    private static void permute(int[] numbers, boolean[] used, int[] current, int index, List<int[]> validPermutations) {
        if (index == 9) {
            if (isValid(current)) {
                // 将当前有效的排列添加到结果列表中
                validPermutations.add(current.clone());
            }
            return;
        }

        for (int i = 0; i < 9; i++) {
            if (!used[i]) {
                used[i] = true;
                current[index] = numbers[i];
                permute(numbers, used, current, index + 1, validPermutations);
                used[i] = false;
            }
        }
    }

    // 检查当前排列是否满足三阶积幻方的条件
    private static boolean isValid(int[] grid) {
        // 计算第一行的乘积作为基准
        long target = (long) grid[0] * grid[1] * grid[2];

        // 检查每一行的乘积
        for (int i = 0; i < 3; i++) {
            long rowProduct = (long) grid[3 * i] * grid[3 * i + 1] * grid[3 * i + 2];
            if (rowProduct != target) return false;
        }

        // 检查每一列的乘积
        for (int i = 0; i < 3; i++) {
            long colProduct = (long) grid[i] * grid[i + 3] * grid[i + 6];
            if (colProduct != target) return false;
        }

        // 检查两条对角线的乘积
        long diag1 = (long) grid[0] * grid[4] * grid[8];
        long diag2 = (long) grid[2] * grid[4] * grid[6];
        if (diag1 != target || diag2 != target) return false;

        return true;
    }
}

七、效果展示

1、输入

2 9 12 36 6 1 3 4 18

2、输出

2 9 12 36 6 1 3 4 18
2 36 3 9 6 4 12 1 18
3 4 18 36 6 1 2 9 12
3 36 2 4 6 9 18 1 12
12 1 18 9 6 4 2 36 3
12 9 2 1 6 36 18 4 3
18 1 12 4 6 9 3 36 2
18 4 3 1 6 36 12 9 2

在这里插入图片描述