用递归法实现24点算法的原理？100分！

[yhec]

穷举法实现24点算法，很简单，
不知递归法写24点算法怎样，用递归法的24点算法的原理？

[赵4老师]

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！
递归函数关注以下几个因素
·退出条件
·参数有哪些
·返回值是什么
·局部变量有哪些
·全局变量有哪些
·何时输出
·会不会导致堆栈溢出

仅供参考
http://topic.csdn.net/u/20120202/11/446d2bd3-e726-4a6e-9533-92dae10358ca.html

[zhouliang0806]

我是来看赵老师的高见的

[BCBPLC]

24点算法代码（C语言版本）

int Search(int n, int iGroup)

{

/*~~~~~~~~~~*/

int i, j;

double a, b;

char expa[MAX_LENGTH_OF_EXP];

char expb[MAX_LENGTH_OF_EXP];

/*~~~~~~~~~~*/

if(1 == n)

{

if(fabs(number[iGroup][0] - NUMBER_TO_BE_CAL) <

PRECISION)

{

return 1;

}

else

{

return 0;

}

}

for(i = 0; i < n; i++)

{

for(j = i + 1; j < n; j++)

{

strcpy(expa, expression[i]);

strcpy(expb, expression[j]);

a = number[iGroup][i];

b = number[iGroup][j];



number[iGroup][j] = number[iGroup][n - 1];

strcpy(expression[j], expression[n - 1]);



sprintf(expression[i], "(%s+%s)", expa, expb);

number[iGroup][i] = a + b;



if(Search(n - 1, iGroup))

{

return 1;

}



sprintf(expression[i], "(%s-%s)", expa, expb);

number[iGroup][i] = a - b;

if(Search(n - 1, iGroup))

{

return 1;

}



sprintf(expression[i], "(%s-%s)", expb, expa);

number[iGroup][i] = b - a;

if(Search(n - 1, iGroup))

{

return 1;

}



sprintf(expression[i], "(%s*%s)", expa, expb);

number[iGroup][i] = a * b;

if(Search(n - 1, iGroup))

{

return 1;

}



if(b != 0)

{

sprintf(expression[i], "(%s/%s)", expa, expb);

number[iGroup][i] = a / b;

if(Search(n - 1, iGroup))

{

return 1;

}

}



if(a != 0)

{

sprintf(expression[i], "(%s/%s)", expb, expa);

number[iGroup][i] = b / a;

if(Search(n - 1, iGroup))

{

return 1;

}

}



number[iGroup][i] = a;

number[iGroup][j] = b;

strcpy(expression[i], expa);

strcpy(expression[j], expb);

}

}

return 0;

}



基本原理

基本原理是穷举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 则恢复数组，以确保当前递归调用获得下一个正确的排列。



括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。

所以在以上算法中，无需考虑括号。括号只是在输出时需加以考虑。





程序中比较重要的地方解释如下：

(1) int Search(int, int) 就是递归函数. char expression[][] 存放每一步

产生的表达式，最后的输出中要用到。

expression[][] 与 number[][] 类似，也是递归调用的现场，必须在下一层递

归调用前改变、在下一层递归调用后恢复。



(2) number[][] 数组长度只有4。 在 Search() 中，每次取出两个数后，使用

局部变量 a, b 保存这两个数，

同时数组中加入运算结果，并调整数组使得有效的数字都排列在数组前面。

在下一层递归调用后，利用局部变量a, b 恢复整个数组。对 expression[][]

的处理与 number[][] 类似。



(3) 因为 + * 满足交换率而 - / 不满足，所以程序中，从数组生成两个数的

排列，

