一个算法的问题!我觉得很难!看哪位大侠能作出来!

Question

我认为没必要用穷举法把所有可能都计算出来
您的要的结果是谁快谁就胜利（我理解的意思）
个人观点(仅供参考)：
               您只要判断在同一时刻抽出的4×n（n>=2），n个人从抽出扑克牌到提交结果所用的时间，不就ok了（大概思路）

Answer 1

回复人： 007remember(绿原) 
可能您还没弄明白我的意思!我可能也没说清楚!
当然有可能抽出4张牌是1,1,1,1怎么弄也弄不到24
所以,我要找出52张牌所有抽出4张牌能得到24的组合!是这个意思!

Answer 2

可以在1秒种之内解决任何计算24的问题. 当然想算25, 26... 
也是可以的.
#include "stdafx.h" 
// 
//原理, 将4个数字和3个运算符按"波兰表达式"组成一个序列, 
// 计算该序列的值是否为所求目标. 可以对这个序列的组成 
// 进行遍历, 以确定是否有解. 
//根据我的计算如果只限于用1-10之间的数字计算24, 总共有 
// 715个不同的题目, 其中566个有解. 如果是1-13, 则有 
// 1820个不同的题目, 其中1362个有解 
// 
int total = 0; //解的个数 
int sp; //当前表达式栈指针 
int s[7]; //表达式栈 
void Evaluate(int& fz, int& fm) 
//计算表达式的值, fz, fm为计算结果的分子, 分母 
{ 
int op, l, m, opn[4]; 
op = s[sp]; //取栈顶元素 
for (l = 0; l < 4; l += 2) 
{ 
if ((m = s[++sp]) > 0) //是数字 
{ 
opn[l] = m; 
opn[l + 1] = 1; 
} 
else //是运算符 
Evaluate(opn[l], opn[l + 1]); 
} 
//根据运算符进行计算 
//opn[0]/opn[1] 是第一个操作数, 
//opn[2]/opn[3] 是第二个操作数, 
switch (op) 
{ 
case -4: //乘法 
fz = opn[0] * opn[2]; 
fm = opn[1] * opn[3]; 
break; 
case -3: //加法 
fz = opn[0] * opn[3] + opn[1] * opn[2]; 
fm = opn[1] * opn[3]; 
break; 
case -2: //减法 
fz = opn[0] * opn[3] - opn[1] * opn[2]; 
fm = opn[1] * opn[3]; 
break; 
case -1: //除法 
fz = opn[0] * opn[3]; 
fm = opn[1] * opn[2]; 
break; 
} 
} 
void Display(CString& m) 
//将表达式转换为字符串 
{ 
int i; 
CString n; 
CString n; 
m = ""; 
for (i = 0; i < 7; i++) 
{ 
switch (s[i]) 
{ 
case -4: m += " *"; break; 
case -3: m += " +"; break; 
case -2: m += " -"; break; 
case -1: m += " /"; break; 
default: n.Format("%3d", s[i]); m += n; break; 
} 
} 
} 
void Compute(int target, int a, int b, int c, int d, CStringArray& ma) 
// target - 计算结果(一般为24) 
// a, b, c, d - 参加计算的4个数 
// ma - 解的字符串表达形式 
{ 
int l1, l2, l3, op1, op2, op3; 
int l, fz, fm, num[4]; 
CString m; 
//记录表达式中间四个元素的排列方式 
// 其中loc[i][0], loc[i][1]表示第二, 第三两个运算符的位置 
// loc[i][2], loc[i][3]表示第一, 第二两个操作数的位置 
int loc[5][4] = {{1, 2, 3, 4}, {1, 3, 2, 4}, {1, 4, 2, 3}, 
{2, 3, 1, 4}, {2, 4, 1, 3}}; 
//num中记录a, b, c, d的一个排列 
for (l1 = 0; l1 < 4; l1++) 
{ 
num[l1] = a; 
for (l2 = 0; l2 < 4; l2++) 
{ 
if (l2 == l1) continue; 
num[l2] = b; 
for (l3 = 0; l3 < 4; l3++) 
{ 
if (l3 == l1 || l3 == l2) continue; 
num[l3] = c; 
num[6 - l1 - l2 - l3] = d; 
//表达式最后两个必须是数字 
s[5] = num[2]; 
s[6] = num[3]; 
for (l = 0; l < 5; l++) 
{ 
s[loc[l][2]] = num[0]; 
s[loc[l][3]] = num[1]; 
for (op1 = -4; op1 < 0; op1++) 
{ 
//表达式第一个必须运算符 
s[0] = op1; 
for (op2 = -4; op2 < 0; op2++) 
{ 
s[loc[l][0]] = op2; 
for (op3 = -4; op3 < 0; op3++) 
{ 
s[loc[l][1]] = op3; 
sp = 0; 
Evaluate(fz, fm); 
//分母不为0, 可以整除, 商为24表示计算成功 
if (fm != 0 && fz % fm == 0 && fz / fm == target) 
{ 
Display(m); 
ma.Add(m); 
total++; 
//这里加return就是只求一个解, 
//否则是求出全部解(没有考虑剔除重复解) 
return; 
} 
} 
} 
} 
} 
} 
} 
} 
} 
不是我写的，希望对你有帮助……