算24（递归）

题目链接:OpenJ_Bailian

Description

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

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

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

Input

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

Output

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

Sample Input

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

Sample Output

YES
NO

题解：

判断四个数能否通过四则运算最后的和为24。本题采用的思路是递归。因为四个数中任意两个数运算之后，接下来的操作就是在剩余的数中重复上一步操作。这个递归的状态转移是数组中的数字变少，而终止条件为最后数组中只有一个数了。If the last only number is equal to 24，那我们就可以输出YES了，否则就输出NO。

代码

#include<iostream>
#include<cmath>
using namespace std;
#define esp 1e-6
double a[5];
//浮点数不能用==
 bool is_zero(double x){
	 return abs(x) < esp;
}
 bool count24(double a[], int n) {
	 if (n == 1) {
		 //此时b数组中只有一个数，即四个数运算完毕
		 if (is_zero(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;
			 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 1;
			 b[m] = a[i] - a[j];
			 if (count24(b, m+1))return 1;
			 b[m] = -a[i] +a[j];
			 if (count24(b, m+1))return 1;
			 b[m] = a[i] * a[j];
			 if (count24(b, m+1))return 1;
			 if (!is_zero(a[i]))
			 {
				 b[m] = a[j]/a[i];
				 if (count24(b, m+1))return 1;
			 }
			 if (!is_zero(a[j]))
			 {
				 b[m] = a[i] / a[j];
				 if (count24(b, m+1))return 1;
			 }
		 }
	 return false;
 }
int main()
{
	//原始数组为a,操作之后的数组为b,b中数组只有一个数，为边界条件
	while(true)
	{
		for (int i = 0; i < 4; i++)
			cin >> a[i];
			if (a[0] == 0)break;
				if (count24(a, 4))cout << "YES" << endl;
				else cout << "NO" << endl;
	}
	return 0;
}

算24 算24（递归）