Ⅰ C语言24点的算法
下面是我自己写的一个程序:
我的解法是把这个问题分解成了两个子问题，首先求出4个数字的无重复全排列，放到一个数组里面，再对没一个排列情况，从头到尾穷举所有的四则运算情况。注意到除法是特殊的，我用x/y表示x除以y，用x|y表示x分之y。注意到，如果穷举的解得到-24的话，只需要把有减法的地方调换一下顺序就可以了，代码如下
/***********************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
int index[4]={0,1,2,3};//used to generate subscription collection
int sub[4]; //used in p() only
float f[4]={8.0f,3.0f,3.0f,8.0f};//the 24 point numbers
float fs[24][4];//all possible permutaions of f
float tmp[4]; //used for buf
int g_number=0; //number of permutations
float RES[4];
char op[3];
void p(int idx){//求全排列的函数
if(idx==4){
for(int i=0;i<4;++i){tmp[i]=f[sub[i]];}
for(int g=0;g<g_number;++g){if(memcmp(fs[g],tmp,sizeof(float)*4)==0)return;}
for(int i=0;i<4;++i){fs[g_number][i]=f[sub[i]];}
g_number++;
return;
}
for(int i=0;i<4;++i){//make subscription collections
bool pflag=false;
for(int j=0;j<idx;++j){if(sub[j]==i)pflag=true;}
if(pflag==true)continue;
sub[idx]=index[i];
p(idx+1);
}
}
void solve(int L){//对某个排列，递归求所有四则运算的结果，找到就退出
if(L==3){
if(fabs(fabs(RES[L])-24.0f)<0.01f){
printf("Found solution,RES=%f,((%d%c%d)%c%d)%c%d\n",RES[L],
(int)f[0],op[0],
(int)f[1],op[1],
(int)f[2],op[2],
(int)f[3]);
exit(0);
}
return;
}
for(int j=0;j<5;++j){//j judges for operators
if(j==0){RES[L+1]=RES[L]+tmp[L+1];op[L]='+';solve(L+1);}
if(j==1){RES[L+1]=RES[L]-tmp[L+1];op[L]='-';solve(L+1);}
if(j==2){RES[L+1]=RES[L]*tmp[L+1];op[L]='*';solve(L+1);}
if(j==3&&tmp[L+1]!=0)
{RES[L+1]=RES[L]/tmp[L+1];op[L]='/';solve(L+1);}
if(j==4&&RES[L+1]!=0)
{RES[L+1]=tmp[L+1]/RES[L];op[L]='|';solve(L+1);}
}
}
int main(int argc,char* argv[]){//should avoid 0
f[0]=atoi(argv[1]);
f[1]=atoi(argv[2]);
f[2]=atoi(argv[3]);
f[3]=atoi(argv[4]);
p(0);
for(int i=0;i<g_number;++i){
memcpy(tmp,fs[i],sizeof(float)*4);
RES[0]=tmp[0];
for(int t=0;t<4;++t){ printf("%d,",(int)tmp[t]); }
printf("\n");
solve(0);
}
printf("Found no solution :( \n");
return 0;
}
----------编译运行，运行时的参数就是4个数字
g++ p.cpp && ./a.out 1 5 5 5
1,5,5,5,
Found solution,RES=-24.000000,((1/5)-5)*5
g++ p.cpp && ./a.out 8 3 3 8
8,3,3,8,
Found solution,RES=-24.000006,((8/3)-3)|8
上面这个解写出来就是
8
--------- = 24
3-(8/3)
主程序为了简化，省去了对输入的检查，楼主可以自己添加。
Ⅱ 求高手用c++解决二十四点的问题，具体如下
24点算法分析
很久没有研究程序了，惭愧中。。。这个夏天大致地翻了一下微软亚洲研究院出的《编程之美》，很喜欢这本书的风格，里面很多题目都很有意思。书中主要突出的是一个“巧”字，最关键的，就是从变化中寻找不变的规律。 这次说的问题其实也很简单，给四个数，写一个程序输出算24点的结果，如果没有就输出“No Answer”。但是如果用我们自己算24点的思维来写程序是不行的，因为那属于一种“凑”的方法，有碰巧和经验的成分。计算机能做的，就是通过一种固定的方式来找寻结果。如果没有一般性的所谓“固定”方式，那么只有通过遍历和穷举来解决问题。这样的方法下诞生了很多所谓的NP难问题，如果原始数据规模比较大就要花很长的时间来得到结果。
24点这个问题最直接的方法就是，列举四个数所有的排列组合，加上各种运算符以及括号，所有的情况经过处理之后可以得到一个包含所有计算结果和计算式的列表，从其中寻找24的影踪就可以了。如果不计计算结果重复的情况，最终的结果有7680种，数据量还是有点大，因此这个算法需要进一步的优化。例如，考虑到加法和乘法的交换律，如果遇到相应的情况只计算一种，对于另一种直接返回。这样的剪枝处理可以减少不少的运算。
不过我用的是书中的另一种思路，采用了划分的思想。具体的算法是：
如果A是一个数组，定义f(A)为数组中的所有数经过四则运算所能得到的结果的集合。对于A中元素个数大于1的情况，可以将A分拆成两个集合，定义运算 Fork(A,B)为f(A)和f(B)中各取一个元素的四则运算得到的所有的结果的集合。这样，如果列举出集合A所有的拆分情况，那么所有Fork结果的并集就是f(A)的结果。
对于24点的情况，因为数组A有4个数，因此将其用各种方法拆分即可得到最终的f(A)，然后查询其中是否存在元素24即可得到有解或者无解的判断。
需要说明的有几点：
1.这个问题表面上需要采用递归的算法，即如果只有一个元素那么直接返回，否则将问题转化为多个f的计算，而每个f的计算又要经过转化，层层递归，直至只有一个元素的情况。但是，不要忘了递归的方法一般都是针对回溯次数不确定的问题。例如汉诺塔问题，只有一个盘子的情况和64个盘子的情况，回溯次数截然不同，千差万别；但是对于24点，因为只有4个数，实际上分拆的可能性是固定的，就那么有限种情况。递归算法的思路是从树的根部往下遍历，而且一般不知道树的大小和规模。而对于24点问题，这棵树的大小固定，完全可以从树的叶子着手，从叶子向根步进，从而得到最终的结果。
2.分拆有一定的技巧，最合适的方法是通过位运算。比如一种分拆方法是{a1,a2},{a3,a4},那么写做1100和0011。这种方法的好处在于，比如要判断1000是不是1100的一个子集，只需要将两者做与运算，最后的结果如果还等于1100则表明确实是子集，同时分拆的另一个结果便是两者的差。这样至多只需要比较 10多次就可以列举出每个集合所有的分拆情况，比较巧妙的方法。同时，位运算的速度也很快，不会对计算的时间有较大的影响。
3.这个方法的缺点在于，最终得到的只是一个无解或者有解的判断，并没有输出表达式。
所以我对这个算法进行了一定的改进，使之能输出表达式。
首先要考虑的，也是最重要的，是这个程序的数据结构。最终的目的自然是为了达到最少的时间复杂度。由于上述方法中f函数返回的是“集合”，因此不存在重复的元素。这样的情况下，哈希表自然是首选的数据结构。
为了记录表达式，需要引入另一套数据结构。每一个计算的结果都必须和一个表达式对应。这样，当最终查询到一个计算结果为24的时候，只需查找相应的表达式就可以得到结果。
这里就产生了冲突。哈希表的特点是存放是乱序的，也就是说，如果只采用一个哈希表存放计算结果，用一个vector存放表达式，那么无法产生对应关系。
因此，有两种方案：
第一种方案比较节省存储空间，将计算结果和表达式分别存在两个vector中，由于两者都是有序的集合类，因此可以在插入数据的时候令各自的下标对应，这样就可以方便地得到对应关系。但是，这样做的后果是，在插入新数据的时候需要在vector中查找是否已经存在这个计算结果，如果已有则不必插入。 vector的查找是穷举式的，效率比较低，尤其是当vector比较大的时候将很大程度上影响计算的效率。但如果不进行查找，势必会计算很多没有意义的重复结果，这样就失去了这个算法的意义了。
第二种方案在第一种方案的基础上将计算结果多存一份哈希表数据。这样做增加了存储空间，但是在时间上的优势是显而易见的。在插入的时候，通过查找哈希表来决定是否已经存在这个结果，由于哈希表的查找效率很高，因此这一步不会对这个程序造成时间上的瓶颈。如果不存在，那么同时在哈希表和两个vector中同时插入数据即可。计算结果和表达式的对应关系依然存在，同时查找的效率也大大提高，整个程序的时间复杂度大大降低。这是典型的空间换时间的方法。
写算法我首选的语言还是c++，但是很惭愧c++的HashTable我不会用，因此用java写了一个版本，还算比较成功，能输出最终的结果。在写程序前我写了一个小程序来测试java的HashSet和ArrayList的查找效率，结果很令人惊讶。在10000次查询中，HashSet所用时间为0ms，而ArrayList则用了1300多ms，看来这个效率完全不是一个数量级上的。因此我采用了上述的第二种方案，最终的效果还不错。
曾经有人问过我5，5，5，1怎么算24点，当时想了很久都没想出来。现在用这个程序可以很轻松地算出5*(5-1/5)=24。看来这个程序可以输出一些大家想不到的结果，很强大把。类似的例子还有很多，比如3，3，7，7等等。总之呢，优化了的穷举法（我这个程序实际上还是一种变相的穷举）是一种很不错的解决问题的思路，值得采用！
过几天就开学了。也许每年的开学前才有时间去研究下这种问题，等到开学之后就基本没什么时间了。嗯，好好工作把，也愿今年能开个好题，明年好好做毕设。Good luck。
PS:昨天经同学提醒才发现有更好的解决方法。主要是因为好久没用，把java的HashMap给忘了。这个数据结构用在这里正合适，也就是说不用两个HashSet加两个ArrayList解决了，直接存在一个HashMap里面就可以。
具体的做法是：把计算结果存在map的key中，而表达式存在map的value中，问题彻底解决。map中key的查找效率是很高的，同时插入也很快；当找到一个计算结果为24的时候直接根据这个key去寻找相应的value即可得到完美的答案，同时HashMap也保证了每个计算结果只保留一个表达式，避免了重复。
我做了一下性能测试，总的来这个改进后的版本效率比以前的版本略有提高，但是最关键的是大大减少了空间的存储，因此也算是对程序进行的大优化把我想。这两天看这个帖子似乎看的人比较多哈，也愿我的想法能给大家一些启发。
Ⅲ 6.6.9.10算24点怎么算
算24点的技巧:有基本算式法，特性求解法，倍数法，巧用分数法，具体解法如下：
1、基本算式法
利用2*12=24,3*8=24,4*6=24求解。一般情况下，先要看四张牌中是否有2,3,4,6,8，Q，如果有，考虑用乘法，将剩余的三个数凑成对应数。如3,3,6,10可组成（10-6/3）*3=24。如果没有2,3,4,6,8，Q，看是否能先把两个数凑成其中之一，再求解24。
2、特性求解法
1）利用0、11的运算特性求解。如（3,4，4,8）可组成3*8+4-4=24。
2）如果有两个相同的6，剩下的只要能凑成2,3,4,5都能算出24，比如6,6,3可以3*6+6=24。同理，如果有两个相同的8，剩下的只要能凑成2,3,4就能算出24。
如（2,5,8,8），（5-2）*8=24，多一个8，可以用乘法的分配律消去8，将算式改为5*8-2*8，将多余的8消去；如果有两个相同的Q，剩下的只要能凑成1,2,3就能算出24，如（9，J,Q,Q）可以12*11-12*9=24。
3、倍数法
利用24的倍数求解2*24=48,3*24=72,4*24=96,5*24=120,6*24=144想办法去凑48,72,96,120,144来求解。在具体的运算过程中，先将数乘得很大，最后再除以一个数得24。
4、巧用分数法
利用24的分数求解。先将数算成分数或小数，最后乘以一个数得24。用一个数除以一个分数，相当于乘以这个数的倒数，最后得24。
24点的口诀为见3凑8，见4凑6，见2凑12等等。
稍微特殊点的规律：2乘10+4，15+9，21+3，14+10等。
(3)24点递归算法输出结果扩展阅读：
“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧问题。计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。这里向大家介绍几种常用的、便于学习掌握的方法：
1．利用3×8＝24、4×6＝24求解。
把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。如3、3、6、10可组成（10—6÷3）×3＝24等。又如2、3、3、7可组成（7＋3—2）×3＝24等。实践证明，这种方法是利用率最大、命中率最高的一种方法。
2．利用0、11的运算特性求解。
如3、4、4、8可组成3×8＋4—4＝24等。又如4、5、J、K可组成11×（5—4）＋13＝24等。
3．在有解的牌组中，用得最为广泛的是以下六种解法：（我们用a、b、c、d表示牌面上的四个数）
①(a—b）×（c＋d）
如（10—4）×（2＋2）＝24等。
②（a＋b）÷c×d
如（10＋2）÷2×4＝24等。
③（a－b÷c）×d
如（3—2÷2）×12＝24等。
④（a＋b－c）×d
如（9＋5—2）×2＝24等。
⑤a×b＋c—d
如11×3＋l—10＝24等。
⑥（a－b）×c＋d
如（4—l）×6＋6＝24等。
游戏时，同学们不妨按照上述方法试一试。
需要说明的是：经计算机准确计算，一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点，如A、A、A、5。
经典24点
4
4
10
10
这个难点在于先要算出一个很大的数，就是100，然后再通过减4，除4就可以得到24点：(10×10-4)÷4=24。
6
9
9
10
这个也要先算大数90，然后除6，再加9即可得24点：9×10÷6+9=24。
2
2
2
9
这个并不难，只是数字比较好玩，包含了3个2，其计算方法为：(2+9)×2+2=24。
1、概述
给定4个整数，其中每个数字只能使用一次；任意使用 + - * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。这方面的程序很多，一般都是穷举求解。本文介绍一种典型的算24点的程序算法，并给出两个具体的算24点的程序：一个是面向过程的C实现，一个是面向对象的java实现。
2、基本原理
基本原理是穷举4个整数所有可能的表达式，然后对表达式求值。
表达式的定义： expression = (expression|number) operator (expression|number)
因为能使用的4种运算符 + - * / 都是2元运算符，所以本文中只考虑2元运算符。2元运算符接收两个参数，输出计算结果，输出的结果参与后续的计算。
由上所述，构造所有可能的表达式的算法如下：
(1) 将4个整数放入数组中
(2) 在数组中取两个数字的排列，共有 P(4,2) 种排列。对每一个排列，
(2.1) 对 + - * / 每一个运算符，
(2.1.1) 根据此排列的两个数字和运算符，计算结果
(2.1.2) 改表数组：将此排列的两个数字从数组中去除掉，将 2.1.1 计算的结果放入数组中
(2.1.3) 对新的数组，重复步骤 2
(2.1.4) 恢复数组：将此排列的两个数字加入数组中，将 2.1.1 计算的结果从数组中去除掉
可见这是一个递归过程。步骤 2 就是递归函数。当数组中只剩下一个数字的时候，这就是表达式的最终结果，此时递归结束。
在程序中，一定要注意递归的现场保护和恢复，也就是递归调用之前与之后，现场状态应该保持一致。在上述算法中，递归现场就是指数组，2.1.2 改变数组以进行下一层递归调用，2.1.3 则恢复数组，以确保当前递归调用获得下一个正确的排列。
括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。所以在以上算法中，无需考虑括号。括号只是在输出时需加以考虑。
Ⅳ 24点游戏算法
看了N个24点的源码了，虽然都能正确的得到结果，不过从效率和智能上来说都很垃圾。(国内的程序员，大多也就是在源码基础上改改而已，这也是企业追逐经济利益的趋势。真正写底层算法的高手就没多少了。。。如果A*，8皇后和跳马的算法对你来说没什么难度，可以尝试写下。很多人应该可以略过看下面的内容了，或者只看不思考，免得伤脑筋)。 这些算法的通病，也正是我目前想解决的问题是：1 效率性把24点扩展一下，就是要写一个函数。function fun(arr:Array,num):Array{ //arr参数为[a,b,c,d,e....] //N个数字,在24点游戏里，为[a,b,c,d] 4个数 //num //要匹配的结果 24点游戏里，num=24 return Array //输出结果存在数组里，如["(3+3)*(2+2)","(3*2+2)*3".........]}如果是N个数字的计算，用N来计算程序的复杂度。那么24点的很多算法是属于穷举排列，无法扩展，并且重复计算量很多。没效率可言2 结果的正确性这个也能说明为什么连把公式穷举出来，作为类似索引表的这样典型空间换时间的方法，效率还是很低。这里还涉及到一点智能问题。
AI很难识别相同的运算。
如 a+b+c+d 和 a+c+b+d 按游戏规则来说属于同种方法 但是在很多方法里，会得出重复的，如同时会输出 ((a+b)+c)*d 和 ((a+c)+b)*d这样同样的公式。在我们玩24点扑克游戏时，这点明显是不允许的。虽然24点这游戏并不是那么严谨，但是有这样的潜规则 在别人讲他的算法时，如果你马上能想出同样能算出24的不同类的方法，可以视为平手 如 2*4*(4-1) 和 (4+4)*(2+1) 可以视为不同的算法。 特殊情况，当牌有点数相同的，花色不同时， 相同点数的位置替代，也应属于同类运算，但是没有一个代码能够识别这些的。 另外(8-(1+3))*6 和 (8-1-3)*6 理应属于同种算法。在程序中理应执行一遍，并且也只属于(8-1-3)*6这种括号数较少的公式才合理。 程序一次是只能计算两个数的运算的。用递归回溯的思路，可以方便的遍历所有的执行顺序和符号组合。但是实际写起来，在程序中，用条件判断，剔除种种不必要的运算和生成简捷正确的公式，难度非常大。另外就是递归的层级相当多，代码设计难度也很大。 这个程序执行所费的时间，花在公式上的存储读取时间和条件判断所花费的时间也是相当可观的。3 智能性 还是回到24点来说了。拟人的思路。 当我们玩24点的游戏，很多时候，大家都不愿意多看，马上要求换牌。比如说A，A，2，2。在程序里可以这样解释，if(a*b*c*d<24){return} 牌太小了不可能有计算结果。 这时我们换了一张牌，结果大家都抢着报自己的答案了。为什么能这么快呢？这和人工智能里的学习记忆机制挂点钩。人算时，并不会像通常的程序那样去排列组合，直到得到满意的结果为止。而是有很多优先的成分。比如说4张牌里面，有一张牌是3，那么，我们马上会想到的是把其它3张牌组合成8。而如果里面有张牌是4，我们会想到把其它3张牌组合成6。而且24点这游戏一般两人玩，手动出牌也很难保证4张牌同时出。不同人的注意力也集中在不同地方。就生成了一个优先度的问题。 如上所诉，那么在计算24点的程序里，如果a,b,c,d里面，有数字=2，3，4，6，8，12这样的12的因数在里面，我们一般应该将这样的数字放在最后去计算，优先组合其它的3个数字。如果数字在数组的位置和优先计算有关系的话，即是 for(var i in arr){ if(arr[i]==24的因数){ arr.push(arr.splice(i,1)) } } 如果要换其中某一张牌时，这时我们其实已经将其他3张牌的种种排列组合已经计算好了。只能与换的那种牌组合了。如果其他3张牌组合好了与第4张牌在一起并不能得到结果，那么也并不代表无解。只是这种方法行不通。那么应该抛弃这样的组合方式，并重新计算(从效率上来说，等同于这样的算法不需要再计算，程序的表达上，这点也较有难度)。 人脑计算时，如果4张牌里面有相同的牌的话， 如果相同的牌不是24的因数，通常是优先把这样的牌给计算掉，假设4张牌为[a1,b1,c,d](后接数字，数字相同的代表数值相等)，那么一般会先这样拆 (a1?c)?(b1?d) ，把相同的牌尽量和其他的牌组合，生成24的因数。如 5,5,3,2 这样的牌，我们会马上反映出 5+3=8 5-2=3 3*8=24，那么换成程序来说，4张牌的优先顺序可能为[a1,c,b1,d]，当a1,c经过计算得到新值e时，排列为[b1,d,e] 如果相同的牌是24的因数。那么我们可能会保留一个，并计算其他3张能否凑成另一个需要的因数。如牌8，8，2，3 我们会优先计算 8*(8-2-2)。而程序上来说，4个数的优先程度是[a1,c,d,b1]上面只分析了部分常见情况，细分下来非常多，并且在程序里实现起来有点难度。不过如果分得很细了。条件判断所用的时间视为0。而每次拟人的计算过程用setInterval(时间周期模拟人脑的一个计算周期)，而不是简单的for来算的话。可能那个24点的程序就很完善了。输入一些参数，设置能模拟出不同的人在牌放置的位置时，计算所用的时间。如果下一次的4张牌刚好和上盘的4张牌一样或重复了3张优先计算的牌，就会像人一样马上靠回忆而不是计算得出结果。 24点的扑克游戏，一个很简单的游戏，如果想复杂了，也是个不得了的东西。
这样可以么？
Ⅳ 各位大神！ 4个数递归法求24点 不要用穷举做 请用C 做 需要有详细的注解，谢谢了 有必要可以追分~~~
具体详细的注解我就不写了，主要原理是这样的
首先是通过四个数经过四则运算得到24，先取出第一个数跟24进行四则运算，获得的四个结果就是剩下三个数经过四则运算需要得到的，以此类推知道最后一个数查看是否是你想要的，这样通过递归法实现便可以求出结果
这里用到一个全排列算法你可以自己看一下
具体详细的注解我就不写了，主要原理是这样的
首先是通过四个数经过四则运算得到24，先取出第一个数跟24进行四则运算，获得的四个结果就是剩下三个数经过四则运算需要得到的，以此类推知道最后一个数查看是否是你想要的，这样通过递归法实现便可以求出结果
这里用到一个全排列算法你可以自己看一下
代码不知道为什么贴不上了，总提示对不起！您的提问（回答）中包含不适合发表的内容，请修改后再提交 你看看能不能通过别的方法给你
Ⅵ C语言算24点
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
char op[3], o[5]="+-*/";
float n[4], on[10];
int used[4] = {0}, top=0, tp=0, x;
void chk(float k);
void search24(int d);
float calc(float n1, float n2, char o);
void make(int i, float p, float q, char o, int d);
int main( void )
{
printf("please input 4 card number: ");
scanf("%f%f%f%f", &n[0], &n[1], &n[2], &n[3]);
search24(0);
printf("No answer. ");
return 0;
}
void chk(float k)
{
if( (tp != 3) || ( fabs(k-24.0) > 0.000001 )) //没有用完3个运算符或者结果不为24就退出.
return;
for(x=0; x<5; x+=2) //这样设计是为了使3个选中的符号都可以得到输出.
printf("%g%c%g=%g ", on[x], op[x/2], on[x+1], //分析得到的.
calc(on[x], on[x+1], op[x/2]));
system("pause");
exit(0);
}
float calc(float n1, float n2, char o)
{
switch(o){
case '+': return (n1+n2);
case '-': return (n1-n2);
case '*': return (n1*n2);
case '/': return (n1/n2);
default: exit(0);
}
}
void make(int i, float p, float q, char o, int d)
{
if(fabs(q)>0.000001 || o!='/') //除数不为0,或者为0的时候不能为除数.
n[i] = calc(p, q, o);
op[tp++] = o;
chk(n[i]);
search24(d+1);
tp--; //因为是全是全局变量,所以在做试验性的循环递归问题时,如果失败,要在递归函数后面重新恢复回原来的值
}
void search24(int d)
{
int i, j, k;
float p, q;
if(d>=3) //控制递归深度,就是运算符的输出个数.
return;
for(i=0; i<4; i++)
for(j=0; j<4; j++)
if( (i!=j)&& (used[i]+used[j] == 0) ) //i!=j是防止重复,(used[i]+used[j] == 0)是防止又再匹配已经用过的j,
//但是i可以新来.
{
used[j] = 1; //j得到匹配之后,赋值为1,表示已经使用
p=n[i];
q=n[j];
on[top++] = p;
on[top++] = q;
for(k=0; k<4; k++) //运算符的循环试用.
make(i, p, q, o[k], d);
n[i] = p; //因为是全是全局变量,所以在做试验性的循环递归问题时,
used[j] = 0; //如果失败,要在递归函数后面重新恢复回原来的值
top -= 2; //
}
}
出处:http://blog.sina.com.cn/s/blog_491de9d60100d5er.html
Ⅶ 24点的算法问题
这个问题实际上是一个编程问题，而不是计算问题。
可能您需要大量的时间来编写这个算法，但在计算中，可以获得时间精简。
比如：2 3 5 1
在标准24点程序中，试探2*5=10后，需求值为2.4或14，但是3+1只能达到4（在这个问题中，明显乘法所得值较大；在出现1时加法所得值较大），不可能更多，所以不用试探3和1的四则运算就可以舍弃2*5的计算法。
在编程中，您当然必须耗费大量的脑力来穷举，但是您可以让计算机绕过一些明显的死路，这样可以用选择比较来大大缩短计算的时间。
不要问我标准算法，我只想提供思路。