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

查看