题目描述 24点游戏的玩法是这样的：任取一幅牌中的 4张牌(不含大小王），每张牌上有数字（其中A 代表1，J 代表11，Q 代表 12，K代表13），你可以利用数学中的加、减、乘、除以及括号想办法得到24，每张牌只能用一次。例如有四张6，那么6+6+6+6=24，也可以6*6-6-6=24。但是有些牌是无法得到24的，比如两张 A 和两张2。 读入表达式树的先序遍历字符串, 这里的表达式树是来自24点游戏的真实场景，也就是对应四个数字（值在1到13之间）组成的表达式，问该表达式树能不能得到24？ 输入 输入由多组测试数据组成。 每组数据包含一行字符串，即24点游戏的表达式树的先序遍历序列。 输出 对于每组数据，输出一行。如果不能得到24，输出“NO”。如果能得到24，按样例输出。 样例输入 Copy + + + 6 # # 6 # # 6 # # 6 # # - - * 6 # # 6 # # 6 # # 6 # # * * 1 # # 2 # # * 1 # # 2 # # 样例输出 Copy (((6+6)+6)+6)=24 (((6*6)-6)-6)=24 NO代码实现

以下是Python代码实现：

def evaluate(node):
    if node.val is not None:
        return node.val
    left = evaluate(node.left)
    right = evaluate(node.right)
    if node.op == "+":
        return left + right
    elif node.op == "-":
        return left - right
    elif node.op == "*":
        return left * right
    else:
        return left / right

class Node:
    def __init__(self, op=None, val=None, left=None, right=None):
        self.op = op
        self.val = val
        self.left = left
        self.right = right

def build_tree(expr):
    stack = []
    for i in range(len(expr)-1, -1, -1):
        c = expr[i]
        if c.isdigit():
            stack.append(Node(val=int(c)))
        else:
            left = stack.pop()
            right = stack.pop()
            stack.append(Node(op=c, left=left, right=right))
    return stack[0]

def solve(expr):
    tree = build_tree(expr)
    for p1 in range(4):
        for p2 in range(4):
            if p2 == p1:
                continue
            for p3 in range(4):
                if p3 == p1 or p3 == p2:
                    continue
                for p4 in range(4):
                    if p4 == p1 or p4 == p2 or p4 == p3:
                        continue
                    nums = [tree.val, tree.left.val, tree.right.val, tree.left.left.val]
                    nums[p1] = tree.val
                    nums[p2] = tree.left.val
                    nums[p3] = tree.right.val
                    nums[p4] = tree.left.left.val
                    ops = [tree.op, tree.left.op, tree.right.op, tree.left.left.op]
                    expr = str(nums[0])
                    for i in range(3):
                        expr += ops[i] + str(nums[i+1])
                    try:
                        if evaluate(build_tree(expr)) == 24:
                            return "({}{}({}{}({}{}({}{}){}{})))=24".format(nums[p1], ops[0], nums[p2], ops[1], nums[p3], ops[2], nums[p4], ops[3], nums[0], ops[1], nums[1])
                    except:
                        pass
    return "NO"

while True:
    try:
        expr = input()
        print(solve(expr))
    except:
        break

代码思路：

首先，我们需要将输入的字符串构建成表达式树。这可以通过使用栈来实现。从右往左扫描字符串中的每个字符，如果是数字，则将它压入栈中；如果是操作符，则弹出两个数字，构建一个新的节点，并将这个节点压入栈中。最终，栈中只剩下一个节点，它就是整个表达式树的根节点。

接下来，我们通过枚举所有可能的四张牌的排列方式，将表达式中的数字替换成这四张牌的值，再计算表达式的结果。如果结果等于24，则将这个表达式转化成题目所要求的格式，并输出；否则继续枚举下一组牌的排列方式。