[24点计算器][C++版本]无聊拿去玩

特性：数字数量、目标答案不限，当然数据大了会很慢...

　　　基本可以去除所有本质相同的表达式...至少能等出结果的数据规模可以。。

安卓：http://yun.baidu.com/s/1slCGILn

程序用法：

　　输入n，tar，lim；分别表示n个数，目标答案，最多计算lim个解（0表示输出所有解）

　　然后输入n个数字

　　例：　　4 24 3

　　　　　　1 2 3 4

　　　　　　表示4个数字1，2，3，4要算出24的前三个解

　　　　　　一般6个数找所有答案开O2需要一分半吧。。

思路（当然是爆枚咯。。。）：

由于中缀表达式枚举括号比较麻烦，所以用后缀表达式枚举运算符，最后再把后缀转成中缀输出即可。

但这样还枚举不全，需要枚举数字的全排列再把运算符填进去。

这样虽然可以枚举所有情况，但是因为交换律的存在大量重复出现（比如2*3*4  3*2*4...）所以要去重。。

由于本人能力有限，，所以用了奇怪的方法，，不过效果还不错，方法如下。

　　随机生成若干个（程序里是4个）数组，和原数组匹配，然后用同样的运算符计算各个数组，把答案打包存进map有重复不输出即可

　　例:

　　　　比如当前枚举的运算方法是(a+b)/c*d

　　　　原数组：

　　　　　　w　　x　　y　　z　　　　==>(w+x)/y*z

　　　　随机数组：

　　　　　　a[0][] a[0][] a[0][2] a[0][3]　　　==>(a[0][]+a[0][])/a[0][2]*a[0][3]=A

　　　　　　a[1][] a[1][] a[1][2] a[1][3]　　　==>(a[1][]+a[1][])/a[1][2]*a[1][3]=B

　　　　　　a[2][] a[2][] a[2][2] a[2][3]　　　==>(a[2][]+a[2][])/a[2][2]*a[2][3]=C

　　　　　　......

　　　　　　把{A,B,C,....}放到map里

　　　　当枚举到(b+a)/c*d的时候发现

　　　　　　x      w　　y　　z　　　　==>(x+w)/y*z

　　　　　　a[0][] a[0][] a[0][2] a[0][3]　　　==>(a[0][]+a[0][])/a[0][2]*a[0][3]=D

　　　　　　a[1][] a[1][] a[1][2] a[1][3]　　　==>(a[1][]+a[1][])/a[1][2]*a[1][3]=E

　　　　　　a[2][] a[2][] a[2][2] a[2][3]　　　==>(a[2][]+a[2][])/a[2][2]*a[2][3]=F

　　　　　　此时{A,B,C,...}=={D,E,F,...}说明(a+b)/c*d和(b+a)/c*d是同样的表达式，那么不输出即可。

