24游戏

go
package main

import (
	"fmt"
	"math"
)

const (
	TARGET   = 24
	EPSILON  = 1e-6
	ADD      = 0
	MULTIPLY = 1
	SUBTRACT = 2
	DIVIDE   = 3
)

func judgePoint24(nums []int) bool {
	var l []float64
	for _, num := range nums {
		l = append(l, float64(num))
	}
	return solve(l)
}

func solve(l []float64) bool {
	if len(l) == 0 {
		return false
	}
	if len(l) == 1 {
		return math.Abs(l[0]-TARGET) < EPSILON
	}
	size := len(l)
	for i := 0; i < size; i++ {
		for j := 0; j < size; j++ {
			if i != j {
				list2 := make([]float64, 0)
				for k := 0; k < size; k++ {
					if k != i && k != j {
						list2 = append(list2, l[k])
					}
				}
				for k := 0; k < 4; k++ {
					if k < 2 && i > j {
						continue
					}
					var a float64
					if k == ADD {
						a = l[i] + l[j]
					} else if k == MULTIPLY {
						a = l[i] * l[j]
					} else if k == SUBTRACT {
						a = l[i] - l[j]
					} else if k == DIVIDE {
						if math.Abs(l[j]) < EPSILON {
							continue
						}
						a = l[i] / l[j]
					}
					list2 = append(list2, a)
					if solve(list2) {
						return true
					}
					list2 = list2[:len(list2)-1] // 回溯
				}
			}
		}
	}
	return false
}

func main() {
	// 示例用法
	nums := []int{4, 1, 8, 7}
	result := judgePoint24(nums)

	fmt.Printf("%t\n", result)
}

cpp

cpp
class Solution {
public:
    // 目标值
    static constexpr int TARGET = 24;
    // 浮点数比较的精度
    static constexpr double EPSILON = 1e-6;
    // 加法、乘法、减法、除法对应的数字
    static constexpr int ADD = 0, MULTIPLY = 1, SUBTRACT = 2, DIVIDE = 3;

    // 判断是否能组成 24 点
    bool judgePoint24(vector<int> &nums) {
        // 将整数数组转换为浮点数数组
        vector<double> l;
        for (const int &num : nums) {
            l.emplace_back(static_cast<double>(num));
        }
        // 调用 solve 函数进行递归求解
        return solve(l);
    }

    // 递归求解是否能组成 24 点
    bool solve(vector<double> &l) {
        // 如果当前数字列表为空，则返回 false
        if (l.size() == 0) {
            return false;
        }
        // 如果当前数字列表只有一个数字，则判断是否等于目标值
        if (l.size() == 1) {
            return fabs(l[0] - TARGET) < EPSILON;
        }
        // 获取当前数字列表的大小
        int size = l.size();
        // 遍历所有数字的组合
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (i != j) {
                    // 生成一个新的数字列表，排除当前选中的两个数字
                    vector<double> list2 = vector<double>();
                    for (int k = 0; k < size; k++) {
                        if (k != i && k != j) {
                            list2.emplace_back(l[k]);
                        }
                    }
                    // 遍历所有可能的运算符
                    for (int k = 0; k < 4; k++) {
                        // 加法和乘法满足交换律，为避免重复计算，i > j 时跳过
                        if (k < 2 && i > j) {
                            continue;
                        }
                        // 根据当前运算符，计算新的数字，并加入到新列表中
                        if (k == ADD) {
                            list2.emplace_back(l[i] + l[j]);
                        } else if (k == MULTIPLY) {
                            list2.emplace_back(l[i] * l[j]);
                        } else if (k == SUBTRACT) {
                            list2.emplace_back(l[i] - l[j]);
                        } else if (k == DIVIDE) {
                            // 除法需要注意除数不能为零
                            if (fabs(l[j]) < EPSILON) {
                                continue;
                            }
                            list2.emplace_back(l[i] / l[j]);
                        }
                        // 递归调用 solve 函数
                        if (solve(list2)) {
                            return true;
                        }
                        // 回溯，移除最后加入的数字
                        list2.pop_back();
                    }
                }
            }
        }
        // 未找到满足条件的组合
        return false;
    }
};