24点游戏规则：
给玩家4张牌，每张牌面值在1-13之间，允许其中有数值相同的牌，采用加、减、乘、除四则运算，允许中间运算存在小数，并且可以使用括号，但每张牌只能使用一次，尝试构造一个表达式，使其运算结果为24.
要依据上述游戏规则构造一个玩24点游戏的算法。
输入：num1 , num2 , num3 , num4
输出：若能得到运算结果为24，则输出一个对应的运算表达式。
如
输入11,8,3,5
输出（11-8）*（3+5）=24
解法一：穷举法
遍历运算符、数字和括号的所有排列组合形式。对于4个数，每个数使用一次，则有4！=24种全排，4个数的四则运算可以重复，则有4^3（4个数运算需要3个运算符），因此不考虑括号情况下有4！*4^3=1536种表达式。考虑括号的情况有五种情况(((AB)C)D)、((AB)(CD))、((A(BC))D)、(A((BC)D))、(A(B(CD)))，因此总共需要穷举1536*5=7680种。
设f(A)代表集合A经过四则运算所能得到的结果集合，则可以采用如下分而治之的思想：
对A先取两个数，进行四则运算后得到的集合取并即可。
如：A={1,2,3,4} 先取出1和2，计算出结果后将结果放回原集合中，得到五个不同的集合B={3,3,4}，C={-1,3,4}，D={1,3,4} E = {2,3,4}，F={1/2,3,4}。则可以递归的定义：f（A）=f（B）并f（C）并f（D）并f（E）并f（F），算法的代码如下所示：
//下面代码是24点游戏的解法一：穷举法
// 输入：四个数字数组numbers[4]
// 输出：可以得到24点，则返回一个表达式结果为24
const int cardsNum = 4;
const int resultValue = 24;
const double Eps = 1E-6; //由于浮点运算会有精度误差，所以用一个很小的数作为容差值
string result[cardsNum];//存放结果表达式
bool PointsSet(int n , double numbers[] )
{
if(n == 1){//递归终止条件
if(fabs(numbers[0]-resultValue) < Eps){//找到24点的一个合法算式
cout<<result[0]<<endl;
return true;
}
else{
return false;
}
}
else{
//取出两个数进行四则运算，递归的求解
for(int i=0 ; i<cardsNum ; i++)//任取两个数
for(int j=i+1 ; j<cardsNum ; j++){
double a = numbers[i];//第一个数
double b = numbers[j];//第二个数
string res1 = result[i];//第一个表达式
string res2 = result[j];//第二个表达式
//进行加法运算a+b
numbers[i] = a+b ; //第一个数存放结果
numbers[j] = numbers[n-1];//第二个数存放最后一个数
result[i] = '(' + res1 + '+' + res2 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))//递归的计算，如果计算结果不为24，则尝试下一种四则预算
return true;
//进行减法运算a-b
numbers[i] = a-b;
numbers[j] = numbers[n-1];
result[i] = '(' + res1 + '-' + res2 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))
return true;
//进行减法运算b-a
numbers[i] = b-a;
numbers[j] = numbers[n-1];
result[i] = '(' + res2 + '-' + res1 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))
return true;
//进行乘法运算a*b
numbers[i] = a*b;
numbers[j] = numbers[n-1];
result[i] = '(' + res1 + '*' + res2 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))
return true;
//进行除法运算a/b
if(b != 0){
numbers[i] = a/b;
numbers[j] = numbers[n-1];
result[i] = '(' + res1 + '/' + res2 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))
return true;
}
//进行除法运算b/a
if(a != 0){
numbers[i] = b/a;
numbers[j] = numbers[n-1];
result[i] = '(' + res2 + '/' + res1 + ')';
result[j] = result[n-1];
if(PointsSet(n-1 , numbers))
return true;
}
//如果遍历本步所有四则运算结果24都没有出现，则退回上步。复原
numbers[i] = a;
numbers[j] = b;
result[i] = res1;
result[j] = res2;
}
return false;
}
}
int main(int argc, char const *argv[])
{
double numbers[cardsNum];
cout<<"输入：四个数字数组numbers"<<endl;
for(int i=0 ; i<cardsNum ; i++)
{
cin>>numbers[i];
char buffer[20];
_itoa_s(numbers[i] , buffer , 10);
result[i] = buffer;
}
if(PointsSet(cardsNum , numbers))
cout<<"Success"<<endl;
else
cout<<"Fail"<<endl;
return 0;
}
解法二：分治法
解法一中存在大量的冗余计算，可以使用分治法将集合A分为非空真子集Ai和另外一部分A-Ai，当Ai穷尽所有A的真子集的时候，f(A)=并Fork(f(Ai) ,f(A-Ai));，其中Fork()含义是解法一中实现的六种运算结果（因为对于减法和除法，不同的运算次序得到结果不同）。f(A)定义为A集合中经过四则运算得到的结果集合。
下面是伪代码：
//伪代码实现24点游戏
//对于四个元素的集合A={a1,a2,a3,a4}，可以使用变量i来表示集合元素是否存在，如0111代表集合{a2,a3,a4}
//在main函数中调用 f((1<<cardsNum)-1)就可以递归的计算到f(i)(0<=i<=N-1)结果集，结果保存在S[i]中
//由定义可以知道f(0001)=a1、f(0010)=a2、f(0100)=a3、f(1000)=a4。所以初始化S集合时要注意以此作为递归截止条件
//S[i]=f(i)即S集合每个元素是f(i)的结果集。最终在S[15]中寻找是否有24的存在，有的话说明可以得到24点
24Game(Array)//Array为输入，每个元素为ai(0<=i<=N-1)
{
for(i=0 ; i<2^N ; i++)
S[i].clear();//初始化S集合
for(int i=0 ; i<N ; i++)
S[1<<i]=ai;
for(i=0 ; i<2^N ; i++)
S[i]=f[i];
s[2^N-1].find(24);//查找是否有24点的存在
}
set f(int i)
{
if(S[i].size())//memo
return S[i];
for(x=1 ; x<i ; x++)//遍历所有非空真子集
if((x&i) == x){//x代表集合是i代表集合的非空真子集
S[i] = Fork(f(x) , f(i-x));
}
}
下面是实现代码，参考：http://blog.csdn.net/tianshuai1111/article/details/7713640
//下面给出24点游戏的具体代码
//采用C++的set作为S[]集合
const int cardsNum = 4;
const double Eps = 1E-6;
const int RES = 24;
struct ELEM{
ELEM(double r , string& i):result(r),info(i) {}
ELEM(double r , char *i):result(r),info(i){}
double result;//运算出的结果
string info;//运算过程
bool operator<(const ELEM &m)const{//在set的红黑树插入需要比较操作
return this->result<m.result;
}
};
set<ELEM> vset[1<<cardsNum];//一定要放在struct定义的后面，否则编译器无法知道set中类型是什么
set<ELEM>& f(int i)//i二进制形式代表A真子集,返回一个集合
{
if(vset[i].size())//memo
return vset[i];
for(int x=1 ; x<i/2 ; x++){//遍历所有非空真子集，由分治的对称性，只分一半
if((x&i) == x){//x是i的一个真子集
string str;
set<ELEM>& s1 = f(x);
set<ELEM>& s2 = f(i-x);
set<ELEM>::iterator iter1;
set<ELEM>::iterator iter2;
for(iter1=s1.begin() ; iter1!=s1.end() ; iter1++)
for(iter2=s2.begin() ; iter2!=s2.end() ; iter2++){
//两元素的六项运算存入对应的vset[i]中
str = '(' + iter1->info +'+' + iter2->info + ')';
vset[i].insert(ELEM(iter1->result+iter2->result , str));
str = '(' + iter1->info +'-' + iter2->info + ')';
vset[i].insert(ELEM(iter1->result-iter2->result , str));
str = '(' + iter2->info +'-' + iter1->info + ')';
vset[i].insert(ELEM(iter2->result-iter1->result , str));
str = '(' + iter1->info +'*' + iter2->info + ')';
vset[i].insert(ELEM(iter1->result*iter2->result , str));
if(abs(iter1->result) > Eps){//第一个数不为0
str = '(' + iter2->info +'/' + iter1->info + ')';
vset[i].insert(ELEM(iter2->result/iter1->result , str));
}
if(abs(iter2->result) > Eps){//第二个数不为0
str = '(' + iter1->info +'/' + iter2->info + ')';
vset[i].insert(ELEM(iter1->result/iter2->result , str));
}
}
}
}
return vset[i];
}
int main()
{
cout<<"请输入4个数字："<<endl;
int numbers[cardsNum];
for(int i=0 ; i<cardsNum ; i++)
cin>>numbers[i];
for(int i=0 ; i<cardsNum ; i++){//初始化vset[15]集合,置vset[2^i].result = ai;
char buffer[10];
sprintf_s(buffer , "%d" , numbers[i]);
vset[1<<i].insert(ELEM(numbers[i] , buffer));
}
set<ELEM> resultSet = f((1<<cardsNum)-1);
set<ELEM> ::iterator iter;
for(iter=resultSet.begin() ; iter!=resultSet.end() ; iter++){
if(iter->result == RES)
cout<<iter->info<<endl;
}
}
2829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
