第十三届蓝桥杯大赛软件赛省赛大学 A 组-D题-矩形拼接-Java

题目描述

已知 3 个矩形的大小依次是 a1 × b1, a2 × b2 和 a3 × b3。用这 3 个矩形能拼出的所有多边形中，边数最少可以是多少？例如用 3 × 2 的矩形（用 A 表示）、4 × 1 的矩形（用 B 表示）和 2 × 4 的矩形（用 C 表示）可以拼出如下 4 边形。

例如用 3 × 2 的矩形（用 A 表示）、3 × 1 的矩形（用 B 表示）和 1 × 1 的矩形（用 C 表示）可以拼出如下 6 边形。

输入格式

输入包含多组数据。

第一行包含一个整数 T，代表数据组数。

以下 T 行，每行包含 6 个整数 a1, b1, a2, b2, a3, b3，其中 a1, b1 是第一个矩形的边长，a2, b2 是第二个矩形的边长，a3, b3 是第三个矩形的边长。

输出格式

对于每组数据，输出一个整数代表答案。

样例输入

复制

2
2 3 4 1 2 4
1 2 3 4 5 6

样例输出

复制

4
6

 
解题思路-暴力解法

        先思考能拼接出的可能一共有三种：4，6，8

        4：三个矩形都有一条长度相等的边、两个矩形有一条长度相等的边且这两个矩形的另外两条边的长度和等于第三个矩形其中一边的长度

        6：两个矩形有一条长度相等的边、两个矩形的两条边之和等一另外一个矩形其中一条边

        8：其余情况

public class rectangular_splicing_809 {
    static int[][] s = {
            {0, 1, 2},
            {0, 2, 1},
            {1, 0, 2},
            {1, 2, 0},
            {2, 0, 1},
            {2, 1, 0}
    };
    static int[][] s1 = {
            {0, 0, 0},
            {0, 0, 1},
            {0, 1, 0},
            {0, 1, 1},
            {1, 0, 0},
            {1, 0, 1},
            {1, 1, 0},
            {1, 1, 1}
    };

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = Integer.parseInt(scanner.nextLine());
        String[] inPut = new String[num];
//        输入次数
        for (int i = 0; i < num; i++) {
            inPut[i] = scanner.nextLine();
        }
        // 交换矩形顺序
        for (int i = 0; i < num; i++) {
            String[] l = inPut[i].split(" ");
            int[][] L = StringToInt(l);
            int[][] ans = new int[6][8];
            // 交换矩形长宽
            for (int j = 0; j < 6; j++) {
                int[][] L1 = chageL(L, s[j]);
                for (int k = 0; k < 8; k++) {
                    for (int m = 0; m < 3; m++) {
                        if (s1[k][m] == 1) {
                            L1[m] = changeIt(L1[m]);
                        }
                    }
                    ans[j][k] = getIt(L1);
                }
            }
            System.out.println(getMin(ans));
        }
    }

    //    private static void suchu(int[][] l1) {
//        for (int i = 0; i < l1.length; i++) {
//            for (int j = 0; j < l1[i].length; j++) {
//                System.out.print(l1[i][j]);
//            }
//        }
//        System.out.println();
//    }
    // 交换长宽
    private static int[][] chageL(int[][] l, int[] i) {
        int[][] L = new int[3][2];
        for (int j = 0; j < l.length; j++) {
            for (int k = 0; k < l[j].length; k++) {
                L[j][k] = l[i[j]][k];
            }
        }
        return L;
    }

    // 获取最小值
    private static int getMin(int[][] ans) {
        int num = ans[0][0];
        for (int i = 0; i < ans.length; i++) {
            for (int j = 0; j < ans[i].length; j++) {
                if (num > ans[i][j]) {
                    num = ans[i][j];
                }
            }
        }
        return num;
    }

    // 交换矩形顺序
    private static int[] changeIt(int[] l) {
        int[] L = new int[l.length];
        L[0] = l[1];
        L[1] = l[0];
        return L;
    }

    private static int[][] StringToInt(String[] l) {
        int[][] ans = new int[3][2];
        for (int i = 0, j = 0; i < 3; i++, j += 2) {
            ans[i][0] = Integer.parseInt(l[j]);
            ans[i][1] = Integer.parseInt(l[j + 1]);
        }
        return ans;
    }

    // 计算改顺序组成的边数量
    public static int getIt(int[][] l) {
        if ((l[0][0] == l[1][0] && l[0][0] == l[2][0]) || (l[0][0] == l[1][0] && l[0][1] + l[1][1] == l[2][0]))
            return 4;
        if ((l[0][0] == l[1][0]) || l[0][0] + l[1][0] == l[2][0]) return 6;
        return 8;
    }


}