c++用结构和队列的24点扑克游戏算法（显示所有答案算式）

本程序用C++的结构struct和队列queue处理4张扑克牌计算24点的算法，没有使用递归深搜，程序简洁高效，通用性强，稍改两参数即可每次5张牌算60点；是学习和理解结构和队列应用的经典实例之一。

原理是：获得所有两个数的组合，所有两数组合的6种运算结果和剩余的数组成新的任务节点送入队列。

重要特点是：通过结构的处理的N个数和N个数的对应来源（原始值或计算过程值），最后输出所有合法算式，并对结果进行了去重复处理。

扑克24点四组高难度的检测样例：

第一组：5,5,5,1（小数运算4.8*5） 输出：5*(5-(1/5))=24

第二组：7,7,3,3 （分数运算）输出：7*(3+(3/7))=24

第三组：7,7,4,4 （分数运算）输出：7*(4-(4/7))=24

第四组:3,9,1,10  (正常整数运算，但较偏,33-9=24)   类似：4,4,10,10   ((10*10)-4)/4=24

说明：上述四组对于小学生能算出一组已是天才，全部算出应能985。

完整代码：

#include<bits/stdc++.h>
using namespace std;
struct Node{
	float arr[4];//1-4个牌的实际原始值或运算结果值，除法时会有小数
	char str[4][64];//n个数对应的来源字符串，可能是初值，也可能是运算结果
	int n;//当前节点应处理数字个数，每2个数运算合成1个，即每次减少1个，递减4->3->2->1。
	void init(){//初始化清0
		memset(arr,0,16);
		n=0;
		memset(str,0,4*64);
	}
};
int main(){
	vector<string>result;//字符串算式结果收集表，判断是否有重复。
	int Ansers=0;
	queue<Node>q;//任务队列
	
	//队列增加第一个节点
	Node t;
	t.init();
	scanf("%f,%f,%f,%f",&t.arr[0],&t.arr[1],&t.arr[2],&t.arr[3]);
	sprintf(t.str[0],"%.0f",t.arr[0]);//原始值无小数，即%.0f
	sprintf(t.str[1],"%.0f",t.arr[1]);
	sprintf(t.str[2],"%.0f",t.arr[2]);
	sprintf(t.str[3],"%.0f",t.arr[3]);
	t.n=4;
	q.push(t);
	
	while(!q.empty()){
		Node now=q.front();
		q.pop();
		
		//队列节点运算数每层递减从4--3-->2-->1,当只剩下1个数就是最终的运算结果了
		if(now.n==1){
			//检查是否有重复，比如:5,5,5,1会有四个相同的
			bool ok=true;
			for(int i=0;i<Ansers;i++){
				if(result[i].compare(now.str[0])==0){
					ok=false;
					break;
				}
			}
			if(ok){
				result.push_back(now.str[0]);
				Ansers++;
                printf("%d.结果：%s=24\n",Ansers,now.str[0]);
			}
            continue;
		}
		
		//双循环历遍N个数的所有2数组合
		for(int i=0;i<now.n-1;i++){
			for(int j=i+1;j<now.n;j++){
				t.init();
				//一、先收集除要运算的两个之外的剩余的0-2个
				int at=0;
				for(int k=0;k<now.n;k++){
					if(k!=i&&k!=j){
						t.arr[at]=now.arr[k];
						sprintf(t.str[at],"%s",now.str[k]);
						//strcat(t.str[at],now.str[k]);//也可以
						at++;
					}
				}
				t.n=at+1;//新节点应处理数个数是剩余数增加1
				
				//二、每个两数组合增加6个新节点
				//即：两数组合之外的数值作为节点的共同参数，分别补上6个运算结果值
                //注：at==0时,是最终结果，可以不输出括号更美观一些。
                //1.加
                t.arr[at]=now.arr[i]+now.arr[j];
                if(at==0){
					if(abs(t.arr[at]-24)<1e-6){	//有除法运算的float不能直接比较，误差0.000001
                    	sprintf(t.str[at],"%s+%s",now.str[i],now.str[j]);			
					    q.push(t);						
					}					
				}
				else{
	                sprintf(t.str[at],"(%s+%s)",now.str[i],now.str[j]);			
					q.push(t);	
				}
				 //2.减A   
                t.arr[at]=now.arr[i]-now.arr[j];
                if(at==0){					
					if(abs(t.arr[at]-24)<1e-6){	
                    	sprintf(t.str[at],"%s-%s",now.str[i],now.str[j]);			
					    q.push(t);						
					}					
				}
				else{
	                sprintf(t.str[at],"(%s-%s)",now.str[i],now.str[j]);			
					q.push(t);	
				}
				 //3.减B   
                t.arr[at]=now.arr[j]-now.arr[i];//减法对调
                if(at==0){
					if(abs(t.arr[at]-24)<1e-6){	
                    	sprintf(t.str[at],"%s-%s",now.str[j],now.str[i]);			
					    q.push(t);						
					}					
				}
				else{
	                sprintf(t.str[at],"(%s-%s)",now.str[j],now.str[i]);			
					q.push(t);	
				}				    
				//4.乘	
                t.arr[at]=now.arr[i]*now.arr[j];
                if(at==0){
					//有除法运算的float不能直接比较，误差0.000001
					if(abs(t.arr[at]-24)<1e-6){	
                    	sprintf(t.str[at],"%s*%s",now.str[i],now.str[j]);			
					    q.push(t);						
					}					
				}
				else{
	                sprintf(t.str[at],"(%s*%s)",now.str[i],now.str[j]);			
					q.push(t);	
				}
				//5.除A  
				if(now.arr[j]!=0)//分母不能是0
				{				  
                	t.arr[at]=now.arr[i]/now.arr[j];
                	if(at==0){
						if(abs(t.arr[at]-24)<1e-6){	
                    		sprintf(t.str[at],"%s/%s",now.str[i],now.str[j]);			
					    	q.push(t);						
						}					
					}
					else{
	                    sprintf(t.str[at],"(%s/%s)",now.str[i],now.str[j]);			
					    q.push(t);	
					}
				}
				//6.除B   
				if(now.arr[i]!=0)//分母不能是0
				{
                	t.arr[at]=now.arr[j]/now.arr[i];//除法对调
                	if(at==0){
						if(abs(t.arr[at]-24)<1e-6){	
                    		sprintf(t.str[at],"%s/%s",now.str[j],now.str[i]);			
					    	q.push(t);						
						}					
					}
					else{
	                    sprintf(t.str[at],"(%s/%s)",now.str[j],now.str[i]);			
					    q.push(t);	
					}
				}																	    																
			}
		}
	}
	if(result.size()==0)
		printf("提供的4张牌无法得到24！\n");
	
	return 0;
}