hiho一下 第九十八周 #1304 : 搜索一·24点 【此方法好巧妙呀---用来求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点

小Hi：小Ho，你仔细观察我们计算24点的方法，来总结有几种情况。
假设我们用⊙表示运算，⊙除了可以表示基本的"+","-","*","/"外。我们还引入两个新的运算，"反-",和"反/"。
比如(a 反/ b)的意思是(b / a)。则对形如(c / (a + b))的形式，就可以等价的描述为((a + b) 反/ c)。
利用这6种运算，可以将所有可能的计算过程归结为2类：

(((a ⊙ b) ⊙ c ) ⊙ d)
((a ⊙ b) ⊙ (c ⊙ d))

小Ho：恩..(小Ho思考了一下)..好像确实是这样。
小Hi：既然我们已经找到了固定的模式，那么剩下的就比较简单了。
将4张牌的值，分别代入a,b,c,d，再把可能的运算符也代入。就可以得到相应的计算式子，将其计算出来，再检查结果是否等于24。
那么小Ho，你觉得有多少种情况呢？
小Ho：由于我们有4个数，所以对于a,b,c,d的对应关系有4!=24种情况。3个运算符，每个运算符可能有6种情况，那就是6^3=216。再考虑到2种不同的模式，所以一共有2 * 24 * 216 = 10368种情况。
小Hi：你的计算中并没有考虑等价的情况，比如a + b 和 b + a，所以实际的情况数其实是小于10368种的。
不过由于对计算机而言，10368种情况数本来也不是很多，而要考虑等价反而显得比较麻烦。所以我们可以不要去考虑加法和乘法的可逆性，直接枚举所有的情况。
那么最后还是由小Ho你来给出参考的伪代码吧。
小Ho：嗯，这次的伪代码：

used[] = false
nowNumber[] = {0,0,0,0}
ops[] = {0,0,0}
opType = {+,-,*,/,反-,反/}

makeNumber(depth):
If (depth >= 4) Then
// 此时已经枚举完a,b,c,d
// 开始枚举运算符
Return makeOperation(0)
End If
For i = 1 .. 4
If (not used[i]) Then	// 每个数字只能使用一次
nowNumber[ depth ] = number[i]
used[i] = true
If (makeNumber(depth + 1)) Then
Return True
End If
used[i] = false
End If
End For
Return False

makeOperation(depth):
If (depth >= 3) Then
// 此时已经枚举完a,b,c,d和三个运算符
// 计算在(((a ⊙ b) ⊙ c ) ⊙ d)形式下的值
If (calcType1(nowNumber, ops) == 24) Then
Return true;
End If
// 计算在((a ⊙ b) ⊙ (c ⊙ d))形式下的值
If (calcType2(nowNumber, ops) == 24) Then
Return true;
End If
Return false
End If
For i = 1 .. 6
ops[ depth ] = opType[i]
If (makeOperation(depth + 1)) Then
Return True
End If
End For
Return False

Main:
input(number)
used[] = false
makeNumber(0)

代码1：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
double a[4];
double p(double x,double y,int z)
{
switch (z)
{
case  0:
return x+y;
case  1:
return x-y;
case  2:
return x*y;
case  3:
return x/y;
case  4:
return y-x;
case  5:
return y/x;
}
}
bool pp(int i,int j,int k,int q,int w,int e,int r)
{
double x,y;
x=p(a[q],a[w],i);
x=p(x,a[e],j);
x=p(x,a[r],k);
if (x==24)
return true;
x=p(a[q],a[w],i);
y=p(a[e],a[r],k);
x=p(x,y,j);
if (x==24)
return true;
return false;
}
int main()
{
int t;scanf("%d",&t);
while (t--)
{
scanf("%lf%lf%lf%lf",&a[0],&a[1],&a[2],&a[3]);
bool fafe=false;
for (int q=0;q<4;q++)
{
for (int w=0;w<4;w++)
{
if (q==w) continue;
for (int e=0;e<4;e++)
{
if (q==e||w==e) continue;
for (int r=0;r<4;r++)
{
if (q==r||w==r||e==r) continue;
for (int i=0;i<6;i++)
{
if (fafe)
break;
for (int j=0;j<6;j++)
{
if (fafe)
break;
for (int k=0;k<6;k++)
if (pp(i,j,k,q,w,e,r))
{
fafe=true;
break;
}
}
}
}
}
}
}
printf("%s\n",fafe?"Yes":"No");
}
return 0;
}

