蓝桥杯——ALGO995——24点_蓝桥杯 计算24

通过万岁！！！

• 题目：就是给你四张扑克牌，然后尽可能的通过加减乘除和括号得到小于等于24的最大值，最大就是24。注意，除法的时候需要判断是不是整除。
• 思路：猛一看，感觉可能有点难，特别是加括号，这可如何是好。但是再怎么加括号，也是两个数一块运算呗。所以说，每次找两个数，然后进行计算得到一个ans，然后再找一个进行计算…，直到4个数都用完。并且我们记录每次得到的最大的满足条件的数。上面的思路其实就是a，b计算得到ans，然后ans与c计算得到ans，ans再与d计算，得到ans，最终比较max和ans。但是存在一个问题，例如(a+b)*(c+d)的时候，这时候，需要并行的先计算两部分，而之前的思路类似串行计算。这个也简单，我们当计算完a，b的时候，再把这种情况考虑进去就行了，拿到剩下两个c，d计算，然后两个计算结果再计算。
• 技巧：这里其实用到了深度优先，但是这个题的并行(a+b)*(c+d)，是需要额外考虑的。
• 题目链接：http://lx.lanqiao.cn/problem.page?gpid=T2979

java代码

import java.util.Scanner;


/**
* @创建人 xcs
* @创建日期 2022/4/3
* @创建时间 15:01
* 题目链接：http://lx.lanqiao.cn/problem.page?gpid=T2979
*/
public class ALGO995 {
    static int max = 0;


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < n; i++) {
            max = 0;
            int[] nums = new int[4];
            nums[0] = Integer.parseInt(scanner.nextLine());
            nums[1] = Integer.parseInt(scanner.nextLine());
            nums[2] = Integer.parseInt(scanner.nextLine());
            nums[3] = Integer.parseInt(scanner.nextLine());
            // 初始化全false
            boolean[] vis = new boolean[4];
            for (int j = 0; j < 4; j++) {
                vis[j] = true;
                getAns(vis, nums, 1, nums[j]);
                vis[j] = false;
            }
            System.out.println(max);
        }
    }

    private static void getAns(boolean[] vis, int[] nums, int flag, int ans) {
        if (max == 24) {
            return;
        }
        if (4 == flag) {
            max = ans > max && ans <= 24 ? ans : max;
        }
        if (2 == flag) {
            // 选了两个了，然后选择剩下两个(a+b)*(c+d)的情况
            int c = 0, d = 0;
            for (int i = 0; i < 4; i++) {
                if (!vis[i] && flag == 2) {
                    // 没有被选
                    c = nums[i];
                    flag--;
                } else if (!vis[i] && flag == 1) {
                    d = nums[i];
                }
            }
            // 还原
            flag = 2;
            // 下面注销的都是不影响的
            //ans = ans + (c + d);
            //max = ans > max && ans <= 24 ? ans : max;
            //ans = ans - (c + d);
            //ans = ans - (c + d);
            //max = ans > max && ans <= 24 ? ans : max;
            //ans = ans + (c + d);
            ans = ans * (c + d);
            max = ans > max && ans <= 24 ? ans : max;
            ans = ans / (c + d);
            if (ans % (c + d) == 0) {
                ans = ans / (c + d);
                max = ans > max && ans <= 24 ? ans : max;
                ans = ans * (c + d);
            }


            //ans = ans + (c - d);
            //max = ans > max && ans <= 24 ? ans : max;
            //ans = ans - (c - d);
            //ans = ans - (c - d);
            //max = ans > max && ans <= 24 ? ans : max;
            //ans = ans + (c - d);
            if (c != d) {
                ans = ans * (c - d);
                max = ans > max && ans <= 24 ? ans : max;
                ans = ans / (c - d);
                if (ans % (c - d) == 0) {
                    ans = ans / (c - d);
                    max = ans > max && ans <= 24 ? ans : max;
                    ans = ans * (c - d);
                }
            }


            ans = ans + (c * d);
            max = ans > max && ans <= 24 ? ans : max;
            ans = ans - (c * d);
            ans = ans - (c * d);
            max = ans > max && ans <= 24 ? ans : max;
            ans = ans + (c * d);
            //ans = ans * (c * d);
            //max = ans > max && ans <= 24 ? ans : max;
            //ans = ans / (c * d);
            if (ans % (c * d) == 0) {
                ans = ans / (c * d);
                max = ans > max && ans <= 24 ? ans : max;
                ans = ans * (c * d);
            }


            if (c % d == 0) {
                ans = ans + (c / d);
                max = ans > max && ans <= 24 ? ans : max;
                ans = ans - (c / d);
                ans = ans - (c / d);
                max = ans > max && ans <= 24 ? ans : max;
                ans = ans + (c / d);
                //ans = ans * (c / d);
                //max = ans > max && ans <= 24 ? ans : max;
                //ans = ans / (c / d);
                if (ans % (c / d) == 0) {
                    ans = ans / (c / d);
                    max = ans > max && ans <= 24 ? ans : max;
                    ans = ans * (c / d);
                }
            }
        }
        for (int i = 0; i < 4; i++) {
            if (vis[i]) {
                // 选了
                continue;
            }
            // 选第i个
            vis[i] = true;
            // 之前的跟现在这个进行加减乘除
            // 加
            ans += nums[i];
            getAns(vis, nums, flag + 1, ans);
            ans -= nums[i];
            // 减
            ans -= nums[i];
            getAns(vis, nums, flag + 1, ans);
            ans += nums[i];
            // 乘
            ans *= nums[i];
            getAns(vis, nums, flag + 1, ans);
            ans /= nums[i];
            // 除
            if (ans % nums[i] == 0) {
                ans /= nums[i];
                getAns(vis, nums, flag + 1, ans);
                ans *= nums[i];
            }
            vis[i] = false;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

• 总结：题目还是比较有意思的，代码虽然有点长，但是大多数是重复的部分。