for (i = 0; i < n; i++) {

for (j = i + 1; j < n; j++) {

其内层循环 j 是从 i+1 -> n，而非从 0->n，因为对于交换率来说，两个数字

的顺序是无所谓的。

当然，循环内部对 - / 做了特殊处理，计算了 a-b b-a a/b b/a 四种情况。



(4) 此程序只求出第一个解。当求出第一个解时，通过层层 return true 返回

并输出结果，然后程序结束。



(5) 以 double 来进行求解，定义精度，用以判断是否为 24 。考虑 (5-1/5)

*5 这个表达式就知道这么做的原因了。



(devil) 输出时，为每个表达式都添加了括号。



（6） 输出时，为每个表达式都添加了括号。

[BCBPLC]

递归法算24点2008-02-20 16:13(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）


C源码


#include <stdio.h>
#include <string.h>
#include <math.h>
#define MAXS 4
#define TARGET 24
char sss[]={'+','-','*','/'};

double add(double a,double b)
{return a+b;}
double sub(double a,double b)
{return a-b;}
double mul(double a,double b)
{return a*b;}
double div(double a,double b)
{if(b==0) return 999;return a/b;}

double (*fpt[])(double,double)={add,sub,mul,div};

//参数1：要计算的4个数的数组首地址
//参数2：参数1的数组大小
//参数3：用来储存输出的数组
//返回：1表示成功，0表示失败

int comp24(double *souce,int l,char sc[MAXS][100])//souce为对象数组，为当前目标长度，sc为输出字符串数组
{
double aa[MAXS];
char sc1[MAXS][100];
int i1,i2,j,k,z1;

if(l==1)//当数组中长度为1时，对其进行判断，输出
{
if(fabs(souce[0]-TARGET)<0.01)
{printf("success!\n");
printf("%s",sc[0]);
return 1;}
return 0;
}
for(i1=0;i1<l;i1++)//2个for用来取任意2个位置不相等的数
for(i2=0;i2<l;i2++)
{
if(i1==i2)continue;
for(z1=0,k=0;k<l;k++)//将剩下的元素放入另一个数组
{
if(k!=i1&&k!=i2)
{
sprintf(sc1[z1],"%s",sc[k]);
aa[z1++]=souce[k];
}
}
for(j=0;j<4;j++)//计算，递归
{
aa[z1]=fpt[j](souce[i1],souce[i2]);
sprintf(sc1[z1],"(%s%c%s)",sc[i1],sss[j],sc[i2]);
if(suan24(aa,z1+1,sc1)==1)
return 1;
}
}
return 0;
}

void main()
{
double bbb[]={1,2,3,4};
char output[MAXS][100];
for(n=0;n<MAXS;n++)
comp24(bbb,MAXS,output);
}

[BCBPLC]

#include<stdio.h>
#define N 4
#include<math.h>
float cun[N-1][3];
int q=0;

float f(int b,float m,float n) /*定义函数f,功能:对m和n进行四则运算,参数b代表四则运算法则*/
{
float c;
if(b==1)
c=m+n;
else if(b==2)
c=m-n;
else if(b==3)
c=m*n;
else if (b==4&&n!=0)
c=m/n;
else
c=-1000;
return (c);
}

void pf(int b,float m,float n) /*定义函数pf,功能:输出,参数b代表四则运算*/
{if(b==1)
printf("%.3f+%.3f=%.3f\t",m,n,f(1,m,n));
else if(b==2)
printf("%.3f-%.3f=%.3f\t",m,n,f(2,m,n));
else if(b==3)
printf("%.3f*%.3f=%.3f\t",m,n,f(3,m,n));
else if(b==4&&n!=0)
printf("%.3f/%.3f=%.3f\t",m,n,f(4,m,n));
}

int work(float a[],int b1[],int count,int p) /*定义函数work,参数p*/
{
int i,k,j,way;
int b2[N]={0};
float c[N];

if(p==0)
{if(fabs(a[0]-24)<1e-5)
q=1;
return 0;
}

if(count==-1)
{ for(way=1;way<5;way++)
{for(i=0;i<p+1;i++)
if(i==0)
{if(way==4&&a[b1[1]-1]==0)
goto end;
c[i]=f(way,a[b1[0]-1],a[b1[1]-1]);
}
else c[i]=a[b1[i+1]-1];

work(c,b1,p-1,p-1);
if(q==1)
{cun[N-p-1][0]=way;
cun[N-p-1][1]=a[b1[0]-1];
cun[N-p-1][2]=a[b1[1]-1];
return 0;
}
end:;
}
}

for(j=1;j<=p+1;j++)
{for(i=0;i<N;i++)
b2[i]=b1[i];
for(i=count+1;i<=p;i++)
if(b1[i]==j)
goto point;

b2[count]=j;
work(a,b2,count-1,p);
if(q==1)
return 0;
point:;
}
}


main()
{
int i,j,b[N];
char p;
float a[N];
do{ q=0;
for(i=0;i<N;i++)
scanf("%f",&a[i]);
work(a,b,N-1,N-1);
if(q==1)
for(i=0;i<N-1;i++)
pf(cun[i][0],cun[i][1],cun[i][2]);
else printf("No answer.");
scanf(" %c",&p);
} while(p!='n');
}

[yhec]

一下子这么多，百度上搜来的吧。
第三个我试了上下，结果：
1
4
5
6

5.0/6.0=0.8333 1-0.83333=0.167 4.000/0.167=24.000
意思是出来了，但显示效果不好！