第一个代码虽然A了，但是浮点数会存在精度问题----比如3 3 8 8-----这一组就会WA----

下面这个用分数的形式就可以保证没有精度问题了====

代码2：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[4],mu[4],zi[4];
void p(int y,int z)
{
switch (z)
{
case 0:
zi[0]+=mu[0]*y;
return ;
case 1:
zi[0]-=mu[0]*y;
return ;
case 2:
zi[0]*=y;
return ;
case 3:
mu[0]*=y;
return ;
case 4:
zi[0]=mu[0]*y-zi[0];
return ;
case 5:
int c=mu[0];
mu[0]=zi[0];
zi[0]=c;
zi[0]*=y;
return ;
}
}
void ppp(int y,int z)
{
switch (z)
{
case 0:
zi[1]+=mu[1]*y;
return ;
case 1:
zi[1]-=mu[1]*y;
return ;
case 2:
zi[1]*=y;
return ;
case 3:
mu[1]*=y;
return ;
case 4:
zi[1]=mu[1]*y-zi[1];
return ;
case 5:
int c=mu[1];
mu[1]=zi[1];
zi[1]=c;
zi[1]*=y;
return ;
}
}
void pppp(int z)
{
switch (z)
{
case 0:
zi[2]=zi[0]*mu[1]+zi[1]*mu[0];
mu[2]=mu[0]*mu[1];
return ;
case 1:
zi[2]=zi[0]*mu[1]-zi[1]*mu[0];
mu[2]=mu[0]*mu[1];
return ;
case 2:
zi[2]=zi[0]*zi[1];
mu[2]=mu[0]*mu[1];
return ;
case 3:
zi[2]=zi[0]*mu[1];
mu[2]=zi[1]*mu[0];
return ;
case 4:
zi[2]=zi[1]*mu[0]+zi[0]*mu[1];
mu[2]=mu[0]*mu[1];
return ;
case 5:
zi[2]=zi[1]*mu[0];
mu[2]=zi[0]*mu[1];
return ;
}
}
bool pp(int i,int j,int k,int q,int w,int e,int r)
{
mu[0]=1;zi[0]=a[q];
p(a[w],i);
p(a[e],j);
p(a[r],k);
if (mu[0]*24==zi[0]&&zi[0]!=0)
return true;
mu[0]=1;zi[0]=a[q];
p(a[w],i);
mu[1]=1;zi[1]=a[e];
ppp(a[r],k);
pppp(j);
if (mu[2]*24==zi[2]&&zi[2]!=0)
return true;
return false;
}
int main()
{
int t;scanf("%d",&t);
while (t--)
{
scanf("%d%d%d%d",&a[0],&a[1],&a[2],&a[3]);
bool fafe=false;
for (int q=0;q<4;q++)
{
for (int w=0;w<4;w++)
{
if (q==w) continue;
for (int e=0;e<4;e++)
{
if (q==e||w==e) continue;
for (int r=0;r<4;r++)
{
if (q==r||w==r||e==r) continue;
for (int i=0;i<6;i++)
{
if (fafe)
break;
for (int j=0;j<6;j++)
{
if (fafe)
break;
for (int k=0;k<6;k++)
if (pp(i,j,k,q,w,e,r))
{
// printf("%d %d %d %d %d %d %d\n",i,j,k,q,w,e,r);/*可以输出式子*/
fafe=true;
break;
}
}
}
}
}
}
}
printf("%s\n",fafe?"Yes":"No");
}
return 0;
}