[关闭]
@songpfei 2016-01-05T22:54:09.000000Z 字数 20494 阅读 1933

24点游戏问题

OJ_算法

1. 题目描述

问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利
输入：4个1-10的数字。[数字允许重复，测试用例保证无异常数字]
输出：True or False

2. 问题求解（穷举法）

  利用穷举法，列出所有可能的表达式，然后计算表达式的值，问题便求解。
此问题可以分解为两步：
1. 列出所有可能的表达式
2. 计算法表达式（四则混合运算）的值

2.1 列出所有可能的表达式

表达式由输出的四个数字（1~10）、3个加减乘除（“+”、“-”、“*”、“/"）运算符以及括号组成。
分析所有组合（情况数）：
1. 四个数字的所有排序：4*3*2=24
2. 四个数字中间的运算符的所有排列（由于运算符可以重复）：4*4*4=64；
3. 添加括号分为以下三种情况：eg:a+b*c-d

类型 实例 数量(种）
无括号 a+b*c-d 1
1个括号 (a+b)*c-d;a+(b*c)-d;a+b*(c-d);(a+b*c)-d;a+(b*c-d); 5
2个括号 （a+b)*(c-d) 1

注：2个括号的其他类型通过去括号转化为一个括号类型

综上所述：所有表达式的排列为：24*64*（1+5+1）=10752（其中可能有重复）
代码实现：

  1. //1.全排列：用递归的思想求出全排列
  3. void swap(int &a, int &b)//交换连个元素
  4. {
  5.     int tem;
  6.     tem = a;
  7.     a = b;
  8.     b = tem;
  9. }
  10. //计算所有操作数的全排列
  11. void CalAllPermutation(int *a, int first, int length, vector<vector<string>>&permutation)
  12. {
  13.     if (first == length - 1)//如果递归到深层时，到最后交换的元素即时最后一个元素时就打印出来
  14.     {
  15.         vector<string> permu(length);
  16.         char itoa_buffer[64];
  17.         for (int i = 0; i < length; i++)
  18.         {
  19.             sprintf(itoa_buffer, "%d", a[i]);
  20.             permu[i] = string(itoa_buffer);
  21.         }
  22.         permutation.push_back(permu);
  23.     }
  24.     else
  25.     {
  26.         for (int i = first; i < length; i++)
  27.         {//循环遍历使得当前位置后边的每一个元素都和当前深度的第一个元素交换一次
  28.             swap(a[first], a[i]);//使得与第一个元素交换
  29.             CalAllPermutation(a, first + 1, length, permutation);//深入递归，此时已确定前边的元素，处理后边子序列的全排列形式。
  30.             swap(a[first], a[i]);//恢复交换之前的状态
  31.         }
  32.     }
  33. }
  34. //计算所有运算符的组合
  35. void CalOpSymbolCombination(string&sym, int ope_bit, int n, vector<string>&symbol)
  36. {
  37.     if (ope_bit == n)
  38.     {
  39.         symbol.push_back(sym);
  40.         return;
  41.     }
  43.     for (int i = 0; i < 4; i++)
  44.     {
  45.         switch (i)
  46.         {
  47.         case 0:
  48.             sym[ope_bit] = '+';
  49.             break;
  50.         case 1:
  51.             sym[ope_bit] = '-';
  52.             break;
  53.         case 2:
  54.             sym[ope_bit] = '*';
  55.             break;
  56.         case 3:
  57.             sym[ope_bit] = '/';
  58.             break;
  59.         default:
  60.             break;
  61.         }
  63.         CalOpSymbolCombination(sym, ope_bit + 1, n, symbol);
  64.     }
  66. }

2.2. 计算法表达式（四则混合运算）的值

2.2.1将中缀表达式变为后缀表达式

我们把平时所用的标准四则运算表达式，即“9+(3-1)×3+10÷2”叫做中缀表达式。因为所有的运算符号都在两数字的中间。

  中缀表达式 “9+(3-1)×3+10÷2” 转化为后缀表达式 “9 3 1 - 3 * + 10 2 / +” 。

