Hi~亲，欢迎来到题谷网,新用户注册7天内每天完成登录送积分一个，7天后赠积分33个，购买课程服务可抵相同金额现金哦~
意见详细错误描述：
教师讲解错误
错误详细描述：
当前位置：>>>
有一个“24点”的游戏，其规则是：在1至9这9个数中任取4个数(每个数只能取一次)进行加减乘除混合运算，使其结果等于24．例如：取1，2，3，4，则有(1＋2＋3)×4＝24，现有4个数3，4，－6，10，运用上述规则，写出两种不同的算式，使其结果等于24．(可以打乱顺序)
下面这道题和您要找的题目解题方法是一样的，请您观看下面的题目视频
有一种“24点”的游戏，其规则是：任取4个数，将这4个数（每个数只能用一次）进行加、减、乘、除混合运算，使其结果为24.例如：1，2，3，4，做运算：（1十2＋3）×4＝24.现有4个有理数：4，1，－3，7，运用上述规则写出一条算式，使其结果等于24：________________________．
主讲：李宇歌
给视频打分
招商电话：010-
地址：北京市西城区新街口外大街28号A座4层409
扫一扫有惊喜！
COPYRIGHT (C)
INC. ALL RIGHTS RESERVED. 题谷教育 版权所有
京ICP备号 京公网安备应届面经（10）
#include&cstdio&
#include&iostream&
#include &cmath&
unsigned long int xx[1001];
int f1(int a, int b, int c, int d)
char s1,s2,s3;
for (int j = 1; j &= 4; j++)
for (int k = 1; k &= 4; k++)
for (int l = 1; l &= 4; l++)
switch (j)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%b)
sum = 9999;
switch (k)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%c)
sum = 9999;
switch (l)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%d)
sum = 9999;
switch (j)
case 1:s1='+';
case 2:s1='-';
case 3:s1='*';
case 4:s1='/';
switch (k)
case 1:s2='+';
case 2:s2='-';
case 3:s2='*';
case 4:s2='/';
switch (l)
case 1:s3='+';
case 2:s3='-';
case 3:s3='*';
case 4:s3='/';
if (sum == 24)
xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
printf(&((%d%c%d)%c%d)%c%d==24\n&,a,s1,b,s2,c,s3,d);
for (int i=1;i&=x;i++)
if ((a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l)==xx[i])
if (pd==0)
xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
printf(&((%d%c%d)%c%d)%c%d==24\n&,a,s1,b,s2,c,s3,d);
int f2(int a, int b, int c, int d)
int sum = 0;
sum = f1(a, b, c, d) + f1(a, b, d, c) + f1(a, c, b, d) + f1(a, c, d, b) + f1(a, d, b, c) + f1(a, d, c, b);
if (sum != 0)
int main()
int a, b, c,
cin && a && b && c &&
sum = f2(a, b, c, d) + f2(b, a, c, d) + f2(c, a, b, d) + f2(d, a, b, c);
if (sum == 0)
cout && 'N' &&
bool RecursiveCalc(double *pArray, int nCount)
bool bRet =
if (1 == nCount)
if (fabs(pArray[0] - 24.0) & 0.0001)
g_Total++;
Output(pArray[0]);
for (int i = 0; i & nC i++)
for (int j = 0; j & nC j++)
if (j == i)
double f1 = pArray[i];
double f2 = pArray[j];
char *p = g_
for (int nop = 1; nop &= 4; nop++, p++)
if ('/' == *p && fabs(f2) & 0.0001)
double f = Operation(f1, f2, *p);
double *pnew = new double[nCount-1];
if (!pnew)
for (int m = 1, n = 0; m & nCount-1; m++)
while (n == i || n == j)
pnew[m] = pArray[n++];
bRet |= RecursiveCalc(pnew, nCount-1);
g_n1 -= 2;
if (g_bOnlyGetOne && bRet)
递归方式的次数分析
在不考虑加法和乘法的交换律的情况下，对于给定的4个数字的递归算法有以下排列：
4个数中取2个数的排列 &12种 *4种运算符 = 48种
3个数中取2个数的排列 &6种 &*4种运算符 = 24种
2个数中取2个数的排列 &2种 &*4种运算符 = 8种
所以共有48*24*8种 = 9216种情况
【思路三】
后缀表达式方法
后缀表达式又称为逆波兰表达式，是一种把运算符放在要运算的两个数值后面的一种表示方法，后缀表达式的好处是可以不用括号。
例如对于（1-2）/(3-4)这样的表达式，后缀表示法为：12-34-/，在解释后缀表达式时，我们从左到右扫描，遇到运算符就往运算符的左边取最近的两个数值进行运算，运算结束后将这个运算符和对应的两个运算数替换为运算结果，然后重复这个过程，直到算出最终结果。
例如对于3 ,6 5 - 8 + * 这个表达式，我们可以这样计算：
遇到数字先不管，遇到第一个符号是减号，往前找两个数，是6和5，所以就是6-5，结果=1。用1替换掉6 5 - 得到新的表达式：
3 1 8 + * 接下来是加号，1+8 = 9，表达式变为：3 9 *
最后的结果就是3*9 = 27。
而原来的表达式转换为我们平时看到的中缀表示法就是：3*（6-5+8），可以看出后缀表达式避免了括号。
关于这种表达式的更详细说明，读者可以搜索相关介绍。
将后缀表达式看成栈操作是很多教科书和文章中都提到的一种理解方式，其中向栈中加入数值时不进行任何处理，向栈中加入运算符则取栈顶的2个操作数和运算符进行运算，运算结果再放回栈中，所以每加入一个运算符，相当于栈中数值的数量会减少1，这一点从上面的图中也能看出来，每经过一个运算符，后面括号中的数值都比父节点小1。而每加入一个数值，后面括号中的数值都比父节点多1。
void SetNextSortPermutation(int *pIdx, int nLen)//调整到有序全排列的下一个排列
int nCurIdx = nLen-1;
int nFindIdx = nCurI
while (nCurIdx-1 &= 0 && pIdx[nCurIdx-1] & pIdx[nCurIdx])
nCurIdx--;
if (nCurIdx-1 & 0)
while (pIdx[nFindIdx] & pIdx[nCurIdx-1])
nFindIdx--;
int tmp = pIdx[nCurIdx-1];
pIdx[nCurIdx-1] = pIdx[nFindIdx];
pIdx[nFindIdx] =
for (int i = nCurIdx, j = nLen-1; i & i++, j--)
tmp = pIdx[i];
pIdx[i] = pIdx[j];
调整到运算符的下一个排列的算法类似四则运算中的进位处理，我们定义运算符的顺序是+-*/。则+++的下一个排列是++-，只需要将最后一个符号（+1）变成下一个符号，如果符号越界了，比如++/，最后一个符号是除法，加1，就需要回到加号，同时对前面的符号进行进位，在进位的过程中可能产生循环进位，所以要循环处理。++/（加加除）的下一个排列是+-+，+//（加除除）的下一个排列是-++（减加加）。对应的代码如下：
void SetNextOpComb(int *nOp, int nLen)//调整到运算符组合的下一个组合，类似运算中的进位处理
int nCurIdx = nLen-1;
while (nCurIdx &= 0 && 4 == ++nOp[nCurIdx])
nOp[nCurIdx] = 0;
nCurIdx--;
具体的模拟栈操作中，我定义了一个结点结构表示数值或者符号：
struct Node
在实际的代码中使用list，只操作list的尾部来模拟栈。代码如下：
bool CalcStack(Node *node_all, int nLen)
std::list&Node&
char output[200] = {0};
char tmp[30] = {0};
for (int i = 0; i & nL i++)
if (0 == node_all[i].nType)
lst.push_back(node_all[i]);
sprintf_s(tmp, 30, &%2d &, (int)node_all[i].d);
strcat_s(output, 200, tmp);
else if(1 == node_all[i].nType)
sprintf_s(tmp, 30, &%c &, g_op[node_all[i].op]);
strcat_s(output, 200, tmp);
Node f2 = lst.back();
lst.pop_back();
Node f1 = lst.back();
lst.pop_back();
if (abs(f2.d) & 0.0001 && 3 == node_all[i].op)
node.nType = 0;
node.d = Operation(f1.d, f2.d, g_op[node_all[i].op]);
lst.push_back(node);
assert(0);
double f = lst.back().d;
if (abs(f-24.0) & 0.0001)
g_Total++;
printf(&%s=%d\r\n&, output, (int)f);
后缀表达式方法共有5种合法的后缀表达式,假设abcd为4个数，+代表符号
第一种: abcd+++
第二种: abc+d++
第三种: ab+cd++
第四种: abc++d+
第五种: ab+c+d+
对于每种情况，4个数字的全排列=24，3个符号的可能性是4*4*4，所以每种情况有24*64=1536种
5种情况 共1536*5 = 7680 种排列
虽然从数据比较上来看，后缀表达式方式的情况比递归法的少，但由于我在代码中用到了list来模拟栈，所以实际代码运行的效率，递归法反而比后缀表达式方法更快，消耗的时间大约只有后缀表达式方法的1/10。也就是低一个数量级。
【题解小结】
相对于直接玩扑克牌软件形式的计算24点游戏，有的软件对每道题目仅提供一个答案，而不管实际的解法有多少种。而有的版本刚好相反，提供了答案的所有排列方式。这意味着，对于1、2、3、4这四个数，尽管只有1×2×3×4一种解法，而列出的答案包含4×3×2×1、2×1×4×3等多达24种！&
一方面，如果有多种计算方式，我们应该提供所有答案，而不仅是其中一个答案；另一方面，我们应该避免重复提供相同答案的不同形式。给出所有答案是比较容易的，这里我们只讨论如何避免重复提供相同答案的不同形式。比如1、1、3、8这四个数，1×1×3×8与8×3×1×1应该等效的，答案中只需提供其中一个。那么如何认定两个式子是等效的呢？
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：107607次
积分：5051
积分：5051
排名：第3726名
原创：387篇
评论：150条
(11)(46)(48)(12)(1)(24)(20)(14)(5)(8)(3)(36)(68)(68)(12)(1)(11)(10)有一种“二十四点”的游戏，其游戏规则是这样的：任取四个1至13之间的自然数，将这四个数（每个数用且只能用一次）进行加减乘除四则运算，可以使用括号，使其结果等于24．例如对1，2，3，4，可作如下运算：（1+2+3）×4=24（上述运算与4×（1+2+3）视为相同方法的运算）
现有四个有理数3，-5，7，-9，运用上述规则写出一个运算式，使其结果等于24．运算式如下：
（1）3-（-5）+7-（-9）=24；
另有四个有理数3，4，-6，10，运用上述规则写出三种不同方法的运算式，可通过运算式：
（2）10-4-3×（-6）=24；
（3）4-（-6）÷3×10=24；
（4）3×（4-6+10）=24使其结果等于24．
此题是二十四点游戏，在给定的数字之间，加任意的加减乘除符号，使其结果等于24即可．
（1）3-（-5）+7-（-9）=24；
（2）10-4-3×（-6）=24；
（3）4-（-6）÷3×10=24；
（4）3×（4-6+10）=24．用数字1,4,6,2,算24点游戏,有几种解法望告知_百度知道
用数字1,4,6,2,算24点游戏,有几种解法望告知
4,算24点游戏用数字1,2,6
三种：4×6×(2－1)＝244×6÷(2－1)＝24(6＋2)×(4－1)＝24
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