#1304 : 搜索一·24点

Posted 2022-11-01 计算机科学家的世界

#1304 : 搜索一·24点

时间限制: 10000ms 单点时限: 1000ms 内存限制: 256MB

描述

周末，小Hi和小Ho都在家待着。

在收拾完房间时，小Ho偶然发现了一副扑克，于是两人考虑用这副扑克来打发时间。

小Ho：玩点什么好呢？

小Hi：两个人啊，不如来玩24点怎么样，不靠运气就靠实力的游戏。

小Ho：好啊，好啊。

<经过若干局游戏之后>

小Ho：小Hi，你说如果要写个程序来玩24点会不会很复杂啊？

小Hi：让我想想。

<过了几分钟>

小Hi：我知道了！其实很简单嘛。

提示：24点

输入

第1行：1个正整数, t，表示数据组数，2≤t≤100。

第2..t+1行：4个正整数, a,b,c,d，1≤a,b,c,d≤10。

输出

第1..t行：每行一个字符串，第i行表示第i组能否计算出24点。若能够输出"Yes"，否则输出"No"。

样例输入

2
5 5 5 1
9 9 9 9

样例输出

Yes
No

算法：

最简单的是暴力枚举，每次枚举两个数的操作，将剩下的数减少两个，当只剩下一个数时，判断是否是24即可。

代码：

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

int gcd(int a, int b);
int lcd(int a, int b);

class Fraction 
public:
	Fraction(const int _a, const int _b) 
		a = _a, b = _b;
	

	Fraction(const int _a) 
		a = _a;
		b = 1;
	
public:
	friend Fraction operator * (const Fraction &l, const Fraction &r) 
		if (l.Zero() || r.Zero()) 
			return Fraction(0, 1);
		
		Fraction c(l.a * r.a, l.b * r.b);
		return c.Simplity();
	

	friend Fraction operator - (const Fraction &l, const Fraction &r) 
		Fraction c(l.a * r.b - l.b * r.a, l.b * r.b);
		return c.Simplity();
	

	friend Fraction operator + (const Fraction &l, const Fraction &r) 
		Fraction c(l.a * r.b + l.b * r.a, l.b * r.b);
		return c.Simplity();
	

	friend Fraction operator / (const Fraction &l, const Fraction &r) 
		Fraction c(l.a * r.b, l.b * r.a);
		return c.Simplity();
	

	friend bool operator == (const Fraction &l, const Fraction &r) 
		return l.a * r.b == l.b * r.a;
	

public:
	bool Zero() const
		return a == 0;
	

	Fraction& Simplity() 
		int c = gcd(a, b);
		a /= c;
		b /= c;
		return *this;
	

public:
	int a, b; // a / b
;

int gcd(int a, int b) 
	return !b ? a :gcd(b, a % b);


bool DFS(const vector<Fraction>& fs);


void HandleCase();

int main() 
	int iCase;
	cin >> iCase;
	while (iCase--) 
		HandleCase();
	



void HandleCase() 
	vector<Fraction> v;
	int f;
	for (int i = 0; i < 4; ++i) 
		cin >> f;
		v.push_back(f);
	
	if (DFS(v)) 
		cout << "Yes" << endl;
	 else 
		cout << "No" << endl;
	




int lcd(int a, int b) 
	return a * b / gcd(a, b);


bool DFS(const vector<Fraction>& fs) 
	if (fs.size() == 1) 
		return fs[0] == 24;
	
	vector<Fraction> v;
	for (int i = 0; i < fs.size(); ++i) 
		for (int j = 0; j < fs.size(); ++j) 
			if (i == j) 
				continue;
			
			v.clear();
			for (int k = 0; k < fs.size(); ++k) 
				if (k == i || k == j) 
					continue;
				
				v.push_back(fs[k]);
			
			//+
				v.push_back(fs[i] + fs[j]);
				if (DFS(v)) 
					return true;
				
				v.pop_back();
			

			//-
				v.push_back(fs[i] - fs[j]);
				if (DFS(v)) 
					return true;
				
				v.pop_back();
			

			//*
				v.push_back(fs[i] * fs[j]);
				if (DFS(v)) 
					return true;
				
				v.pop_back();
			

			// /
				if(!fs[j].Zero())
					v.push_back(fs[i] / fs[j]);
					if (DFS(v)) 
						return true;
					
					v.pop_back();
				
			
		
	

	return false;

结果：

1304

搜索一·24点

AC

G++

61ms

0MB

4小时前

查看