规则：中缀表达式转后缀表达式的方法：
1.遇到操作数：直接输出（添加到后缀表达式中）
2.栈为空时，遇到运算符，直接入栈
3.遇到左括号：将其入栈
4.遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
5.遇到其他运算符：加减乘除：弹出所有优先级大于或者等于该运算符的栈顶元素，然后将该运算符入栈
6.最终将栈中的元素依次出栈，输出。。
代码实现（中缀表达式转后缀表达式）：

  1. // 2. 中缀表达式变后缀表达式并计算值
  2. static char symbolPriority[4][4] = {
  3. /* 符号优先级表 /*  '+'  '-'  '*'  '/' */
  4.        /*  '+'  */{ '=', '=', '<', '<',},
  5.        /*  '-'  */{ '=', '=', '<', '<',},
  6.        /*  '*'  */{ '>', '>', '=', '=',},
  7.        /*  '/'  */{ '>', '>', '=', '=' } };
  9. vector<string> InfixToPostfixExpression(const string &infixExpression)
  10. {
  11.     size_t i = 0;
  12.     vector<string> suffix_expression;
  13.     stack<char> symbol_stack;//符号栈
  14.     char ch = infixExpression[i++];
  16.     while (i <= infixExpression.size())
  17.     {
  18.         if (isdigit(ch))//1.遇到数字，直接输出
  19.         {
  20.             string digit;
  21.             while (isdigit(ch))
  22.             {
  23.                 digit.push_back(ch);
  24.                 ch = infixExpression[i++];
  25.             }
  26.             suffix_expression.push_back(digit);
  27.         }
  28.         else
  29.         {
  30.             if (symbol_stack.empty()||ch=='('||symbol_stack.top()=='(')//2.遇到符号：栈为空或符号为'('或栈顶为‘(',符号直接入栈
  31.             {
  32.                 symbol_stack.push(ch);
  33.                 ch = infixExpression[i++];
  34.             }
  35.             else if (ch == ')')//3. 遇到右括号，弹出所有栈中符号直到左括号并输出（左括号不输出）
  36.             {
  37.                 while (symbol_stack.top()!='(')
  38.                 {
  39.                     string a(1, '#');
  40.                     a[0] = symbol_stack.top();
  41.                     symbol_stack.pop();
  42.                     suffix_expression.push_back(a);
  43.                 }
  44.                 symbol_stack.pop();//弹出左括号，不输出
  45.                 ch = infixExpression[i++];
  46.             }
  47.             else
  48.             {
  49.                 while (!symbol_stack.empty())
  50.                 {
  51.                     char sym_priority = CompareSymbolPriorityPost(symbol_stack.top(), ch);
  52.                     if (sym_priority == '>' || sym_priority == '=')//4.弹出优先级大于等于ch的所有符号
  53.                     {
  54.                         string a(1, '#');
  55.                         a[0] = symbol_stack.top();
  56.                         symbol_stack.pop();
  57.                         suffix_expression.push_back(a);
  58.                     }
  59.                     else
  60.                         break;
  61.                 }
  63.                 symbol_stack.push(ch);//压入符号
  64.                 ch = infixExpression[i++];
  65.             }
  66.         }
  67.     }
  68.     while (!symbol_stack.empty())
  69.     {
  70.         string a(1, '#');
  71.         a[0] = symbol_stack.top();
  72.         symbol_stack.pop();
  73.         suffix_expression.push_back(a);
  74.     }
  75.     return suffix_expression;
  76. }
  78. char CompareSymbolPriorityPost(char sym1, char sym2)//中缀变后缀比较符号优先级
  79. {
  80.     int index1 = IndexOfSymbol(sym1);
  81.     int index2 = IndexOfSymbol(sym2);
  82.     return symbolPriority[index1][index2];
  83. }
  84. int IndexOfSymbol(char sym)//符号优先级索引
  85. {
  86.     int index;
  87.     switch (sym)
  88.     {
  89.     case '+':
  90.         index = 0;
  91.         break;
  92.     case '-':
  93.         index = 1;
  94.         break;
  95.     case '*':
  96.         index = 2;
  97.         break;
  98.     case '/':
  99.         index = 3;
  100.         break;
  101.     case '(':
  102.         index = 4;
  103.         break;
  104.     case ')':
  105.         index = 5;
  106.         break;
  107.     case '=':
  108.         index = 6;
  109.         break;
  110.     default:
  111.         break;
  112.     }
  113.     return index;
  114. }

