24点游戏递归法

24点游戏是经典的纸牌益智游戏。

常见游戏规则：

   从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。

基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。

          1.程序风格良好(使用自定义注释模板)

          2.列出表达式无重复。

算法描述:

递归调用的核心思路:

1. 在四个数遍历选两个数;
2. 计算该组合在此运算符下的结果；
3. 将步骤2的结果放入原数组第i个,将最后一个放入原数组的第j个；并对字符串数组赋对应的表达式;
4. 对新数组递归调用f，找到一个表达式则返回；
5. 将步骤2的结果移除，并将该组合中的两个数重新放回该数组；字符串数组也同理;

C++源码如下:

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<ctime> 
#include<string>
using namespace std;
int n=4;//三次运算标记值 
int A[4]={0};//存储4个数字
char oper[4]={'+','-','*','/'}; //存储运算符
string B[4];
int count=0;
int F(int n){
	//判断是否已完成三次运算 
	if(n==1){
		if(A[0]==24)//判断结果是否为24 
		{	
			cout<<B[0]<<endl;//如果可以则输出,B[0]里蕴含了整个表达式 
			count++;
		} 
		else
		{} 
	}
	//从数组中任意取出两个数的组合 
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			double a,b;
			string x,y;
			a=A[i];
			b=A[j];
			A[j]=A[n-1];//将最后一位的赋给空出来的j 		
			x=B[i];
			y=B[j];
			B[j]=B[n-1];//最后一位的数字放入第j个 
			
			A[i]=a+b;//第一个空间保存前两个的运算结果 
			B[i]='('+x+'+'+y+')';//将第一步的运算结果存入数组 
			F(n-1);
			
			//减法应该分顺序 
			A[i]=a-b;
			B[i]='('+x+'-'+y+')';
			F(n-1);
			A[i]=b-a;
			B[i]='('+y+'-'+x+')';
			F(n-1);
			//乘法 
			A[i]=a*b;
			B[i]='('+x+'*'+y+')';
			F(n-1);
			//除法也要分顺序, 并且判断分母不为零 
			if(b!=0){
				A[i]=a/b;
				B[i]='('+x+'/'+y+')';
				F(n-1);
			}
			if(a!=0){
				A[i]=b/a;
				B[i]='('+y+'/'+x+')';
				F(n-1);
			}
			//当以上四则运算的结果都不能满足条件时
			//为了方便进入下一个for循环, 需要将之前的i和j上的值都重新找回 
			A[i]=a;
			A[j]=b;
			B[i]=x;
			B[j]=y;
		
		}
		
	}
}
/*
*对于每一个类，都可以在构造函数中构建一次随机数种子。 
*这样，由于一个随机数种子会对应一个随机数。再由于时间在波动，所以，就可以更新随机数。 
*同样可以增加代码的重用。可以说是一个非常好的程序员思维。 
*/
class RandomNumber{
public:
    RandomNumber(){
        srand(time(0));
    }
    int get(int begin = 0, int end = 1){
        return rand()%(end-begin+1)+begin;
    }
}; 
int main(){
	RandomNumber r;
    for (int i = 0; i < 4; ++i) {//生成4个1~13之间的数字 
        A[i]=r.get(1,13);
		cout<<A[i]<<" "; 
    }
    cout<<endl;
	for(int i=0;i<4;i++){
		if(A[i]==1) B[i]='A';
		else if(A[i]==11) B[i]='J';
		else if(A[i]==12) B[i]='Q';
		else if(A[i]==13) B[i]='K';
		else B[i]='0'+A[i];
	} 
	F(n);
	cout<<endl<<"总共有 "<<count<<" 种解法"<<endl; 
	return 0;
}

测试结果:

 

总结:

这次写24点游戏最开始考虑到括号, 就排列出来这五种

1.(A*B)*C*D

2.(A*(B*C))*D

3.A*((B*C)*D)

4.A*(B*(C*D))

5.(A*B)*(C*D)

最开始for循环太多出现了卡顿, 而且最后结果出现了很多重复的,诸如A*B和B*A其实是一样的;

后来想到了递归,用n作为运算次数传递参数,每次里面只选取两个数字进行运算, 就不用考虑括号的问题, 写的过程本来想在两数全排列的二重循环里面再调用一层循环进行加减乘除, 发现不太能实现, 就百度了一下, 发现是对于每一种运算进行F(n-1)递归, 而且还要注意减法和除法的顺序.

这次作业让我更好的理解了递归这种算法, 就是可以将重复问题能够通过把一个大问题分解成同类的子问题去解决,这样相比穷举法能够省掉很多麻烦