24点算法实现

1. #include <fstream>
2. #include <algorithm>
3. #include <string>
4. #include <sstream>
5. #include <list>
6. #include <cmath>
7. #include <climits>
8. #include <bitset>
9. using namespace std;
11. const char* INPUT_FILE  = "game.in";
12. const char* OUTPUT_FILE = "game.out";
13. const int NUMBER_COUNT  = 6;
14. const int STATE_COUNT   = (1 << NUMBER_COUNT);
15. const int MAX_NUMBER    = 100;
16. const int MAX_EXPECTION = 1000;
17. const int MAX_VALUE             = MAX_EXPECTION * MAX_NUMBER;
19. struct Node {
20.         int value;
21.         int left, right;        
22.         int leftvalue, rightvalue;
23.         char opr;
24. };
26. typedef list<Node> NodeList;
28. struct State {
29.         bitset<MAX_VALUE+10> exist;
30.         NodeList nodelist;
31. };
33. int number[NUMBER_COUNT], expection;
34. State state[STATE_COUNT];
36. void ReadData()
37. {
38.         ifstream fin(INPUT_FILE);
39.         
40.         for (int i = 0; i < NUMBER_COUNT; i++) {
41.                 fin >> number[i];
42.         }
43.         fin >> expection;
44. }
46. void Init()
47. {
48.         Node node ;
49.         for (int i = 0; i < NUMBER_COUNT; i++) {
50.                 node.value              = number[i];
51.                 node.left = node.right = -1;
52.                 state[(1 << i)].nodelist.push_back(node);
53.                 state[(1 << i)].exist[node.value] = true;
54.         }
55. }
57. void Merge(int a, int b, int x)
58. {      
59.         Node node;      
60.         NodeList::const_iterator i, j;
62.         for (i = state[a].nodelist.begin(); i != state[a].nodelist.end();
63. i++) {
64.                 for (j = state[b].nodelist.begin(); j != state[b].nodelist.en
66. d(); j++)
67. {                                      
68.                         node.value = (*i).value + (*j).value;
69.                         node.left  = a;
70.                         node.right = b;                 
71.                         node.leftvalue  = (*i).value;
72.                         node.rightvalue = (*j).value;
73.                         node.opr   = '+';
74.                         if ( (node.value <= MAX_VALUE) && (!state[x].exist[no
76. de.value]) ) {
77.                                 state[x].nodelist.push_back(node);
78.                                 state[x].exist[node.value] = true;
79.                         }
81.                         /
83.                         double tmp = double((*i).value) * double((*j).value);
85.                         if (tmp < INT_MAX) {
86.                                 node.value = (*i).value * (*j).value;
87.                                 node.left  = a;
88.                                 node.right = b;
89.                                 node.leftvalue  = (*i).value;
90.                                 node.rightvalue = (*j).value;
91.                                 node.opr   = '*';
92.                                 if ( (node.value <= MAX_VALUE) && (!state[x].
94. exist[node.value]) )
95. {
96.                                         state[x].nodelist.push_back(node);
97.                                         state[x].exist[node.value] = true;
98.                                 }
99.                         }
101.                         /
103.                         if ((*i).value >= (*j).value) {
104.                                 node.value = (*i).value - (*j).value;
105.                                 node.left  = a;
106.                                 node.right = b;
107.                                 node.leftvalue  = (*i).value;
108.                                 node.rightvalue = (*j).value;
109.                                 node.opr   = '-';
110.                         } else {
111.                                 node.value = (*j).value - (*i).value;
112.                                 node.left  = b;
113.                                 node.right = a;
114.                                 node.leftvalue  = (*j).value;
115.                                 node.rightvalue = (*i).value;
116.                                 node.opr   = '-';
117.                         }
118.                                                 
119.                         if ( (node.value <= MAX_VALUE) && (!state[x].exist[no
121. de.value]) ) {
122.                                 state[x].nodelist.push_back(node);
123.                                 state[x].exist[node.value] = true;
124.                         }
126.                         /
129.                         if ( ((*j).value != 0) && ((*i).value >= (*j).value) &
130. &
131.                                         ((*i).value % (*j).value == 0) )
132.                         {
133.                                 node.value = (*i).value / (*j).value;
134.                                 node.left  = a;
135.                                 node.right = b;         
136.                                 node.leftvalue  = (*i).value;
137.                                 node.rightvalue = (*j).value;
138.                                 node.opr   = '/';
139.                         } else if ( ((*i).value != 0) && ((*j).value >= (*i).
141. value) &&
142.                                         ((*j).value % (*i).value == 0) )
143.                         {
144.                                 node.value = (*j).value / (*i).value;
145.                                 node.left  = b;
146.                                 node.right = a;
147.                                 node.leftvalue  = (*j).value;
148.                                 node.rightvalue = (*i).value;
149.                                 node.opr   = '/';
150.                         }
151.                                                 
152.                         if ( (node.value <= MAX_VALUE) && (!state[x].exist[no
154. de.value]) )
155. {                              
156.                                 state[x].nodelist.push_back(node);
157.                                 state[x].exist[node.value] = true;
158.                         }                       
159.                         /
161.                 }
162.         }
163. }
165. void Solve()
166. {
167.         Init();
168.         
169.         for (int x = 2; x < STATE_COUNT; x++) {
170.                 for (int i = 1; i < x; i++) {                  
171.                         if ( (x & i) == i ) {
172.                                 int j = x - i;
173.                                 if (i <= j) {
174.                                         Merge(i, j, x);         
175.                                 }
176.                         }
177.                 }
178.         }
179. }
181. void PrintExpression(ostream& out, Node node)
182. {
183.         if (node.left == -1) {
184.                 out << node.value;
185.         } else {
186.                 NodeList::const_iterator iter;
187.                
188.                 out << "(";
190.                 for (iter = state[node.left].nodelist.begin();
191.                                 iter != state[node.left].nodelist.end();
192.                                 iter++)
193.                 {
194.                         if ((*iter).value == node.leftvalue) {
195.                                 PrintExpression(out, *iter);
196.                                 break;
197.                         }
198.                 }
200.                 out << node.opr;
202.                 for (iter = state[node.right].nodelist.begin();
203.                                 iter != state[node.right].nodelist.end();
204.                                 iter++)
205.                 {
206.                         if ((*iter).value == node.rightvalue) {
207.                                 PrintExpression(out, *iter);
208.                                 break;
209.                         }
210.                 }
212.                 out << ")";
213.         }               
214. }
216. void Output()
217. {
218.         ofstream fout(OUTPUT_FILE);
220.         int bestValue = -INT_MAX;      
221.         NodeList::const_iterator iter, bestIter;
223.         NodeList& nodelist = state[STATE_COUNT-1].nodelist;
225.         for (iter = nodelist.begin(); iter != nodelist.end(); iter++)
226.         {      
227.                 if ( ((*iter).value <= expection) && (bestValue < (*iter).val
229. ue) ) {
230.                         bestValue = (*iter).value;
231.                         bestIter  = iter;
232.                 }
233.         }      
234.         fout << bestValue << endl;
235.         PrintExpression(fout, *bestIter );
236.         fout << endl;
237. }
239. int main()
240. {
241.         ReadData();
242.         Solve();
243.         Output();
244.         return 0;
245. }