POJ 2787:算24

描述

给出4个小于10个正整数，你可以使用加减乘除4种运算以及括号把这4个数连接起来得到一个表达式。现在的问题是，是否存在一种方式使得得到的表达式的结果等于24。

这里加减乘除以及括号的运算结果和运算的优先级跟我们平常的定义一致（这里的除法定义是实数除法）。

比如，对于5，5，5，1，我们知道5 * (5 – 1 / 5) = 24，因此可以得到24。又比如，对于1，1，4，2，我们怎么都不能得到24。

输入

输入数据包括多行，每行给出一组测试数据，包括4个小于10个正整数。最后一组测试数据中包括4个0，表示输入的结束，这组数据不用处理。

输出

对于每一组测试数据，输出一行，如果可以得到24，输出“YES”；否则，输出“NO”。

样例输入

5 5 5 1
1 1 4 2
0 0 0 0

样例输出

YES
NO

    1. 每次从数组中选出两个数字,进行加减乘除
    2. 注意dfs() 函数中的n 代表的是数组a中的元素个数
    3. 注意数组要设置成double类型

#include<iostream>
#include<cmath>
using namespace std;

bool flag = false;

void dfs(double m[], int n){
    
    if (n == 1 && fabs(m[0] - 24) < 0.001){
        flag = true;
        return;
    }
    
    else if (n > 1){
        double a[4];
        int i,j,idx;
        for (i = 0 ; i < n; ++i){
            for (j = 0; j < n; ++j){
                if (i == j) continue;
                idx = 0;
                for (int k = 0; k < n; ++k)
                    if (k != i && k != j)
                        a[idx++] = m[k];
                        
                a[idx] = m[i] + m[j];
                dfs(a,idx + 1);
                
                a[idx] = m[i] - m[j];
                dfs(a,idx + 1);
                
                a[idx] = m[i] * m[j];
                dfs(a,idx + 1);
                
                if (m[j] > 1e-6){
                    a[idx] = m[i] / (1.0 * m[j]);
                    dfs(a,idx + 1);
                }
            }
        }
    }
}

int main(){
    double m[4];
    while(~scanf("%lf%lf%lf%lf", &m[0], &m[1], &m[2], &m[3]) && (m[0] || m[1] || m[2] || m[3])){
        flag = false;
        dfs(m,4);
        if (flag)
            puts("YES");
        else puts("NO");
        flag = false;
    }
    return 0;