C++递归实现24点游戏

题目：给出4个1~13的数字，求出是否可以根据加减乘除得到24点

代码：

#include 

#include 
using namespace std;

/*创建算法模板*/
int cal_msk_4[6][4] = { 1, 1, 0, 0,
						1, 0, 1, 0,
						1, 0, 0, 1,
						0, 1, 1, 0,
						0, 1, 0, 1,
						0, 0, 1, 1};

int cal_msk_3[3][3] = { 1, 1, 0,
						1, 0, 1,
						0, 1, 1};

int cal_msk_2[1][2] = {1,1};

/*递归判断是否可以计算24点*/
bool check24Points(vector inputValue)
{
	/*递归出口条件，当仅剩最后一个数，且为24时，则OK*/
	if (inputValue.size() == 1)
	{
		if (inputValue[0] == 24)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	/*nextValue为下次递归的输入*/
	vector nextValue;
	/*calValue为当前递归需要计算的两个数*/
	int calValue[2];
	/*cal_msk根据当前inputValue个数获取模板*/
	int* cal_msk;

	/*获取组合个数和模板*/
	unsigned int combineSum;
	switch (inputValue.size())
	{
	case 4:
		combineSum = 6;
		cal_msk = &cal_msk_4[0][0];
		break;
	case 3:
		combineSum = 3;
		cal_msk = &cal_msk_3[0][0];
		break;
	case 2:
		combineSum = 1;
		cal_msk = &cal_msk_2[0][0];
		break;
	default:
		combineSum = 0;
		break;
	}

	
	for (unsigned int i = 0; i < combineSum; i++)
	{
		/*首先获取当前组合的nextValue和calValue*/
		nextValue.clear();
		calValue[0] = 0;calValue[1] = 0;
		unsigned int index = 0;
		for (unsigned int j = 0; j < inputValue.size(); j++)
		{
			if (cal_msk[i * inputValue.size() + j] == 0)
			{
				nextValue.push_back(inputValue[j]);
			}
			else
			{
				calValue[index] = inputValue[j];
				index++;
			}
		}

		/*根据calValue的计算方式进行下一次递归*/
		int result = 0;
		/*1.两数相加*/
		result = calValue[0] + calValue[1];
		nextValue.push_back(result);
		if (check24Points(nextValue))
		{
			//cout << calValue[0] << " + " << calValue[1] << endl;
			return true;
		}
		nextValue.pop_back();

		/*2.两数相减*/
		result = calValue[0] - calValue[1];
		nextValue.push_back(result);
		if (check24Points(nextValue))
		{
			//cout << calValue[0] << " - " << calValue[1] << endl;
			return true;
		}
		nextValue.pop_back();
		result = calValue[1] - calValue[0];
		nextValue.push_back(result);
		if (check24Points(nextValue))
		{
			//cout << calValue[1] << " - " << calValue[0] << endl;
			return true;
		}
		nextValue.pop_back();

		/*3.两数相乘*/
		result = calValue[0] * calValue[1];
		nextValue.push_back(result);
		if (check24Points(nextValue))
		{
			//cout << calValue[0] << " * " << calValue[1] << endl;
			return true;
		}
		nextValue.pop_back();

		/*4.两数相除*/
		if ((calValue[1]!= 0) && ((calValue[0]%calValue[1]) == 0))
		{
			result = calValue[0] / calValue[1];
			nextValue.push_back(result);
			if (check24Points(nextValue))
			{
				//cout << calValue[0] << " / " << calValue[1] << endl;
				return true;
			}
			nextValue.pop_back();
		}
		if ((calValue[0]!=0) && ((calValue[1]%calValue[0]) == 0))
		{
			result = calValue[1] / calValue[0];
			nextValue.push_back(result);
			if (check24Points(nextValue))
			{
				//cout << calValue[1] << " / " << calValue[0] << endl;
				return true;
			}
			nextValue.pop_back();
		}

	}

	/*遍历所有情况，无法计算24点*/
	return false;
}

bool Game24Points(int a, int b, int c, int d)
{
	//cout << endl;
	//TODO: Add codes here ...
	vector inputValue;
	inputValue.push_back(a);
	inputValue.push_back(b);
	inputValue.push_back(c);
	inputValue.push_back(d);

	return check24Points(inputValue);
}