24点问题（带输出构造方式）

那就随便一点

于 2022-12-03 10:42:53 发布

阅读量716

点赞数

分类专栏： # 回溯法文章标签：算法 c++ 回溯法穷举法

本文链接：https://blog.csdn.net/m0_65508678/article/details/128158409

版权

回溯法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

问题描述：

在屏幕上输入1〜10范围内的4个整数（可以有重复），对它们进行加、减、乘、除四则运算后（可以任意的加括号限定计算的优先级），寻找计算结果等于24的表达式。

例如输入4个整数4、5、6、7，可得到表达式：4*((5-6)+7)=24。这只是一个解，要求输出全部的解。要求表达式中数字的顺序不能改变。

思路：

拼凑加减乘除，使4个数的运算结果等于24。

由于四则运算中，乘除的优先级高于加减，所以必须“加括号”来限定4个数之间运算优先级。

例如：A+B*C-D 这个式子，通过增加括号，可以产生多种结果，比如 (A+B)*(C-D) 和 A+(B*C-D)。

那么总共有几种加括号的方法呢，该如何分类呢？

要想将4个数字的运算优先级细分，必须使用两对括号。

可以这么理解：我们的目的是将4个数的运算转换成两个“数”的运算（这里的“数”包括括号表达式），而每两个数运算，就能得出一个结果，即每对括号可以减少一个要计算的数字（如(A+B)*(C+D)中，A和B运算，使式子变成了3个数，C接着和D运算，使式子剩下两个数字）。4-2=2即为需要的括号数。

下面列举所有可能的括号表达式：（#表示四则运算符）

