编程之美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];	// 记录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;
}