　　代码如下

 #include <bits/stdc++.h>

 using namespace std;

 const int base=;

 int    n,a[],vec[],tar,trw=,Cnt;
 int    test[][],testb[][];
 bool    visited[];

 const char op_list[]={'+','-','*','/'};

 struct T
 {
     double    aa,bb;
     bool    operator<(const T temp)const
     {
         if(fabs(aa-temp.aa)>1e-) return aa<temp.aa;
         if(fabs(bb-temp.bb)>1e-) return bb<temp.bb;
         return false;
     }
 };

 struct Expr
 {
     string str;
     char op;
     Expr(){op=' ';}
 };

 vector<int>    op[];
 map<T,bool> Map;

 void    Init_random_list()
 {
     srand(time());
     for(int j=;j<;++j) for(int i=;i<n;++i) test[i][j]=rand()%(base*);
     for(int i=;i<n;++i) for(int j=i+;j<n;++j)
     if(a[i]==a[j]) for(int k=;k<;++k) test[j][k]=test[i][k];
     return ;
 }
 double    C()
 {
     stack<double>    S;
     stack<double>    r[];
     for(int i=;i<n;++i)
     {
         S.push(vec[i]);
         for(int j=;j<(int)op[i].size();++j)
         {
             double t1=S.top(); S.pop();
             double t2=S.top(); S.pop();
             if(op[i][j]==) S.push(t2+t1);
             if(op[i][j]==) S.push(t2-t1);
             if(op[i][j]==) S.push(t2*t1);
             if(op[i][j]==) S.push(t2/t1);
         }
     }
     if(fabs(S.top()-(double)tar)<1e-)
     {
         for(int i=;i<n;++i)
         {
             for(int k=;k<;++k)
             {
                 r[k].push(testb[i][k]);
                 for(int j=;j<(int)op[i].size();++j)
                 {
                     double t1=r[k].top(); r[k].pop();
                     double t2=r[k].top(); r[k].pop();
                     if(op[i][j]==) r[k].push(t2+t1);
                     if(op[i][j]==) r[k].push(t2-t1);
                     if(op[i][j]==) r[k].push(t2*t1);
                     if(op[i][j]==) r[k].push(t2/t1);
                 }
             }
         }
         T temp=(T){r[].top(),r[].top()};
         if(Map[temp])return -1e100;
         Map[temp]=true;
     }
     return S.top();
 }

 void    Pr()
 {
     Cnt++;

     Expr temp;
     stack<Expr> S;

     for(int i=;i<n;++i)
     {
         char temp_str[];
         sprintf(temp_str,"%d",vec[i]);
         temp.str=temp_str;
         temp.op=' ';

         S.push(temp);
         for(int j=;j<(int)op[i].size();++j)
         {
             Expr t1,t2;
             t2=S.top(); S.pop();
             t1=S.top(); S.pop();
             if(op[i][j]> && (t1.op=='+' || t1.op=='-' || t2.op=='+' || t2.op=='-'))
             {
                 if(t1.op=='+' || t1.op=='-') t1.str=" ( "+t1.str+" ) ";
                 if(t2.op=='+' || t2.op=='-') t2.str=" ( "+t2.str+" ) ";
                 temp.str=t1.str+' '+op_list[op[i][j]]+' '+t2.str;
                 temp.op=op_list[op[i][j]];
             }
             else temp.str=t1.str+' '+op_list[op[i][j]]+' '+t2.str,
                 temp.op=op_list[op[i][j]];
             S.push(temp);
         }
     }
     printf("%s\n",S.top().str.c_str());
     return ;
 }

 /* Violent enumeration operator */
 void    Calc(const int step,const int pos,const int lim)
 {
     if(step==n-)
     {
         if(fabs(C()-(double)tar)<1e-)
         {
             Pr();
             if(Cnt==trw)throw ;
         }
         return ;
     }
     for(int i=max(pos,step+);i<n;++i)
     {
         for(int j=;j<=lim;++j)
         {
             op[i].push_back(j);
             if(step+<=i) Calc(step+,i,lim);
             op[i].pop_back();
         }
     }
     return ;
 }

 /* Violent enumeration Permutations */
 void    Dfs(const int step,const int lim)
 {
     if(step==n)
     {
         try{Calc(,,lim);}
         catch(...){throw ;}
         return ;
     }
     for(int i=;i<n;++i)
     {
         if(!visited[i])
         {
             visited[i]=true;
             vec[step]=a[i];
             for(int j=;j<;++j)
                 testb[step][j]=test[i][j];
             Dfs(step+,lim);
             visited[i]=false;
         }
     }
     return ;
 }

 int main()
 {
     printf("Size of Input:\t"); scanf("%d",&n);
     printf("Target Result:\t"); scanf("%d",&tar);
     printf("Result limits(0 for no limits):  "); scanf("%d",&trw);

     printf("Input(32bits integers):\n");
     for(int i=;i<n;++i) scanf("%d",&a[i]);

     clock_t start_time=clock();
     Init_random_list();

     printf("========================\n");
     //这里会优先选择没有乘除的方案
     //try{Dfs(0,0);}catch(...){}
     //try{Dfs(0,1);}catch(...){}
     //try{Dfs(0,2);}catch(...){}
     try{Dfs(,);}catch(...){}
     printf("========================\n");

     printf("%d Results Found!\n",Cnt);
     printf("%ldms Cost!\n",clock()-start_time);
     return ;
 }