直接计算中缀表达是的值：

  1. //运算符的优先关系比对表        
  2. static char SymbolRelation[7][7] = {
  3.     //'+', '-', '*', '/', '(', ')', '=' //运算符2
  4.     { '>', '>', '<', '<', '<', '>', '>' }, //'+'   //运算符1    
  5.     { '>', '>', '<', '<', '<', '>', '>' }, //'-'     
  6.     { '>', '>', '>', '>', '<', '>', '>' }, //'*'     
  7.     { '>', '>', '>', '>', '<', '>', '>' }, //'/'     
  8.     { '<', '<', '<', '<', '<', '=', '>' }, //'('     
  9.     { '>', '>', '>', '>', '=', '>', '>' }, //')'     
  10.     { '<', '<', '<', '<', '<', ' ', '=' } };//'='
  12. double CalResultBySuffixExpression(string &infixExpresion)
  13. {
  14.     stack<char> symbol_stack;//符号栈
  15.     stack<double> suffix_expression;//后缀表达式
  16.     char ch;
  17.     int i = 0;
  18.     infixExpresion += '=';
  19.     symbol_stack.push('=');
  20.     ch = infixExpresion[i++];
  21.     while (ch != '=' || symbol_stack.top() != '=')
  22.     {
  23.         if (isdigit(ch))//数字，直接输出
  25.         {
  26.             int ope_data = 0;
  27.             while (isdigit(ch))
  28.             {
  29.                 ope_data = 10 * ope_data + ch - '0';//将字符串操作数转化为整数
  30.                 ch = infixExpresion[i++];
  31.             }
  32.             suffix_expression.push(ope_data);
  33.         }
  34.         else
  35.         {
  36.             switch (CompareSymbolPriority(symbol_stack.top(), ch))
  37.             {
  38.             case '<'://栈顶符号优先级低：继续压入符号进栈
  39.                 symbol_stack.push(ch);
  40.                 ch = infixExpresion[i++];
  41.                 break;
  42.             case '='://括号配对：弹出栈顶括号，并丢弃该括号
  43.                 symbol_stack.pop();
  44.                 ch = infixExpresion[i++];
  45.                 break;
  46.             case '>'://栈顶优先级高
  47.                 char sym_top = symbol_stack.top();
  48.                 symbol_stack.pop();
  49.                 double num2 = suffix_expression.top();
  50.                 suffix_expression.pop();
  51.                 double num1 = suffix_expression.top();
  52.                 suffix_expression.pop();
  54.                 double sub_result = CalSubExpressionResult(num1, num2, sym_top);
  55.                 suffix_expression.push(sub_result);
  56.                 break;
  57.             }
  58.         }
  59.     }
  61.     return suffix_expression.top();//返回后缀表达式
  62. }
  64. char CompareSymbolPriority(char sym1, char sym2)//比较符号优先级，直接计算值
  65. {
  66.     int index1 = IndexOfSymbol(sym1);
  67.     int index2 = IndexOfSymbol(sym2);
  68.     return SymbolRelation[index1][index2];
  69. }
  71. int IndexOfSymbol(char sym)//符号优先级索引
  72. {
  73.     int index;
  74.     switch (sym)
  75.     {
  76.     case '+':
  77.         index = 0;
  78.         break;
  79.     case '-':
  80.         index = 1;
  81.         break;
  82.     case '*':
  83.         index = 2;
  84.         break;
  85.     case '/':
  86.         index = 3;
  87.         break;
  88.     case '(':
  89.         index = 4;
  90.         break;
  91.     case ')':
  92.         index = 5;
  93.         break;
  94.     case '=':
  95.         index = 6;
  96.         break;
  97.     default:
  98.         break;
  99.     }
  100.     return index;
  101. }
  102. double CalSubExpressionResult(double a, double b, char symbol)
  103. {
  104.     double result = 0.0;
  106.     switch (symbol)
  107.     {
  108.     case '+':
  109.         result = a + b;
  110.         break;
  111.     case '-':
  112.         result = a - b;
  113.         break;
  114.     case '*':
  115.         result = a*b;
  116.         break;
  117.     case '/':
  118.         result = a / b;
  119.         break;
  120.     default:
  121.         break;
  122.     }
  124.     return result;
  125. }

2.2.2 计算后缀表达式的值

后缀表达式计算结果

规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。(初始化一个空栈,此栈用来对要运算的数字进行使用)
代码实现：

  1. double CalSubExpressionResult(double a, double b, char symbol)
  2. {
  3.     double result = 0.0;
  5.     switch (symbol)
  6.     {
  7.     case '+':
  8.         result = a + b;
  9.         break;
  10.     case '-':
  11.         result = a - b;
  12.         break;
  13.     case '*':
  14.         result = a*b;
  15.         break;
  16.     case '/':
  17.         result = a / b;
  18.         break;
  19.     default:
  20.         break;
  21.     }
  23.     return result;
  24. }
  26. //3. 计算后缀表达式的值
  27. double CalPostfixExpressionValue(const vector<string>& postfixExpression)
  28. {
  29.   stack<double> exp_data;
  30.   for (size_t i=0;i<postfixExpression.size();i++)
  31.   {
  32.       if(isdigit(postfixExpression[i][0]))
  33.       {
  34.           double data=atof(postfixExpression[i].c_str());
  35.           exp_data.push(data);
  36.       }
  37.       else
  38.       {
  39.           double num1,num2;
  40.           num2 = exp_data.top();
  41.           exp_data.pop();
  42.           num1 = exp_data.top();
  43.           exp_data.pop();
  45.           double temp_result= CalSubExpressionResult(num1,num2,postfixExpression[i][0]);
  46.           exp_data.push(temp_result);
  47.       }
  48.   }
  50.   return exp_data.top();
  51. }

