#1304 : 搜索一·24点

#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小时前

查看