编程之美1.16——24点游戏

问题：

给玩家4张牌，每张牌的面值在1-13之间，允许其中有数值相同的牌，采用加、减、乘、除四则运算，允许中间运算存在小数，并且可以使用括号，但每张牌只能用一次。构造表达式，使其结果为24.

解法：

传统的枚举解法会产生大量重复的运算，主要有两类重复：运算结果的重复和排列的重复。假设4张牌为3 3 8 8，我们对3 3进行一次操作（6种运算）得到6 0 0 1 1 9，其中重复的数据就是我们所说的运算结果重复，使用集合不重复性来解决。枚举算法在枚举时要对牌的顺序进行排列，由于牌可以重复，所以产生的排列会有大量的重复(3
3) 8 8, (3 8) 3 8, (3 8) 3 8,
(3 8) 3 8,(3 8) 3 8, (8 8) 3 3，这属于排列重复，使用分治法加memo来解决。采用二进制数来表达集合和子集的概念，我们可以用一个数来表示子集中拥有哪些元素，再用这个数作为索引来找出该集合运算后产生的结果集。

#include <iostream>
#include <set>
#include <string>
using namespace std;

#define N	4	// 4张牌，可变
#define RES	24	// 运算结果为24，可变
#define EPS 1e-6

struct Elem
{
Elem(double r, string& i):res(r),info(i){}
Elem(double r, char* i):res(r),info(i){}
double res;	// 运算出的数据
string info; // 运算的过程
bool operator<(const Elem& e) const
{
return res < e.res; // 在set的红黑树插入操作中需要用到比较操作
}
};

int A
;	// 记录N个数据
// 用二进制数来表示集合和子集的概念，0110表示集合包含第2,3个数
set<Elem> vset[1<<N];	// 包含4个元素的集合共有16个子集0-15

set<Elem>& Fork(int m)
{
// memo递归
if (vset[m].size())
{
return vset[m];
}
for (int i=1; i<=m/2; i++)
if ((i&m) == i)
{
set<Elem>& s1 = Fork(i);
set<Elem>& s2 = Fork(m-i);
set<Elem>::iterator cit1;
set<Elem>::iterator cit2;
// 得到两个子集合的笛卡尔积，并对结果集合的元素对进行6种运算
for (cit1=s1.begin(); cit1!=s1.end(); cit1++)
for (cit2=s2.begin(); cit2!=s2.end(); cit2++)
{
string str;
str = "("+cit1->info+"+"+cit2->info+")";
vset[m].insert(Elem(cit1->res+cit2->res,str));
str = "("+cit1->info+"-"+cit2->info+")";
vset[m].insert(Elem(cit1->res-cit2->res,str));
str = "("+cit2->info+"-"+cit1->info+")";;
vset[m].insert(Elem(cit2->res-cit1->res,str));
str = "("+cit1->info+"*"+cit2->info+")";
vset[m].insert(Elem(cit1->res*cit2->res,str));
if (abs(cit2->res)>EPS)
{
str = "("+cit1->info+"/"+cit2->info+")";
vset[m].insert(Elem(cit1->res/cit2->res,str));
}
if (abs(cit1->res)>EPS)
{
str = "("+cit2->info+"/"+cit1->info+")";
vset[m].insert(Elem(cit2->res/cit1->res,str));
}
}
}
return vset[m];
}

int main()
{
int i;
for (i=0; i<N; i++)
cin >> A[i];
// 递归的结束条件
for (i=0; i<N; i++)
{
char str[10];
sprintf(str,"%d",A[i]);
vset[1<<i].insert(Elem(A[i],str));
}
Fork((1<<N)-1);
// 显示算出24点的运算过程
set<Elem>::iterator it;
for (it=vset[(1<<N)-1].begin();
it!=vset[(1<<N)-1].end(); it++)
{
if (abs(it->res-RES) < EPS)
cout << it->info << endl;
}
}

虽然以上算法在时间复杂度上要小于穷举法，但由于24点游戏的牌数只有4张，计算规模非常小，且上面算法由于引入了set数据结构，该数据结构的底层是一个红黑树，构造的耗时比较高，且访问的复杂度O(h)要大于枚举的O(1)，所以实际运行下，它的速度要比枚举法更慢。下面是书中写的枚举算法，实际运行发现它的速度更快：

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
using namespace std;

const double EPS = 1e-6;
const int NUM = 4;
const int RES = 24;

double A[NUM];
string res_str[NUM];

int times = 0;

bool process(int n)
{
// 退出条件
if (n==1)
{
if (abs(A[0]-RES)<EPS)
{
cout << res_str[0] << endl;
return true;
}
else
return false;
}
double a, b;
string expa, expb;
for (int i=0; i<n; i++)
for (int j=i+1; j<n; j++)
{
times++;
// 保存状态（操作数i,j）
a = A[i];
b = A[j];
expa = res_str[i];
expb = res_str[j];

// 改变状态
A[j] = A[n-1];
res_str[j] = res_str[n-1];
A[i] = a+b;
res_str[i] = '(' + expa + '+' + expb + ')';
if (process(n-1))
return true;
A[i] = a-b;
res_str[i] = '(' + expa + '-' + expb + ')';
if (process(n-1))
return true;
A[i] = b-a;
res_str[i] = '(' + expb + '-' + expa + ')';
if (process(n-1))
return true;
A[i] = a*b;
res_str[i] = '(' + expa + '*' + expb + ')';
if (process(n-1))
return true;
if (b!=0)
{
A[i] = a/b;
res_str[i] = '(' + expa + '/' + expb + ')';
if (process(n-1))
return true;
}
if (a!=0)
{
A[i] = b/a;
res_str[i] = '(' + expb + '/' + expa + ')';
if (process(n-1))
return true;
}

// 恢复状态
A[i] = a;
A[j] = b;
res_str[i] = expa;
res_str[j] = expb;
}
return false;
}

int main()
{
for (int i=0; i<NUM; i++)
{
cin >> A[i];
char c[10];
sprintf(c,"%.0f",A[i]);
res_str[i] = c;
}
clock_t start = clock();
if (process(NUM))
cout << res_str[0] << endl;
else
cout << "failed" << endl;
clock_t duration = clock() - start;
cout << duration << endl;
}