3. 24点游戏（穷举法）代码实现（全）

  1. #include"Game24Points.h"
  2. #include<cstdio>
  3. #include<cctype>
  4. #include<string>
  5. #include<vector>
  6. #include<stack>
  7. #include <iostream>
  8. using namespace std;
  9. static void swap(int &a, int &b);//交换连个元素
  10. static void CalAllPermutation(int *a, int first, int length, vector<vector<string>>&permutation);
  11. static void CalOpSymbolCombination(string&sym, int ope_bit, int n, vector<string>&symbol);
  12. static int  IndexOfSymbol(char sym);
  13. static char CompareSymbolPriority(char sym1, char sym2);//比较符号优先级
  14. static char CompareSymbolPriorityPost(char sym1, char sym2);//中缀变后缀比较符号优先级
  15. static std::vector<std::string> InfixToPostfixExpression(const std::string &infixExpression);
  16. static double CalSubExpressionResult(double a, double b, char symbol);
  17. static double CalResultBySuffixExpression(string &infixExpresion);
  18. static double CalPostfixExpressionValue(const vector<string>& postfixExpression);
  21. //运算符的优先关系比对表        
  22. static char SymbolRelation[7][7] = {
  23.     //'+', '-', '*', '/', '(', ')', '=' //运算符2
  24.     { '>', '>', '<', '<', '<', '>', '>' }, //'+'   //运算符1    
  25.     { '>', '>', '<', '<', '<', '>', '>' }, //'-'     
  26.     { '>', '>', '>', '>', '<', '>', '>' }, //'*'     
  27.     { '>', '>', '>', '>', '<', '>', '>' }, //'/'     
  28.     { '<', '<', '<', '<', '<', '=', '>' }, //'('     
  29.     { '>', '>', '>', '>', '=', '>', '>' }, //')'     
  30.     { '<', '<', '<', '<', '<', ' ', '=' } };//'='     
  32. static char symbolPriority[4][4] = {
  33. /* 符号优先级表 /*  '+'  '-'  '*'  '/' */
  34.        /*  '+'  */{ '=', '=', '<', '<',},
  35.        /*  '-'  */{ '=', '=', '<', '<',},
  36.        /*  '*'  */{ '>', '>', '=', '=',},
  37.        /*  '/'  */{ '>', '>', '=', '=' } };
  38. bool Game24Points(int a, int b, int c, int d)
  39. {
  40.     int data[4] = { a,b,c,d };
  41.     vector<vector<string>> permutation;
  42.     string sym(3, '=');
  43.     vector<string> symbol;
  44.     string infix_expression;//中缀表达式
  45.     vector<string> postfix_expression;//后缀表达式
  46.     double expression_result = 0.0;
  48.     CalAllPermutation(data, 0, 4, permutation);//计算数字输入数字的全排列
  50.     CalOpSymbolCombination(sym, 0, 3, symbol);//计算表达式中间三个符号的所有组合
  52.     for (size_t i = 0; i < permutation.size(); i++)
  53.     {
  54.         for (size_t j = 0; j<symbol.size(); j++)
  55.         {
  56.             for (size_t k = 0; k < 7; k++)//添加括号
  57.             {
  58.                 switch (k)
  59.                 {
  60.                 case 0://无括号类型
  61.                     infix_expression = permutation[i][0] + symbol[j][0] + permutation[i][1] + symbol[j][1] + permutation[i][2]
  62.                         + symbol[j][2] + permutation[i][3];
  63.                     break;
  64.                 case 1://(a+b)*c-d类型
  65.                     infix_expression = "(" + permutation[i][0] + symbol[j][0] + permutation[i][1] + ")" + symbol[j][1] + permutation[i][2]
  66.                         + symbol[j][2] + permutation[i][3];
  67.                     break;
  68.                 case 2://a+(b*c)-d类型
  69.                     infix_expression = permutation[i][0] + symbol[j][0] + "(" + permutation[i][1] + symbol[j][1] + permutation[i][2] + ")"
  70.                         + symbol[j][2] + permutation[i][3];
  71.                     break;
  72.                 case 3://a+b*(c-d)类型
  73.                     infix_expression = permutation[i][0] + symbol[j][0] + permutation[i][1] + symbol[j][1] + "(" + permutation[i][2]
  74.                         + symbol[j][2] + permutation[i][3] + ")";
  75.                     break;
  76.                 case 4://(a+b*c)-d类型
  77.                     infix_expression = "(" + permutation[i][0] + symbol[j][0] + permutation[i][1] + symbol[j][1] + permutation[i][2]
  78.                         + ")" + symbol[j][2] + permutation[i][3];
  79.                     break;
  80.                 case 5://a+(b*c-d)类型
  81.                     infix_expression = permutation[i][0] + symbol[j][0] + "(" + permutation[i][1] + symbol[j][1] + permutation[i][2]
  82.                         + symbol[j][2] + permutation[i][3] + ")";
  83.                     break;
  84.                 case 6://(a+b)*(c-d)类型
  85.                     infix_expression = "(" + permutation[i][0] + symbol[j][0] + permutation[i][1] + ")" + symbol[j][1] + "(" + permutation[i][2]
  86.                         + symbol[j][2] + permutation[i][3] + ")";
  87.                     break;
  88.                 default:
  89.                     break;
  90.                 }
  91.                 //expression_result = CalResultBySuffixExpression(infix_expression) - 24;
  92.                 postfix_expression=InfixToPostfixExpression(infix_expression);
  93.                 expression_result=CalPostfixExpressionValue(postfix_expression)-24;
  94.                 if (expression_result<0.001&&expression_result>(-0.001))
  95.                 {
  96.                     cout<<infix_expression<<endl;
  97.                     return true;
  98.                 }
  100.             }
  101.         }
  102.     }
  104.     return false;
  105. }
  107. //1.全排列：用递归的思想求出全排列
  109. void swap(int &a, int &b)//交换连个元素
  110. {
  111.     int tem;
  112.     tem = a;
  113.     a = b;
  114.     b = tem;
  115. }
  116. void CalAllPermutation(int *a, int first, int length, vector<vector<string>>&permutation)
  117. {
  118.     if (first == length - 1)//如果递归到深层时，到最后交换的元素即时最后一个元素时就打印出来
  119.     {
  120.         vector<string> permu(length);
  121.         char itoa_buffer[64];
  122.         for (int i = 0; i < length; i++)
  123.         {
  124.             sprintf(itoa_buffer, "%d", a[i]);
  125.             permu[i] = string(itoa_buffer);
  126.         }
  127.         permutation.push_back(permu);
  128.     }
  129.     else
  130.     {
  131.         for (int i = first; i < length; i++)
  132.         {//循环遍历使得当前位置后边的每一个元素都和当前深度的第一个元素交换一次
  133.             swap(a[first], a[i]);//使得与第一个元素交换
  134.             CalAllPermutation(a, first + 1, length, permutation);//深入递归，此时已确定前边的元素，处理后边子序列的全排列形式。
  135.             swap(a[first], a[i]);//恢复交换之前的状态
  136.         }
  137.     }
  138. }
  139. void CalOpSymbolCombination(string&sym, int ope_bit, int n, vector<string>&symbol)
  140. {
  141.     if (ope_bit == n)
  142.     {
  143.         symbol.push_back(sym);
  144.         return;
  145.     }
  147.     for (int i = 0; i < 4; i++)
  148.     {
  149.         switch (i)
  150.         {
  151.         case 0:
  152.             sym[ope_bit] = '+';
  153.             break;
  154.         case 1:
  155.             sym[ope_bit] = '-';
  156.             break;
  157.         case 2:
  158.             sym[ope_bit] = '*';
  159.             break;
  160.         case 3:
  161.             sym[ope_bit] = '/';
  162.             break;
  163.         default:
  164.             break;
  165.         }
  167.         CalOpSymbolCombination(sym, ope_bit + 1, n, symbol);
  168.     }
  170. }
  171. // 2. 中缀表达式变后缀表达式并计算值
  173. vector<string> InfixToPostfixExpression(const string &infixExpression)
  174. {
  175.     size_t i = 0;
  176.     vector<string> suffix_expression;
  177.     stack<char> symbol_stack;//符号栈
  178.     char ch = infixExpression[i++];
  180.     while (i <= infixExpression.size())
  181.     {
  182.         if (isdigit(ch))//1.遇到数字，直接输出
  183.         {
  184.             string digit;
  185.             while (isdigit(ch))
  186.             {
  187.                 digit.push_back(ch);
  188.                 ch = infixExpression[i++];
  189.             }
  190.             suffix_expression.push_back(digit);
  191.         }
  192.         else
  193.         {
  194.             if (symbol_stack.empty()||ch=='('||symbol_stack.top()=='(')//2.遇到符号：栈为空或符号为'('或栈顶为‘(',符号直接入栈
  195.             {
  196.                 symbol_stack.push(ch);
  197.                 ch = infixExpression[i++];
  198.             }
  199.             else if (ch == ')')//3. 遇到右括号，弹出所有栈中符号直到左括号并输出（左括号不输出）
  200.             {
  201.                 while (symbol_stack.top()!='(')
  202.                 {
  203.                     string a(1, '#');
  204.                     a[0] = symbol_stack.top();
  205.                     symbol_stack.pop();
  206.                     suffix_expression.push_back(a);
  207.                 }
  208.                 symbol_stack.pop();//弹出左括号，不输出
  209.                 ch = infixExpression[i++];
  210.             }
  211.             else
  212.             {
  213.                 while (!symbol_stack.empty())
  214.                 {
  215.                     char sym_priority = CompareSymbolPriorityPost(symbol_stack.top(), ch);
  216.                     if (sym_priority == '>' || sym_priority == '=')//4.弹出优先级大于等于ch的所有符号
  217.                     {
  218.                         string a(1, '#');
  219.                         a[0] = symbol_stack.top();
  220.                         symbol_stack.pop();
  221.                         suffix_expression.push_back(a);
  222.                     }
  223.                     else
  224.                         break;
  225.                 }
  227.                 symbol_stack.push(ch);//压入符号
  228.                 ch = infixExpression[i++];
  229.             }
  230.         }
  231.     }
  232.     while (!symbol_stack.empty())
  233.     {
  234.         string a(1, '#');
  235.         a[0] = symbol_stack.top();
  236.         symbol_stack.pop();
  237.         suffix_expression.push_back(a);
  238.     }
  239.     return suffix_expression;
  240. }
  241. //3. 计算后缀表达式的值
  242. double CalPostfixExpressionValue(const vector<string>& postfixExpression)
  243. {
  244.   stack<double> exp_data;
  245.   for (size_t i=0;i<postfixExpression.size();i++)
  246.   {
  247.       if(isdigit(postfixExpression[i][0]))
  248.       {
  249.           double data=atof(postfixExpression[i].c_str());
  250.           exp_data.push(data);
  251.       }
  252.       else
  253.       {
  254.           double num1,num2;
  255.           num2 = exp_data.top();
  256.           exp_data.pop();
  257.           num1 = exp_data.top();
  258.           exp_data.pop();
  260.           double temp_result= CalSubExpressionResult(num1,num2,postfixExpression[i][0]);
  261.           exp_data.push(temp_result);
  262.       }
  263.   }
  265.   return exp_data.top();
  266. }
  267. double CalResultBySuffixExpression(string &infixExpresion)
  268. {
  269.     stack<char> symbol_stack;//符号栈
  270.     stack<double> suffix_expression;//后缀表达式
  271.     char ch;
  272.     int i = 0;
  273.     infixExpresion += '=';
  274.     symbol_stack.push('=');
  275.     ch = infixExpresion[i++];
  276.     while (ch != '=' || symbol_stack.top() != '=')
  277.     {
  278.         if (isdigit(ch))//数字，直接输出
  280.         {
  281.             int ope_data = 0;
  282.             while (isdigit(ch))
  283.             {
  284.                 ope_data = 10 * ope_data + ch - '0';//将字符串操作数转化为整数
  285.                 ch = infixExpresion[i++];
  286.             }
  287.             suffix_expression.push(ope_data);
  288.         }
  289.         else
  290.         {
  291.             switch (CompareSymbolPriority(symbol_stack.top(), ch))
  292.             {
  293.             case '<'://栈顶符号优先级低：继续压入符号进栈
  294.                 symbol_stack.push(ch);
  295.                 ch = infixExpresion[i++];
  296.                 break;
  297.             case '='://括号配对：弹出栈顶括号，并丢弃该括号
  298.                 symbol_stack.pop();
  299.                 ch = infixExpresion[i++];
  300.                 break;
  301.             case '>'://栈顶优先级高
  302.                 char sym_top = symbol_stack.top();
  303.                 symbol_stack.pop();
  304.                 double num2 = suffix_expression.top();
  305.                 suffix_expression.pop();
  306.                 double num1 = suffix_expression.top();
  307.                 suffix_expression.pop();
  309.                 double sub_result = CalSubExpressionResult(num1, num2, sym_top);
  310.                 suffix_expression.push(sub_result);
  311.                 break;
  312.             }
  313.         }
  314.     }
  316.     return suffix_expression.top();//返回后缀表达式
  317. }
  319. char CompareSymbolPriority(char sym1, char sym2)//比较符号优先级，直接计算值
  320. {
  321.     int index1 = IndexOfSymbol(sym1);
  322.     int index2 = IndexOfSymbol(sym2);
  323.     return SymbolRelation[index1][index2];
  324. }
  326. char CompareSymbolPriorityPost(char sym1, char sym2)//中缀变后缀比较符号优先级
  327. {
  328.     int index1 = IndexOfSymbol(sym1);
  329.     int index2 = IndexOfSymbol(sym2);
  330.     return symbolPriority[index1][index2];
  331. }
  332. int IndexOfSymbol(char sym)//符号优先级索引
  333. {
  334.     int index;
  335.     switch (sym)
  336.     {
  337.     case '+':
  338.         index = 0;
  339.         break;
  340.     case '-':
  341.         index = 1;
  342.         break;
  343.     case '*':
  344.         index = 2;
  345.         break;
  346.     case '/':
  347.         index = 3;
  348.         break;
  349.     case '(':
  350.         index = 4;
  351.         break;
  352.     case ')':
  353.         index = 5;
  354.         break;
  355.     case '=':
  356.         index = 6;
  357.         break;
  358.     default:
  359.         break;
  360.     }
  361.     return index;
  362. }
  363. double CalSubExpressionResult(double a, double b, char symbol)
  364. {
  365.     double result = 0.0;
  367.     switch (symbol)
  368.     {
  369.     case '+':
  370.         result = a + b;
  371.         break;
  372.     case '-':
  373.         result = a - b;
  374.         break;
  375.     case '*':
  376.         result = a*b;
  377.         break;
  378.     case '/':
  379.         result = a / b;
  380.         break;
  381.     default:
  382.         break;
  383.     }
  385.     return result;
  386. }

