Openjudge-2787-算24

这题的话，我们思考一下，我们首先选两个数进行计算，两个数计算之后是一个数，加上之前的两个数，就是三个数。

然后再进行计算，再选两个数再进行计算，然后剩下两个数，然后再进行计算，就剩下一个数了， 这时候我们就判断它是否等于二十四。

判断的方法是浮点数的精度进行比较，我们设一个10的-6次方精度，如果某浮点数与24的差的绝对值小于这个精度，我们就判定它们相等。

计算的方法有6种，加减乘除，减和除法，分别有两种，除法进行的时候，我们首先判断一下除数是否等于零，避免出现计算错误。

需要注意的是我们每次都在一个函数里面开一个大小为5的数组，用来存储我们经过计算之后的几个数字，然后把数字传入下一层的计算函数，只有这样我们才不会交叉使用同一个数组。

互相不干扰使用，这样才不容易出错。当然了，理论上应该是不会出错的。

少算一种方法是不能过的。

#include <iostream>
#include <cmath>
using namespace std;
const double EPS=1e-6;

bool isZero(double x)
{
    return fabs(x)<=EPS;
}

bool Count24(double a[],int n)
{
    if (n==1) {
        if (isZero(a[0]-24))
            return true;
        else 
            return false;
    }
    for (int i=0;i<n-1;i++) {
    	double b[5];
        for (int j=i+1;j<n;j++) {
            int m=0;
            for (int k=0;k<n;k++) {
                if (k!=i&&k!=j) {
                    b[m++]=a[k];
                }
            }
            b[m]=a[i]+a[j];
            if (Count24(b,m+1))
                return true;
            b[m]=a[i]-a[j];
            if (Count24(b,m+1))
                return true;
            b[m]=a[j]-a[i];
            if (Count24(b,m+1))
                return true;
            b[m]=a[i]*a[j];
            if (Count24(b,m+1)) 
                return true;
            if (!isZero(a[i])) {
                b[m]=a[j]/a[i];
                if (Count24(b,m+1))
                    return true;
            }
            if (!isZero(a[j])) {
                b[m]=a[i]/a[j];
                if (Count24(b,m+1))
                    return true;
            }    
        }
    }
    return false;
}

int main()
{
    double b[5];
    while (cin>>b[0]>>b[1]>>b[2]>>b[3]&&b[0]&&b[1]&&b[2]&&b[3]) {
        if (Count24(b,4))
            cout<<"YES"<<endl;
        else 
            cout<<"NO"<<endl; 
    }
    return 0;
}