测试结果1: 通过本测试点|有效耗时94ms

测试结果2: 通过本测试点|有效耗时47ms

测试结果3: 通过本测试点|有效耗时953ms

测试结果4: 通过本测试点|有效耗时219ms

测试结果5: 通过本测试点|有效耗时172ms

测试结果6: 通过本测试点|有效耗时421ms

测试结果7: 通过本测试点|有效耗时94ms

测试结果8: 通过本测试点|有效耗时297ms

测试结果9: 通过本测试点|有效耗时406ms

测试结果10: 通过本测试点|有效耗时625ms

普通BFS

测试结果1: 通过本测试点|有效耗时47ms

测试结果2: 通过本测试点|有效耗时46ms

测试结果3: 通过本测试点|有效耗时188ms

测试结果4: 通过本测试点|有效耗时94ms

测试结果5: 通过本测试点|有效耗时93ms

测试结果6: 通过本测试点|有效耗时125ms

测试结果7: 通过本测试点|有效耗时94ms

测试结果8: 通过本测试点|有效耗时110ms

测试结果9: 通过本测试点|有效耗时109ms

测试结果10: 通过本测试点|有效耗时141ms

双 bfs 单步操作量太大，而这里数据量很小，自然显得慢。

这道题我用的是 类似于《能量项链》的手法；

#include<stdio.h>

#include<stdlib.h>

int c[5];

float t[5][5][60000];//,sub[5][5][30000];

int main()

{

freopen("out.txt","w",stdout);

int i,j,a,b,k,last,d;

float temp;

for(j=1;j<=4;j++)

{

scanf("%c",&i);

getchar();

t[1][j+1][1]=(float)i;

t[1][j][0]=1;

if(t[1][j+1][1]<'A'||t[1][j+1][1]>'Z')

{

t[1][j+1][1]-='0';

}

else

switch(c[i])

{

case 'A':t[1][j+1][1]=1;break;

case 'J':t[1][j+1][1]=11;break;

case 'Q':t[1][j+1][1]=12;break;

case 'K':t[1][j+1][1]=13;break;

}

}

for(j=2;j<=4;j++)

{

for(k=1;k<=5-j;k++)

{

last=0;

for(d=j-1;d>0;d--)

{

for(a=1;a<=t[d][k][0];a++)

{

for(b=1;b<=t[j-d][d+k][0];b++)

{

temp=t[d][k][a]+t[j-d][k+d][b];

t[j][k][++last]=temp;

temp=t[d][k][a]-t[j-d][k+d][b];

t[j][k][++last]=temp;

temp=t[d][k][a]*t[j-d][k+d][b];

t[j][k][++last]=temp;

temp=t[d][k][a]/t[j-d][k+d][b];

t[j][k][++last]=temp;

temp=t[j-d][k+d][b]/t[d][k][a];

t[j][k][++last]=temp;

temp=t[j-d][k+d][b]-t[d][k][a];

t[j][k][++last]=temp;

}

}

}

t[j][k][0]=last;

}

}

for(j=1;j<=t[4][1][0];j++)

{

if(t[4][1][j]<=24.1 && t[4][1][j]>23.9)

{

printf("yes");

return 0;

}

}

printf("no");

//system("pause");

return 0;

}