24点游戏中的去重和括号

24点游戏中的去重和括号是通过构建表达式树来实现的。具体步骤如下：

 

 

构建表达式树：将给定的四个数字作为叶子节点，将加减乘除四种运算符作为非叶子节点，构建表达式树。

 

遍历表达式树：从根节点开始遍历表达式树，对于每个非叶子节点，分别以其左右子节点为根节点，递归遍历左右子树，得到左右子树的所有表达式。

 

去重：对于每个非叶子节点，将其左右子树的所有表达式两两组合，得到新的表达式，并将新表达式加入到当前节点的表达式列表中。在加入新表达式之前，需要先对新表达式进行排序和去重操作，以避免重复。

 

加括号：对于每个非叶子节点，将其左右子树的所有表达式两两组合，得到新的表达式，并将新表达式加入到当前节点的表达式列表中。在加入新表达式之前，需要先对新表达式进行排序和去重操作，以避免重复。在加入新表达式之后，还需要对新表达式加上括号，以避免运算顺序的问题。

 

下面是一个示例代码，演示如何实现24点游戏中的去重和括号：

# 定义表达式树节点

class TreeNode:

    def __init__(self, val, left=None, right=None):

        self.val = val

        self.left = left

        self.right = right

        self.expressions = []

 

# 构建表达式树

def buildExpressionTree(nums):

    if len(nums) == 1:

        return TreeNode(nums[0])

    else:

        root = TreeNode(None)

        for i in range(1, len(nums)):

            left = buildExpressionTree(nums[:i])

            right = buildExpressionTree(nums[i:])

            for l in left.expressions:

                for r in right.expressions:

                    root.expressions.append(l + '+' + r)

                    root.expressions.append(l + '-' + r)

                    root.expressions.append(l + '*' + r)

                    if r != '0':

                        root.expressions.append(l + '/' + r)

            root.left = left

            root.right = right

        return root

 

# 去重和加括号

def simplifyExpressions(root):

    if root.left is None and root.right is None:

        root.expressions.append(str(root.val))

    else:

        simplifyExpressions(root.left)

        simplifyExpressions(root.right)

        for i in range(len(root.expressions)):

            for j in range(i + 1, len(root.expressions)):

                exp1 = root.expressions[i]

                exp2 = root.expressions[j]

                exps = [exp1 + '+' + exp2, exp1 + '-' + exp2, exp1 + '*' + exp2]

                if exp2 != '0':

                    exps.append(exp1 + '/' + exp2)

                for exp in exps:

                    newExp = '(' + exp + ')'

                    newExpSorted = ''.join(sorted(newExp))

                    if newExpSorted not in root.expressions:

                        root.expressions.append(newExpSorted)

为了判断给定的四个数字是否可以通过四则运算计算得出24，我们可以使用递归的方法，将四个数字分成两组，每组两个数字，然后对这两组数字进行四则运算，得到一个新的数字，将这个新数字和剩下的两个数字组成新的两组数字，再进行四则运算，直到最后得到24或者无法得到24为止。

 

以下是Java代码实现：

 

#java

public class Calculate24 {

    private static final double TARGET = 24;

    private static final double EPSILON = 1e-6;

    

    public static boolean judgePoint24(int[] nums) {

        double[] arr = new double[]{nums[0], nums[1], nums[2], nums[3]};

        return dfs(arr);

    }

    

    private static boolean dfs(double[] arr) {

        if (arr.length == 1) {

            return Math.abs(arr[0] - TARGET) < EPSILON;

        }

        for (int i = 0; i < arr.length; i++) {

            for (int j = 0; j < arr.length; j++) {

                if (i == j) {

                    continue;

                }

                double[] newArr = new double[arr.length - 1];

                int index = 0;

                for (int k = 0; k < arr.length; k++) {

                    if (k != i && k != j) {

                        newArr[index++] = arr[k];

                    }

                }

                for (double num : compute(arr[i], arr[j])) {

                    newArr[newArr.length - 1] = num;

                    if (dfs(newArr)) {

                        return true;

                    }

                }

            }

        }

        return false;

    }

    

    private static double[] compute(double a, double b) {

        return new double[]{a + b, a - b, b - a, a * b, a / b, b / a};

    }

}

```

 

 

调用`judgePoint24`方法，传入一个长度为4的整数数组，即可判断这四个数字是否可以通过四则运算计算得出24。