![]() |
|
SPONSORED LINKS BY GOOGLE |
|
3
2nd October 16:09
External User
Posts: 1
|
That's a slightly different goal. The strategy that
maximizes your expected score may not be the same as the strategy that maximizes your likelihood of exceeding a specified score. For example, suppose an earlier player has already achieved a perfect score of 24, so your only hope of sharing in the pot is to match that score. A strategy that aims to maximize your expected score might tell you to be content if you roll 1-2-5-6-6-6 for a total of 23, but if you follow that strategy in this situation you are guaranteed to lose. It seems to me the goal of the Kth player should be to maximize the likelihood that his score exceeds the maximum of the K-1 preceding scores and the expected maximum of the N-(K-1) scores that will follow. Since the score that K actually achieves can influence the expected scores of the later players (by "raising the bar"), the calculation seems quite complicated. Perhaps it could be attacked by starting with the Nth player and computing his expected scores when he aims to exceed each of the possible preceding maxima, then work back to the (N-1)st player, and so on. -- Eric Sosman esosman@acm-dot-org.invalid |
|
|
4
2nd October 16:12
External User
Posts: 1
|
(I think that this method will analyze a slightly simpler problem, where
draws do not split the pot; they entirely go to the first tying player, though I may have made an error in it...) Let NDICE and NSIDES be fixed constants Define f(total, pot, later_players) -> (avg_payoff, p_later_wins, avg_pot) - total is the highest total of any previous qualifying player. - pot is the number of chips in the pot - later_players is the number of players who play after this player - avg_payoff is the average win by this player in this situation - p_later_wins is the probability this player or someone later wins - avg_pot is the average end value of the pot Define g(total, has1, has2, pot, later_players, dice_left) -> (avg_payoff, p_later_wins, avg_pot) - total is (points by highest previous player) - (points stored by this player) - has1 is 1 if this player has stored a 1, 0 if otherwise - has2 is 1 if this player has stored a 2, 0 if otherwise - pot is the value of the pot initially Return values are as above Define h(total, has1, has2, pot, later_players, (dice)) -> (avg_payoff, p_later_wins, avg_pot, no_dice) - (dice) is a sorted list of dice values - no_dice is the number of dice taken by the player f and g are cached; h is not. (If g is written properly, no value of h will be evaluated by g more than once; it will only be reevaluated if the player is looking for a strategy.) g (A, B, C, D, E, F) -> weighted_avg (sorted lists L of F numbers from 1 to NSIDES: weight(multinomial(L)) : h(A, B, C, D, E, L)) h(...) uses rules: Always take a 1 if there is one and you don't already have one. Similar with 2. After that, consider each possibility of taking top N dice. Return values corresponding to highest avg_payoff. (Rest of recursion omitted). -- ------------------------ Mark Jeffrey Tilford tilford@ugcs.caltech.edu |
|
|
SPONSORED LINKS BY GOOGLE |
|
|