((A#B)#C)#D
(A#(B#C))#D
A#((B#C)#D)
A#(B#(C#D))
(A#B)#(C#D)

具体思路：

上面5种括号表达式都可以单独写成函数，函数内部按照括号的优先级+从左往右的顺序进行运算，最后返回计算结果。

每个表达式中有3个'#'号，它们是四则运算符（+、-、*、/），可以定义一个全局字符数组，存放4这四个字符。

char my_oprator[4] = {'+', '-', '*', '/'};

主函数使用穷举法，对表达式的每个#符号进行遍历（4种运算符），使用3层 for 循环实现（层数对应3个#符号，每层循环4次，对应4种运算符），最后将符合条件的表达式输出。

【注意】：由于式子中存在除法，所以不能用整型数据进行计算（比如(int)(2/4) = 0），应该使用float或double类型。

浮点数的表示是不精确的，所以运算结果不能直接和 24 比较。它们可能只是在某个范围内相等，如float变量的精度为小数点后六位，所以我们只要保证小数点后 6 位和 24 相等（全为0）即可。

可以使用如下语句进行判断：

if(ret - 24 <= 0.000001 && ret - 24 >= -0.000001)

ret为运算结果，这个 if 语句的作用是判断运算结果 ret 和 24 之间的差值是否超过±0.000001。

代码：

#include <bits/stdc++.h>
#define TARGET_POINT  24    

char my_oprator[4] = {'+', '-', '*', '/'};

float Calculate(float x, float y, char op){
    switch(op){
        case '+': return x + y;
        case '-': return x - y;
        case '*': return x * y;
        case '/':return x / y;
        default: printf("非法运算符\n");
    }
    return 0;
}

float Expression_1(float a, float b, float c, float d, char op1, char op2, char op3){
    float ret = 0;
    ret = Calculate(a, b, op1);   //求出 A#B 的结果
    ret = Calculate(ret, c, op2); //求出 ret#C 的结果
    ret = Calculate(ret, d, op3); //求出 ret#D 的结果
    return ret;
}


float Expression_2(float a, float b, float c, float d, char op1, char op2, char op3){
    float ret = 0;
    ret = Calculate(b, c, op2);   //求出 B#C 的结果
    ret = Calculate(a, ret, op1); //求出 A#ret 的结果
    ret = Calculate(ret, d, op3); //求出 ret#D 的结果
    return ret;
}

float Expression_3(float a, float b, float c, float d, char op1, char op2, char op3){
    float ret = 0;
    ret = Calculate(b, c, op2);   //求出 B#C 的结果
    ret = Calculate(ret, d, op3); //求出 ret#D 的结果
    ret = Calculate(a, ret, op1); //求出 A#ret 的结果
    return ret;
}

float Expression_4(float a, float b, float c, float d, char op1, char op2, char op3){
    float ret = 0;
    ret = Calculate(c, d, op3);   //求出 C#D 的结果
    ret = Calculate(b, ret, op2); //求出 B#ret 的结果
    ret = Calculate(a, ret, op1); //求出 A#ret 的结果
    return ret;
}

float Expression_5(float a, float b, float c, float d, char op1, char op2, char op3){
    float ret1 = 0, ret2 = 0;
    ret1 = Calculate(a, b, op1);   //求出 A#B 的结果
    ret2 = Calculate(c, d, op3);   //求出 C#D 的结果
    ret2 = Calculate(ret1, ret2, op2); //求出 ret1#ret2 的结果
    return ret2;
}

int main(){
    float a = 0, b = 0, c = 0, d = 0;
    int i = 0, j = 0, k = 0;
    float ret = 0;
    int flag = 0;  //是否有匹配结果，1：有结果

    scanf("%f %f %f %f", &a, &b, &c, &d);

    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            for(k = 0; k < 4; k++){
            	
                //表达式1：((A#B)#C)#D
                ret = Expression_1(a, b, c, d,\
                                   my_oprator[i],\
                                   my_oprator[j],\
                                   my_oprator[k]);
                //判断结果是否为目标点数，精度0.000001
                if(ret - TARGET_POINT <= 0.000001 &&\
                        ret - TARGET_POINT >= -0.000001){
                    printf("((%.0f%c%.0f)%c%.0f)%c%.0f=%.0f\n",\
                           a, my_oprator[i],\
                           b, my_oprator[j],\
                           c, my_oprator[k], d, ret);
                    flag = 1; //成功匹配
                }

                //表达式2：(A#(B#C))#D
                ret = Expression_2(a, b, c, d,\
                                   my_oprator[i],\
                                   my_oprator[j],\
                                   my_oprator[k]);
                //判断结果是否为目标点数，精度0.000001
                if(ret - TARGET_POINT <= 0.000001 &&\
                        ret - TARGET_POINT >= -0.000001){
                    printf("(%.0f%c(%.0f%c%.0f))%c%.0f=%.0f\n",\
                           a, my_oprator[i],\
                           b, my_oprator[j],\
                           c, my_oprator[k], d, ret);
                    flag = 1; //成功匹配
                }

                //表达式3：A#((B#C)#D)
                ret = Expression_3(a, b, c, d,\
                                   my_oprator[i],\
                                   my_oprator[j],\
                                   my_oprator[k]);
                //判断结果是否为目标点数，精度0.000001
                if(ret - TARGET_POINT <= 0.000001 &&\
                        ret - TARGET_POINT >= -0.000001){
                    printf("%.0f%c((%.0f%c%.0f)%c%.0f)=%.0f\n",\
                           a, my_oprator[i],\
                           b, my_oprator[j],\
                           c, my_oprator[k], d, ret);
                    flag = 1; //成功匹配
                }

                //表达式4：A#(B#(C#D))
                ret = Expression_4(a, b, c, d,\
                                   my_oprator[i],\
                                   my_oprator[j],\
                                   my_oprator[k]);
                //判断结果是否为目标点数，精度0.000001
                if(ret - TARGET_POINT <= 0.000001 &&\
                        ret - TARGET_POINT >= -0.000001){
                    printf("%.0f%c(%.0f%c(%.0f%c%.0f))=%.0f\n",\
                           a, my_oprator[i],\
                           b, my_oprator[j],\
                           c, my_oprator[k], d, ret);
                    flag = 1; //成功匹配
                }

                //表达式5：(A#B)#(C#D)
                ret = Expression_5(a, b, c, d,\
                                   my_oprator[i],\
                                   my_oprator[j],\
                                   my_oprator[k]);
                //判断结果是否为目标点数，精度0.000001
                if(ret - TARGET_POINT <= 0.000001 &&\
                        ret - TARGET_POINT >= -0.000001){
                    printf("(%.0f%c%.0f)%c(%.0f%c%.0f)=%.0f\n",\
                           a, my_oprator[i],\
                           b, my_oprator[j],\
                           c, my_oprator[k], d, ret);
                    flag = 1; //成功匹配
                }
            }
            
    if(flag == 0)
        printf("没有满足条件的表达式\n");
        
    return 0;
}