算 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

【代码分析】

FourShu函数

• 功能：该函数用于生成输入的四个数的所有 24 种排列可能。通过四层嵌套的循环，排除重复的排列情况，将不同排列依次存入二维数组ZuHe中。
• 参数：接受一个包含四个整数的数组a，以及一个用于存储排列结果的二维数组ZuHe（大小为 24 行 4 列，用于存放 24 种排列后的四个数）。

FourFu函数

• 功能：实现了四种基本四则运算（加、减、乘、除）。根据传入的运算符字符s，对输入的两个数a和b进行相应运算，并返回运算结果。在进行除法运算时，会判断除数b是否为 0，若为 0 则返回 -1 表示错误。
• 参数：接受两个双精度浮点数a和b作为运算数，以及一个字符s表示运算符。

Bool1函数

• 功能：对应判断运算先后顺序为((A#B)#C)#D这种情况是否能得到结果 24。首先生成输入数组A的所有 24 种排列，然后通过三层嵌套循环遍历四种运算符的所有可能组合，按照((A#B)#C)#D的运算顺序依次进行计算，每次计算后与 24 进行比较（考虑到浮点数精度问题，使用abs(result3 - 24) < 0.000001来判断是否相等），若相等则返回true，否则继续尝试其他组合，若所有组合都尝试完仍未得到 24，则返回false。
• 参数：接受一个包含四个整数的数组A。

Bool2函数

• 功能：应该是对应判断运算先后顺序为(A#(B#C))#D这种情况是否能得到结果 24。其整体思路可能与Bool1函数类似，也是先生成输入数组的所有排列，然后通过多层嵌套循环遍历运算符组合，按照(A#(B#C))#D的运算顺序进行计算并与 24 比较，根据结果返回true或false。
• 参数：接受一个包含四个整数的数组作为参数，用于进行相关运算和判断。

【代码实现】

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

//四个数的24种排列可能
void FourShu(int a[4], double ZuHe[24][4])
{
	int Hang = 0;
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			if (i == j)
			{
				continue;
			}
			for (int k = 0; k < 4; k++)
			{
				if (k == i || k == j)
				{
					continue;
				}
				for (int l = 0; l < 4; l++)
				{
					if (l == i || l == j || l == k)
					{
						continue;
					}
					ZuHe[Hang][0] = a[i];
					ZuHe[Hang][1] = a[j];
					ZuHe[Hang][2] = a[k];
					ZuHe[Hang][3] = a[l];
					Hang++;
				}
			}
		}
	}
	
}

double FourFu(double a, double b, char s)		//四种运算符
{
	double result;
	switch (s)
	{
	case'+':
		result = a + b;
		break;
	case'-':
		result = a - b;
		break;
	case'*':
		result = a * b;
		break;
	case'/':
		if (b != 0)
		{
			result = a / b;
		}
		else
		{
			return -1;
		}
		break;
	default:
		return -1;
	}
	return result;
}

//运算先后顺序的五种情况：	1.((A#B)#C)#D	2.(A#(B#C))#D	3.A#((B#C)#D)	4.A#(B#(C#D))	5.(A#B)#(C#D)

//1.((A#B)#C)#D
bool Bool1(int A[4])
{
	char s[4] = { '+','-','*','/' };
	double result1, result2, result3;
	double KeNen[24][4];
	FourShu(A, KeNen);
	int Hang;
	for (Hang = 0; Hang < 24; Hang++)
	{
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
						result1 = FourFu(KeNen[Hang][0], KeNen[Hang][1], s[i]);
						result2 = FourFu(result1, KeNen[Hang][2], s[j]);
						result3 = FourFu(result2, KeNen[Hang][3], s[k]);
						if (abs(result3 - 24) < 0.000001)
						{
							return true;
						}
						else
						{
							continue;
						}
				}
			}
		}
	}
	return false;
}

//2.(A#(B#C))#D	
bool Bool2(int A[4])
{
	char s[4] = { '+','-','*','/' };
	double result1, result2, result3;
	double KeNen[24][4];
	FourShu(A, KeNen);
	int Hang;
	for (Hang = 0; Hang < 24; Hang++)
	{
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
					result1 = FourFu(KeNen[Hang][1], KeNen[Hang][2], s[i]);
					result2 = FourFu( KeNen[Hang][0], result1, s[j]);
					result3 = FourFu(result2, KeNen[Hang][3], s[k]);
					if (abs(result3 - 24) < 0.000001)
					{
						return true;
					}
					else
					{
						continue;
					}
				}
			}
		}
	}
	return false;
}

//3.A#((B#C)#D)	
bool Bool3(int A[4])
{
	char s[4] = { '+','-','*','/' };
	double result1, result2, result3;
	double KeNen[24][4];
	FourShu(A, KeNen);
	int Hang;
	for (Hang = 0; Hang < 24; Hang++)
	{
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
					result1 = FourFu(KeNen[Hang][1], KeNen[Hang][2], s[i]);
					result2 = FourFu(result1, KeNen[Hang][3], s[j]);
					result3 = FourFu(KeNen[Hang][0], result2, s[k]);
					if (abs(result3 - 24) < 0.000001)
					{
						return true;
					}
					else
					{
						continue;
					}
				}
			}
		}
	}
	return false;
}

//4.A#(B#(C#D))	
bool Bool4(int A[4])
{
	char s[4] = { '+','-','*','/' };
	double result1, result2, result3;
	double KeNen[24][4];
	FourShu(A, KeNen);
	int Hang;
	for (Hang = 0; Hang < 24; Hang++)
	{
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
					result1 = FourFu(KeNen[Hang][2], KeNen[Hang][3], s[i]);
					result2 = FourFu(KeNen[Hang][1], result1, s[j]);
					result3 = FourFu(KeNen[Hang][0], result2, s[k]);
					if (abs(result3 - 24) < 0.000001)
					{
						return true;
					}
					else
					{
						continue;
					}
				}
			}
		}
	}
	return false;
}

//5.(A#B)#(C#D)
bool Bool5(int A[4])
{
	char s[4] = { '+','-','*','/' };
	double result1, result2, result3;
	double KeNen[24][4];
	FourShu(A, KeNen);
	int Hang;
	for (Hang = 0; Hang < 24; Hang++)
	{
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
					result1 = FourFu(KeNen[Hang][0], KeNen[Hang][1], s[i]);
					result2 = FourFu(KeNen[Hang][2], KeNen[Hang][3], s[i]);
					result3 = FourFu(result1, result2, s[i]);
					if (abs(result3 - 24) < 0.000001)
					{
						return true;
					}
					else
					{
						continue;
					}
				}
			}
		}
	}
	return false;
}

int main()
{
	int a[100][4];
	int count = 0;
	int Hang = 0;

	while (true)
	{
		count = 0;
		for (int i = 0; i < 4; i++)
		{
			cin >> a[Hang][i];
			if (a[Hang][i] == 0)
			{
				count++;
			}
		}
		Hang++;
		if (count == 4)
		{
			break;
		}
	}
	for (int i = 0; i < Hang-1; i++)
	{
		if (Bool1(a[i]) || Bool2(a[i]) || Bool3(a[i]) || Bool4(a[i]) || Bool5(a[i]))
		{
			cout << "YES" << endl;
		}
		else
		{
			cout << "NO" << endl;
		}
	}
	return 0;
}