UVa Problem Solution: 10149 - Yahtzee

I'm stuck by this problem for two days. Finally I searched for some hints and came to this solution.
The key points to solve this problem are:
  1) using bitmap to record all the possible combinations, and
  2) using DP to handle the bonus.   

Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 10149 C++ "Yahtzee" */
8. #include <iostream>
9. #include <fstream>
10. #include <string>
11. #include <vector>
12. #include <algorithm>
13. #include <limits>
15. using namespace std;
17. int const ncategories = 13;
18. int const nrounds = 13;
19. int const ndices = 5;
20. int const ncombinations = 8192; /* 1 << 13 + 1 */
21. int const nupper = 64; /* 63 + 1 */
22. int nmapped[ncombinations];
24. int ones(int dices[]) 
25. {
26.   int score = 0;
27.   for (int i = 0; i < ndices; ++i) {
28.     if (dices[i] == 1) {
29.       score += 1;
30.     }
31.   }
32.   return score;
33. }
35. int twos(int dices[]) 
36. {
37.   int score = 0;
38.   for (int i = 0; i < ndices; ++i) {
39.     if (dices[i] == 2) {
40.       score += 2;
41.     }
42.   }
43.   return score;
44. }
46. int threes(int dices[]) 
47. {
48.   int score = 0;
49.   for (int i = 0; i < ndices; ++i) {
50.     if (dices[i] == 3) {
51.       score += 3;
52.     }
53.   }
54.   return score;
55. }
57. int fours(int dices[]) 
58. {
59.   int score = 0;
60.   for (int i = 0; i < ndices; ++i) {
61.     if (dices[i] == 4) {
62.       score += 4;
63.     }
64.   }
65.   return score;
66. }
68. int fives(int dices[]) 
69. {
70.   int score = 0;
71.   for (int i = 0; i < ndices; ++i) {
72.     if (dices[i] == 5) {
73.       score += 5;
74.     }
75.   }
76.   return score;
77. }
79. int sixes(int dices[]) 
80. {
81.   int score = 0;
82.   for (int i = 0; i < ndices; ++i) {
83.     if (dices[i] == 6) {
84.       score += 6;
85.     }
86.   }
87.   return score;
88. }
90. int chance(int dices[]) 
91. {
92.   int score = 0;
93.   for (int i = 0; i < ndices; ++i) {
94.     score += dices[i];
95.   }
96.   return score;
97. }
99. int three_kind(int dices[]) 
100. {
101.   int score = 0;
102.   if (dices[0] == dices[2] || 
103.       dices[1] == dices[3] || 
104.       dices[2] == dices[4]) {
105.     for (int i = 0; i < ndices; ++i) {
106.       score += dices[i];
107.     }
108.   }
109.   return score;
110. }
112. int four_kind(int dices[]) 
113. {
114.   int score = 0;
115.   if (dices[0] == dices[3] || 
116.       dices[1] == dices[4]) {
117.     for (int i = 0; i < ndices; ++i) {
118.       score += dices[i];
119.     }
120.   }
121.   return score;
122. }
124. int five_kind(int dices[]) 
125. {
126.   int score = 0;
127.   if (dices[0] == dices[4]) {
128.     score = 50;
129.   }
130.   return score;
131. }
133. int short_straight(int dices[]) 
134. {
135.   int score = 0;
136.   if (dices[0] == dices[1]-1 && 
137.       dices[1] == dices[2]-1 && 
138.       dices[2] == dices[3]-1 ||
139.       dices[1] == dices[2]-1 && 
140.       dices[2] == dices[3]-1 && 
141.       dices[3] == dices[4]-1) {
142.     score = 25;
143.   }
144.   return score;
145. }
147. int long_straight(int dices[]) 
148. {
149.   int score = 0;
150.   if (dices[0] == dices[1]-1 && 
151.       dices[1] == dices[2]-1 &&
152.       dices[2] == dices[3]-1 && 
153.       dices[3] == dices[4]-1) {
154.     score = 35;
155.   }
156.   return score;
157. }
159. int full_house(int dices[]) 
160. {
161.   int score = 0;
162.   if (dices[0] == dices[1] && 
163.       dices[2] == dices[4] ||
164.       dices[0] == dices[2] && 
165.       dices[3] == dices[4]) {
166.     score = 40;
167.   }
168.   return score;
169. }
170.       
171. struct mapping
172. {
173.   int map;
174.   int upper;
175. };
177. void best_categorization(int scores[][ncategories], int categorization[], 
178.                          int& bonus, int& score)
179. {
180.   int best[ncombinations][nupper];
181.   mapping previous[ncombinations][nupper];
182.   for (int i = 0; i < ncombinations; ++i) {
183.     for (int j = 0; j < nupper; ++j) {
184.       best[i][j] = numeric_limits<int>::min();
185.     }
186.   }
187.   best[0][0] = 0;
189.   for (int r = 0; r < nrounds; ++r) {
190.     for (int c = 0; c < ncategories; ++c) {
191.       int score = scores[r][c];
192.       int upper = c < 6 ? score : 0;
193.       for (int map = 0, add = 1 << c; map < ncombinations; ++map) {
194.         if (nmapped[map] != r || map & add) continue;
195.         for (int u = 0; u < nupper; ++u) {
196.           int newscore = score + best[map][u];
197.           int newupper = upper + u < nupper ? upper + u : nupper - 1;
198.           if (newscore > best[map|add][newupper]) {
199.             best[map|add][newupper] = newscore;
200.             previous[map|add][newupper].map = map;
201.             previous[map|add][newupper].upper = u;
202.           }
203.         }
204.       }
205.     }
206.   }
208.   int map = ncombinations - 1;
209.   int upper = nupper - 1;
210.   bonus = 35;
211.   score = best[map][upper] + bonus;
212.   for (int u = 0; u < nupper; ++u) {
213.     if (score < best[map][u]) {
214.       bonus = 0;
215.       score = best[map][u];
216.       upper = u;
217.     }
218.   }
219.   
220.   while (map) {
221.     mapping pre = previous[map][upper];
222.     int c = 0;
223.     for (int add = map ^ pre.map; add >>= 1; ++c) /* NOP */;
224.     categorization[c] = best[map][upper] - best[pre.map][pre.upper];
225.     map = pre.map;
226.     upper = pre.upper;
227.   }
228. }
230. int main(int argc, char *argv[])
231. {
232. #ifndef ONLINE_JUDGE
233.   filebuf in, out;
234.   cin.rdbuf(in.open((string(argv[0]) + ".in").c_str(), ios_base::in));
235.   cout.rdbuf(out.open((string(argv[0]) + ".out").c_str(), ios_base::out));
236. #endif
237.   
238.   /* calculate the number of "used categories" for each combination*/
239.   for (int i = 0; i < ncombinations; ++i) {
240.     for (int j = 0; j < ncategories; ++j) {
241.       nmapped[i] += (i & (1 << j)) ? 1 : 0;
242.     }
243.   }
245.   typedef int (*scorer)(int []);
246.   scorer scorers[ncategories] = { 
247.     &ones, &twos, &threes, &fours, &fives,  &sixes, &chance, 
248.     &three_kind, &four_kind, &five_kind, &short_straight, &long_straight, 
249.     &full_house, 
250.   };
251.   
252.   int dices[ndices];
253.   int scores[nrounds][ncategories];
254.   int d = 0, r = 0, g = 0;
255.   while (cin >> dices[d++ % ndices]) {
256.     if (d / ndices > r) {
257.       sort(dices, dices + ndices);
258.       for (int c = 0; c < ncategories; ++c) {
259.         scores[r % nrounds][c] = scorers[c](dices);
260.       }
261.       r = d / ndices;
262.     }
263.     if (r / nrounds > g) {
264.       g = r / nrounds;
265.       int categorization[ncategories];
266.       int bonus = 0;
267.       int score = 0;
268.       best_categorization(scores, categorization, bonus, score);
269.       for (int c = 0; c < ncategories; ++c) {
270.         cout << categorization[c] << ' ';
271.       }
272.       cout << bonus << ' ' << score << '/n';
273.     }
274.   }
276.   return 0;
277. }
278.