main 函数

  3. #include <iostream>
  4. #include"Game24Points.h"
  5. using namespace std;
  8. int main()
  9. {
  10.     int a,b,c,d;
  12.     do 
  13.     {
  14.         cin>>a>>b>>c>>d;
  15.         if(!Game24Points(a,b,c,d))
  16.         {
  17.             cout<<"No Answer"<<endl;
  18.         }
  19.     } while (1);
  20.     system("pause");
  21.     return 0;
  22. }

24点游戏问题优化解：

  1. /******************************************************************************
  3. Copyright (C), 2001-2013, Huawei Tech. Co., Ltd.
  5. ******************************************************************************
  6. File Name     :
  7. Version       :
  8. Author        :
  9. Created       : 2013/03/12
  10. Last Modified :
  11. Description   :
  12. Function List :
  14. History       :
  15. 1.Date        : 2013/03/12
  16. Author      :
  17. Modification: Created file
  19. ******************************************************************************/
  20. #include"OJ.h"
  21. #include<string>
  22. #include<vector>
  23. #include<stack>
  24. #include <iostream>
  25. #include<algorithm>
  26. #include<sstream>
  27. using namespace std;
  28. void CalOpSymbolSet(char(*symbol_set)[3]);
  29. static int  IndexOfSymbol(char sym);
  30. static char CompareSymbolPriority(char sym1, char sym2);//比较符号优先级
  31. static void PopSymbolToPostfixExpression(stack<char> &symbol_stack, vector<string> &postfix_expression);
  32. static vector<string> InfixToPostfixExpression(const string &infix_expression);
  33. static string int_to_string(const int n);//int to string
  34. static double CalSubExpressionResult(double a, double b, char symbol);
  35. static double CalPostfixExpressionValue(const vector<string>& postfix_expression);
  38. //运算符的优先关系比对表        
  39. static char symbol_priority[4][4] = {
  40. /* 符号优先级表 /*  '+'  '-'  '*'  '/' */
  41.        /*  '+'  */{ '=', '=', '<', '<',},
  42.        /*  '-'  */{ '=', '=', '<', '<',},
  43.        /*  '*'  */{ '>', '>', '=', '=',},
  44.        /*  '/'  */{ '>', '>', '=', '=' } };
  47. bool Game24Points(int a, int b, int c, int d)
  48. {
  49.     int num_array[4] = { a,b,c,d };
  50.     char symbol_set[64][3];//运算符号组合
  51.     string infix_expression;//中缀表达式
  52.     vector<string> postfix_expression;//后缀表达式
  53.     double expression_result = 0.0;
  55.     //1. 计算符号组合
  56.     int count = 0;
  57.     CalOpSymbolSet(symbol_set);
  59.     //2.计算输入数字的字典序排列
  60.     sort(num_array, num_array + 4);
  61.     do
  62.     {
  63.         for (int i = 0; i < 64; i++)
  64.             for (int j = 0; j < 7; j++)
  65.             {
  66.                 switch (j)
  67.                 {
  68.                 case 0://无括号类型
  69.                     infix_expression = int_to_string(num_array[0]) + symbol_set[i][0] + int_to_string(num_array[1]) + symbol_set[i][1] + int_to_string(num_array[2])
  70.                         + symbol_set[i][2] + int_to_string(num_array[3]);
  71.                     break;
  72.                 case 1://(a+b)*c-d类型
  73.                     infix_expression = "(" + int_to_string(num_array[0]) + symbol_set[i][0] + int_to_string(num_array[1]) + ")" + symbol_set[i][1] + int_to_string(num_array[2])
  74.                         + symbol_set[i][2] + int_to_string(num_array[3]);
  75.                     break;
  76.                 case 2://a+(b*c)-d类型
  77.                     infix_expression = int_to_string(num_array[0]) + symbol_set[i][0] + "(" + int_to_string(num_array[1]) + symbol_set[i][1] + int_to_string(num_array[2]) + ")"
  78.                         + symbol_set[i][2] + int_to_string(num_array[3]);
  79.                     break;
  80.                 case 3://a+b*(c-d)类型
  81.                     infix_expression = int_to_string(num_array[0]) + symbol_set[i][0] + int_to_string(num_array[1]) + symbol_set[i][1] + "(" + int_to_string(num_array[2])
  82.                         + symbol_set[i][2] + int_to_string(num_array[3]) + ")";
  83.                     break;
  84.                 case 4://(a+b*c)-d类型
  85.                     infix_expression = "(" + int_to_string(num_array[0]) + symbol_set[i][0] + int_to_string(num_array[1]) + symbol_set[i][1] + int_to_string(num_array[2])
  86.                         + ")" + symbol_set[i][2] + int_to_string(num_array[3]);
  87.                     break;
  88.                 case 5://a+(b*c-d)类型
  89.                     infix_expression = int_to_string(num_array[0]) + symbol_set[i][0] + "(" + int_to_string(num_array[1]) + symbol_set[i][1] + int_to_string(num_array[2])
  90.                         + symbol_set[i][2] + int_to_string(num_array[3]) + ")";
  91.                     break;
  92.                 case 6://(a+b)*(c-d)类型
  93.                     infix_expression = "(" + int_to_string(num_array[0]) + symbol_set[i][0] + int_to_string(num_array[1]) + ")" + symbol_set[i][1] + "(" + int_to_string(num_array[2])
  94.                         + symbol_set[i][2] + int_to_string(num_array[3]) + ")";
  95.                     break;
  96.                 default:
  97.                     break;
  98.                 }
  99.                 postfix_expression = InfixToPostfixExpression(infix_expression);
  100.                 expression_result=CalPostfixExpressionValue(postfix_expression)-24;
  101.                 if (expression_result<0.001&&expression_result>(-0.001))
  102.                 {
  103.                     cout<<infix_expression<<endl;
  104.                     return true;
  105.                 }
  107.             }
  109.     } while (next_permutation(num_array, num_array + 4));//求下一个字典序排列
  111.     return false;
  112. }
  113. string int_to_string(const int n)
  114. {
  115.     ostringstream oss;//创建一个流
  117.     oss << n;//把值传递如流中
  119.     return oss.str();//返回转换后的字符串
  120. }
  121. //1. 计算符号组合
  122. void CalOpSymbolSet(char(*symbol_set)[3])//计算运算符组合(‘+’、‘-’、‘*’、‘/')
  123. {
  124.     char sym[4] = { '+','-','*','/' };
  125.     for (int i = 0; i < 4; i++)
  126.         for (int j = 0; j < 4;j++)
  127.             for (int k = 0; k < 4; k++)
  128.             {
  129.                 (*symbol_set)[0] = sym[i];
  130.                 (*symbol_set)[1] = sym[j];
  131.                 (*symbol_set)[2] = sym[k];
  132.                  ++symbol_set;
  133.             }
  134. }
  136. //3. 中缀表达式变后缀表达式并计算值
  137. vector<string> InfixToPostfixExpression(const string &infix_expression)
  138. {
  139.     size_t i = 0;
  140.     vector<string> postfix_expression;
  141.     stack<char> symbol_stack;//符号栈
  142.     char ch = infix_expression[i++];
  144.     while (i <= infix_expression.size())
  145.     {
  146.         if (isdigit(ch))//1.遇到数字，直接输出
  147.         {
  148.             string digit;
  149.             while (isdigit(ch))
  150.             {
  151.                 digit.push_back(ch);
  152.                 ch = infix_expression[i++];
  153.             }
  154.             postfix_expression.push_back(digit);
  155.         }
  156.         else
  157.         {
  158.             if (symbol_stack.empty()||ch=='('||symbol_stack.top()=='(')//2.遇到符号：栈为空或符号为'('或栈顶为‘(',符号直接入栈
  159.             {
  160.                 symbol_stack.push(ch);
  161.                 ch = infix_expression[i++];
  162.             }
  163.             else if (ch == ')')//3. 遇到右括号，弹出所有栈中符号直到左括号并输出（左括号不输出）
  164.             {
  165.                 while (symbol_stack.top()!='(')
  166.                 {
  167.                     PopSymbolToPostfixExpression(symbol_stack, postfix_expression);
  168.                 }
  169.                 symbol_stack.pop();//弹出左括号，不输出
  170.                 ch = infix_expression[i++];
  171.             }
  172.             else
  173.             {
  174.                 while (!symbol_stack.empty())
  175.                 {
  176.                     char sym_priority = CompareSymbolPriority(symbol_stack.top(), ch);
  177.                     if (sym_priority == '>' || sym_priority == '=')//4.弹出优先级大于等于ch的所有符号
  178.                         PopSymbolToPostfixExpression(symbol_stack, postfix_expression);
  179.                     else
  180.                         break;
  181.                 }
  183.                 symbol_stack.push(ch);//压入符号
  184.                 ch = infix_expression[i++];
  185.             }
  186.         }
  187.     }
  188.     while (!symbol_stack.empty())//弹出栈中剩余符号
  189.     {
  190.         PopSymbolToPostfixExpression(symbol_stack, postfix_expression);
  191.     }
  192.     return postfix_expression;
  193. }
  195. //弹出栈中符号并输出到后缀表达式
  196. void PopSymbolToPostfixExpression(stack<char> &symbol_stack, vector<string> &postfix_expression)
  197. {
  198.     if (symbol_stack.empty())
  199.         return;
  201.     string a(1, '#');
  202.     a[0] = symbol_stack.top();
  203.     symbol_stack.pop();
  204.     postfix_expression.push_back(a);
  205. }
  206. //3. 计算后缀表达式的值
  207. double CalPostfixExpressionValue(const vector<string>& postfix_expression)
  208. {
  209.   stack<double> exp_data;
  211.   for (size_t i=0;i<postfix_expression.size();i++)
  212.   {
  213.       if(isdigit(postfix_expression[i][0]))
  214.       {
  215.           double data = atof(postfix_expression[i].c_str());
  216.           exp_data.push(data);
  217.       }
  218.       else
  219.       {
  220.           double num1,num2;
  221.           num2 = exp_data.top();
  222.           exp_data.pop();
  223.           num1 = exp_data.top();
  224.           exp_data.pop();
  226.           double temp_result= CalSubExpressionResult(num1,num2,postfix_expression[i][0]);
  227.           exp_data.push(temp_result);
  228.       }
  229.   }
  231.   return exp_data.top();
  232. }
  235. char CompareSymbolPriority(char sym1, char sym2)//中缀变后缀比较符号优先级
  236. {
  237.     int index1 = IndexOfSymbol(sym1);
  238.     int index2 = IndexOfSymbol(sym2);
  239.     return symbol_priority[index1][index2];
  240. }
  241. int IndexOfSymbol(char sym)//符号优先级索引
  242. {
  243.     int index;
  244.     switch (sym)
  245.     {
  246.     case '+':
  247.         index = 0;
  248.         break;
  249.     case '-':
  250.         index = 1;
  251.         break;
  252.     case '*':
  253.         index = 2;
  254.         break;
  255.     case '/':
  256.         index = 3;
  257.         break;
  258.     case '(':
  259.         index = 4;
  260.         break;
  261.     case ')':
  262.         index = 5;
  263.         break;
  264.     case '=':
  265.         index = 6;
  266.         break;
  267.     default:
  268.         break;
  269.     }
  270.     return index;
  271. }
  272. double CalSubExpressionResult(double a, double b, char symbol)
  273. {
  274.     double result = 0.0;
  276.     switch (symbol)
  277.     {
  278.     case '+':
  279.         result = a + b;
  280.         break;
  281.     case '-':
  282.         result = a - b;
  283.         break;
  284.     case '*':
  285.         result = a*b;
  286.         break;
  287.     case '/':
  288.         result = a / b;
  289.         break;
  290.     default:
  291.         break;
  292.     }
  294.     return result;
  295. }

参考：
计算表达式值：http://www.cnblogs.com/heyonggang/p/3359565.html
中缀表达式、后缀表达式：
1. http://www.cnblogs.com/heyonggang/p/3359565.html
2. http://www.cnblogs.com/mygmh/archive/2012/10/06/2713362.html
3. http://blog.csdn.net/girlkoo/article/details/17435717
4. http://www.acmerblog.com/infix-to-postfix-6072.html
24点游戏，集合解法：http://www.cnblogs.com/Quincy/archive/2012/03/26/2418546.html

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注