递归3---算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

n个数算24，必有两个数要先算。这两个数算的结果，和剩余n-2个数，就构成了n-1个数求24的问题枚举先算的两个数，以及这两个数的运算方式。边界条件?注意：浮点数比较是否相等，不能用 ==

#include <iostream>
#include <cmath>
using namespace std;
double a[5];
#define EPS 1e-6
bool isZero(double x)
{
	return fabs(x)<= EPS;//判断是否等于 0
}
bool count24(double a[],int n)//递归运算，知道m+1==
{
	//用数组a里的 n个数，计算24
	if( n == 1 ) 
	{
		if(isZero( a[0] - 24) )
			return true;
		else
			return false;
	}
	double b[5];
	for(int i = 0;i < n-1; ++i)
		for(int j = i+1;j < n; ++j) 
		{ //枚举两个数的组合
			int m = 0; //还剩下m个数, m = n - 2
			for(int k = 0; k < n; ++k)
				if( k != i && k!= j)
					b[m++] = a[k];//把其余数放入b，然后把那俩个数进行 + - * / 分别进行判断，总的循环一直在更替也在递归?
			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[j])) 
			{
				b[m] = a[i]/a[j];
				if(count24(b,m+1))
					return true;
			}
			if( !isZero(a[i])) // 判断分母不是0
			{
				b[m] = a[j]/a[i];
				if(count24(b,m+1))
					return true;
			}
		}
		return false;
}
int main()
{
	while(true)
	{
		for(int i = 0;i < 4; ++i)
			cin >> a[i];
		if( isZero(a[0]))
			break;
		if( count24(a,4))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}
	return 0;
}