试题 算法训练 24点

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　24点游戏是一个非常有意思的游戏，很流行，玩法很简单：给你4张牌，每张牌上有数字（其中A代表1，J代表11，Q代表12，K代表13），你可以利用数学中的加、减、乘、除以及括号想办法得到24，例如：
　　((A*K)-J)*Q等价于((1*13)-11)*12=24
　　加减乘不用多说了，但除法必须满足能整除才能除！这样有一些是得不到24点的，所以这里只要求求出不超过24的最大值。

输入格式

　　输入第一行N(1<=N<=5)表示有N组测试数据。每组测试数据输入4行，每行一个整数(1到13)表示牌值。

输出格式

　　每组测试数据输出一个整数，表示所能得到的最大的不超过24的值。

样例输入

3
3
3
3
3
1
1
1
1
12
5
13
1

样例输出

24
4
21

这个题目最多n是5，直接暴力

解题思想就是dfs+暴力

#include<iostream>
#include<vector>
#include<string>
#include<math.h>
//#include<fstream>
//#include<unordered_map>
//#include<stack>
//#include<queue>
#include<iomanip>
#include<algorithm>
//#include<bitset>
//#include<map>
using namespace std;
vector<int> ans;//用于储存
bool flag_nums[4]{ true,true,true,true };//标记是否用过
//bool flag_op[4] = { true };
void dfs(int a, int b, int c, int d,int num,int ret) {
	//终止条件
	if (num == 4) {
		ans.push_back(ret);
		return;
	}
	//如果单纯的dfs下去无法处理（##）（##）
	//所以改进，对这种情况进行单独处理
	if (num == 2) {
		int temp1, temp2;
		int i;
		//找到两个为运算的数字
		for (i = 0; i < 4; i++)
			if (flag_nums[i]) {
				switch (i) {
				case 0:
					temp1 = a;
					break;
				case 1:
					temp1 = b;
					break;
				case 2:
					temp1 = c;
					break;
				case 3:
					temp1 = d;
					break;

				}
				break;
			}
		for (i++; i < 4; i++) {
			if (flag_nums[i]) {
				switch (i) {
				case 0:
					temp2 = a;
					break;
				case 1:
					temp2 = b;
					break;
				case 2:
					temp2 = c;
					break;
				case 3:
					temp2 = d;
					break;

				}
			}
		}
		dfs(a, b, c, d, 4, ret * abs(temp1-temp2));
		dfs(a, b, c, d, 4, ret * (temp1+temp2));
		dfs(a, b, c, d, 4, ret + (temp1 * temp2));
		dfs(a, b, c, d, 4, ret - (temp1 * temp2));
		if (temp1 % temp2 == 0) {
			dfs(a, b, c, d, 4, ret - (temp1 / temp2));
			dfs(a, b, c, d, 4, ret + (temp1 / temp2));
		}
		if (temp2 % temp1 == 0)
		{
			dfs(a, b, c, d, 4, ret + (temp2 / temp1));
			dfs(a, b, c, d, 4, ret - (temp2 / temp1));

		}
		if (abs(temp1 - temp2)!=0&&ret % abs(temp1 - temp2) == 0)
			dfs(a, b, c, d, 4, ret/abs(temp1 - temp2));
		if (ret % (temp1 + temp2) == 0)
			dfs(a, b, c, d, 4, ret/(temp1 + temp2));
		if (ret != 0 && abs(temp1 - temp2) % ret == 0)
			dfs(a, b, c, d, 4, abs(temp1 - temp2) / ret);
		if (ret != 0 && (temp1 + temp2) % ret == 0)
			dfs(a, b, c, d, 4, (temp1 + temp2) / ret);

	}
	
	for (int i = 0; i < 4; i++) {
		if (flag_nums[i]) {
			flag_nums[i] = false;
			switch (i) {
			case 0:
				dfs(a, b, c, d, num + 1, ret * a);
				dfs(a, b, c, d, num + 1, ret - a);
				dfs(a, b, c, d, num + 1, ret + a);
				if(ret%a==0)
					dfs(a, b, c, d, num + 1, ret / a);
				if(ret!=0&&a%ret==0)
					dfs(a, b, c, d, num + 1, a / ret);// /号单独考虑，不满足交换
				break;
			case 1:
				dfs(a, b, c, d, num + 1, ret * b);
				dfs(a, b, c, d, num + 1, ret - b);
				dfs(a, b, c, d, num + 1, ret + b);
				if (ret % b == 0)
					dfs(a, b, c, d, num + 1, ret / b);
				if (ret != 0 && b % ret == 0)
					dfs(a, b, c, d, num + 1, b / ret);
				break;
			case 2:
				dfs(a, b, c, d, num + 1, ret * c);
				dfs(a, b, c, d, num + 1, ret - c);
				dfs(a, b, c, d, num + 1, ret + c);
				if (ret % c == 0)
					dfs(a, b, c, d, num + 1, ret / c);
				if (ret != 0 && c % ret == 0)
					dfs(a, b, c, d, num + 1, c / ret);
				break;
			case 3:
				dfs(a, b, c, d, num + 1, ret * d);
				dfs(a, b, c, d, num + 1, ret - d);
				dfs(a, b, c, d, num + 1, ret + d);
				if (ret % d == 0)
					dfs(a, b, c, d, num + 1, ret / d);
				if (ret != 0 && d % ret == 0)
					dfs(a, b, c, d, num + 1, d / ret);
				break;
			}
			flag_nums[i] = true;
		}
	}
}
int main() {
	int n;
	cin >> n;
	/*for (auto& t : flag_nums)
		cout << t;*/
	while (n--) {
		ans.clear();//清空
		int a, b, c, d;
		cin >> a >> b >> c >> d;
		//这里如果用vector储存的话
		//代码量会少很多，如果有兴趣可以自己改一下
		flag_nums[0] = false;
		dfs(a, b, c, d, 1, a);
		flag_nums[0] = true;
		flag_nums[1] = false;

		dfs(a, b, c, d, 1, b);
		flag_nums[1] = true;
		flag_nums[2] = false;
		dfs(a, b, c, d, 1, c);
		flag_nums[2] = true;
		flag_nums[3] = false;

		dfs(a, b, c, d, 1, d);
		flag_nums[3] = true;
		int an=-1;
		for (int i = 0; i < ans.size(); i++) {
			if (ans[i] <= 24) {
				an = max(an, ans[i]);
			}
		}
		//cout << ans.size() << endl;
		cout << an << endl;
	}
	return 0;
}