A Coin Game

最新推荐文章于 2025-10-08 11:27:46 发布
原创 最新推荐文章于 2025-10-08 11:27:46 发布 · 896 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#algorithm #list #each #class

  Suppose you play the following game with your opponent:
There is a sequence of n coins with values v[1], v[2], …, v[n] in a queue which are known in advance. Now each player takes alternate turn to pick a coin. The rule is you can only take the coin from the head or from the tail of the queue each time.
Please design a dynamic program algorithm such that the total value of the coins you pick is the largest.  We assume the opponent is very stupid and always makes an incorrect decision. We assume you make the first pick. Pseudo code is not required but you need to show the inductive formula and initial conditions for the program. What is the complexity of your algorithm?
Apply your algorithm to the following sequence: 7, 5, 2, 3, 1, 6.



设L(i,j)是玩家i,i+1,i+2....j-1,j的所能获取的最大值。
假设从(i,j)序列开始取数，玩家可能获取的最大值应该是v(i)+L(i+1 , j )  和 v(j) + L(i , j -1)中的最大值。对于L(i+1,j)队列而言，是对手先获取硬币，而且对手只能拿较小的硬币。所以对于具体的序列当v(i+1) > v(j) 时 L(i+1, j ) = ( i+1 , j-1) 。而当v(i+1) < v(j)时，L( i +1 , j ) = l( i＋2 , j )。所以最后可以推导出计算公式：



下面是 7 ， 5 ，2 ， 3 ， 1 ，6 序列的推导过程：


7(1,1)    7(1,2)    9(1,3)    12(1,4)    15(1,5)    18(1,6)
               5(2,2)    5(2,3)    8(2,4)      8(2,5)      14(2,6)
                              2(3,3)    3(3,4)     3(3,5)       9(3,6)
                                             3(4,4)     3(4,5)       9(4,6)
                                                            1(5,5)       6(5,6)
                                                                              6(6,6)



__author__ = 'lun.wei'


class CoinGame :
    def __init__(self , coins ):
        self.coins = coins
        self.coinNum  = len(coins)
        self.mTable  = list()
        self.mIndexTable = list()
        for i in range( 0 , self.coinNum ):
            tempList = list()
            tempIndexList = list()
            for j in range( 0 , self.coinNum) :
                tempList.append( 0 )
                tempIndexList.append( 0 )
            self.mTable.append(tempList)
            self.mIndexTable.append(tempIndexList)

    def calu(self):
        for j in range( 0 , self.coinNum):
            i = j
            while  i >= 0 :
                if i == j  :
                    self.mTable[i][j] = self.coins[i]
                    self.mIndexTable[i][j] = ( j - i )
                elif (j - 1) == i :
                    temp = self.coins[i]
                    self.mIndexTable[i][j] = 0
                    if  self.coins[j] > self.coins[i] :
                        temp = self.coins[j]
                        self.mIndexTable[i][j] = j - i
                    self.mTable[i][j] = temp
                else :
                    num1 = 0
                    num2  = 0
                    if self.coins[i + 1 ] > self.coins[j] :
                        num1 = self.coins[i] + self.mTable[i + 1 ][j - 1 ]
                    else :
                        num1 = self.coins[i] + self.mTable[ i+ 2 ][j]

                    if  self.coins[i] > self.coins[j- 1] :
                        num2 = self.coins[j] + self.mTable[i][j-2]
                    else :
                        num2 = self.coins[j] + self.mTable[i+1][j-1]

                    self.mTable[i][j] = num1
                    self.mIndexTable[i][j] = 0
                    if num2 > num1 :
                        self.mTable[i][j] = num2
                        self.mIndexTable[i][j] = ( j - i )
                i=i-1
                   
    def printChoose(self , end , begin , index ):
        if ( end  - begin    ) < 2  :
            if self.coins[end] > self.coins[begin ]:
                print "%d: %d " %( index ,self.coins[end]  )
            else :
                print "%d: %d " %( index ,self.coins[begin ]  )
        else :
            if  self.mIndexTable[begin][end] == 0  :
                print "%d: %d " %( index  , self.coins[self.mIndexTable[begin][end] + begin ]  )
                if self.coins[begin+ 1 ] > self.coins[end ] :
                    self.printChoose( end  - 1 , begin + 1    ,  index + 1 )
                else :
                    self.printChoose( end  , begin + 2  , index + 1)
            else :
                print "%d: %d " %( index  , self.coins[self.mIndexTable[begin][end]  + begin  ]  )
                if  self.coins[begin] > self.coins[end - 1 ] :
                    self.printChoose(  end - 2 , begin   , index + 1 )
                else :
                    self.printChoose(end -1 , begin + 1  ,index + 1 )


    def outputAnswer(self):
        print "Our Choice"
        self.printChoose( self.coinNum - 1  , 0  , 1 )

    def printMatrix(self , m ):
        for i in range ( 0 , self.coinNum):
            for j in range( 0 , self.coinNum ):
                print "%8d" % (m[i][j]),
            print
       
    def printTable(self):
        print "====Coins======"
        print self.coins
        print "=====MTABLE====="
        #for i in range( 0 , self.coinNum ):
        #    print self.mTable[i]
        self.printMatrix(self.mTable)
        print "=====MINDEXTABLE====="
        #for i in range( 0 , self.coinNum ):
        #    print self.mIndexTable[i]
        self.printMatrix(self.mIndexTable)


game = CoinGame( [  7 , 5 , 2 ,100 ,  3 , 1 , 6 ])
game.calu()
game.printTable()
game.outputAnswer()

运行结果如下图：



博弈论+dp——洛谷P2964 [USACO09NOV]硬币的游戏A Coin Game
我怎么这么菜的呢
05-01 946
https://daniu.luogu.org/problem/show?pid=2964 本来博弈论就不懂，现在套上dp，直接萎了； 题解都看了半天； 我们搞一个f[i][j]表示还剩1~i的时候，上一个人选了j个； 显然i=n的时候是最开始，就是一个都没取； 现在我们倒着dp，所以一开始我们的读入也要倒着读； 关于这个f[i][j]，它代表一个选手的状态，所以到底是先手还是后手我们不
USACO 2009 Nov Silver 1.A Coin Game 动态规划
qq_35891865的博客
08-27 607
Farmer John's cows like to play coin games so FJ has invented with a new two-player coin game called Xoinc for them. Initially a stack of N (5 The first player starts the game by taking the top one
洛谷 P2964 [USACO09NOV] 硬币的游戏A Coin Game
依然一笑作春温。
03-07 861
DP+博弈论
洛谷2964 A Coin Game
YHaX的博客
03-20 601
动态规划
A Coin Game S(DP+博弈)
donnameの博客
09-04 202
题目链接 题意：一排硬币有不同的价值，只能从左到右拿，下一个人最多可以拿上一个人拿的硬币数量的两倍，A先拿，且第一次最多只能拿两枚硬币，问A拿的硬币的价值和最大为多少。 这道题和A Game类似，我们用dp[i][j]表示当剩下i枚硬币且上一次拿硬币的人取走了j枚硬币时可以取得的最大价值,（下列说明默认不超出范围）dp[i][j]状态下,可以取(k=n-i+1)k,k+1,k+2…k+2j-1,dp[i][j-1]状态下,可以取k,k+1,k+2…k+2j-3,两者之间差了k+2j-2,k+2j-1,所以d
洛谷P2964 [USACO09NOV]硬币的游戏A Coin Game
yzyyylx的博客
11-04 381
题面 题意 有一叠硬币，每个硬币有一个币值，双方轮流操作，每个人至少取一枚硬币，最多取上一个人取的数量的两倍（第一个人最多取1枚），问先手至多能得到的硬币币值之和为多少。 做法 首先定义状态dp[i][j]dp[i][j]dp[i][j]表示还剩下iii枚硬币，上一个人取了jjj枚硬币时的最大币值和，然后发现如果暴力转移，则时间复杂度是O(n3)O(n^3)O(n3)，但是我们可以发现dp[i][...
A-Platform-Game
07-17
#一个平台游戏 ＃＃概述 “项目：一个平台的游戏”上实现的javascrip和这样的技术： commonjs ... actorChars.js - 将对象（'Player'、'Coin'、'Lava'）与游戏关卡上的符号（“@”、“o”、“=”）相关联。 文件夹src
45、Super Jumper: A 2D OpenGL ES Game Development Guide
最新发布
numpy6sculptor的博客
10-08 20
本文介绍了基于OpenGL ES的2D游戏《Super Jumper》的开发指南，涵盖核心类设计、游戏对象行为、世界更新机制与碰撞检测。详细解析了Platform、Bob和World类的实现原理，展示了如何通过随机算法生成关卡，并实现了角色运动、平台交互及碰撞响应等关键 gameplay 机制，适合学习Android平台上的2D游戏开发流程。
49、Super Jumper: A 2D OpenGL ES Game Development Guide
rain6的博客
07-17 62
本文详细介绍了使用OpenGL ES开发2D游戏'Super Jumper'的多个核心部分，包括帮助屏幕、高分榜单界面以及各种游戏对象的模拟类实现。内容涵盖了从用户界面设计到游戏物理逻辑的构建，为Android平台上的游戏开发提供了具体指导。
[USACO09NOV]硬币的游戏A Coin Game
weixin_30790841的博客
09-03 190
题目描述 Farmer John's cows like to play coin games so FJ has invented with a new two-player coin game called Xoinc for them. Initially a stack of N (5 <= N <= 2,000) coins sits on the ground; coin ...
NYOJ 题目401 Coin Game
小寒
07-20 511
Coin Game 时间限制：1000 ms  |  内存限制：32768 KB 难度：2 描述After hh has learned how to play Nim game, he begins to try another coin game which seems much easier. The game goes like this:  Tw
Coin Game
weixin_30814223的博客
03-28 287
Problem Description After hh has learned how to play Nim game, he begins to try another coin game which seems much easier.The game goes like this:Two players start the game with a circle of n c...
[3951]:Coin Game
Μῆτις -- chengfengYang_LMN
04-22 444
Problem Description After hh has learned how to play Nim game, he begins to try another coin game which seems much easier.The game goes like this: Two players start the game with a circle of n coins
HDU 3951 Coin Game
Aurora
03-31 400
                                                Coin Game                Time Limit:1000MS    Memory Limit:32768KB    64bit IO Format:%I64d &amp; %I64uDescription After hh has learned how to play Nim...
hdu3951——Coin Game（简单博弈）
Beyond the Sora
05-12 1237
Problem Description After hh has learned how to play Nim game, he begins to try another coin game which seems much easier. The game goes like this: Two players start the game with a circle of n coi
对称博弈（coin game）
EmilSinclair4391的博客
04-19 2025
Problem Description After hh has learned how to play Nim game, he begins to try another coin game which seems much easier. The game goes like this: Two players start the game with a circle of n co
hdu 3951 Coin Game（对称博弈）
K键盘里的青春K
10-19 753
Coin Game Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1756    Accepted Submission(s): 1018 Problem Description After hh has lea
ACM-对称博弈之Coin Game——hdu3951
继续激情，继续奋斗。
05-03 2361
ACM 对称博弈 Coin Game hdu3951
2020 Multi-University Training Contest 10 hdu6883 Coin Game(思维题 贪心)
小衣同学的博客
08-21 409
题目 多组样例，n(n<=5e6)种机器，第i种机器有ai和bi两个权值，用上述算法生成，其中参数1<=k1,k2<=1e12 对于第i种机器，你可以按一次按钮获得ai收益，可以再按一次再获得bi收益，可以再按第三次获得ai收益，最多按三次 记f(x)为只能按x次按钮的最大收益和， 求f(1)^f(2)^...^f(m)(m<=1.5e7)，其中^表示异或 思路来源 官方题解 心得 赛中一直考虑1、2、3三种怎么互斥背包，然而1.5e7决定了只能用线性做， 感觉
We are playing a game. You start with £100. I shall flip a fair coin. If the coin comes up heads, you add £1 to your previous sum of money. If it comes tails the sum you have gets inverted( i.e. you have £x, your sum becomes £(1/x). £100 goes to £0.01, £0.5 to £2 and so on). What is the expected amount of money you will end up with after 10 consecutive coin flips?
06-10
To calculate the expected value of money after 10 coin flips with specific rules, let's break down the problem into manageable parts. Assume the rules involve gaining or losing a certain amount based on heads or tails and possibly inverting the total at some point. ### General Approach to Expected Value Calculation The expected value (EV) for each coin flip can be calculated as follows: $$ EV = P(\text{Heads}) \cdot (\text{Value if Heads}) + P(\text{Tails}) \cdot (\text{Value if Tails}) $$ If there are additional rules such as inversion of money, these need to be factored into the overall calculation. Assume: - Starting amount is $ S_0 $ - For each round, flipping heads increases the amount by $ X $, and flipping tails decreases it by $ Y $ - There may also be an inversion rule where the total amount is inverted after a certain number of flips For simplicity, assume no inversion unless specified. ### Method 1: Direct Calculation Without Inversion If there is no inversion involved, the EV after 10 flips can be calculated using binomial probabilities. Let $ n = 10 $ be the number of flips, $ p $ the probability of heads (e.g., $ p = 0.5 $), and $ q = 1 - p $ the probability of tails. The formula for the final amount after $ k $ heads and $ n-k $ tails is: $$ S_{\text{final}} = S_0 + kX - (n-k)Y $$ The expected value is then: $$ EV = \sum_{k=0}^{n} P(k) \cdot (S_0 + kX - (n-k)Y) $$ Where $ P(k) $ is the binomial probability: $$ P(k) = \binom{n}{k} p^k q^{n-k} $$ ### Method 2: Incorporating Inversion Rule If there is an inversion rule (e.g., the total is inverted after every 5th flip), the calculation becomes more complex. The process involves recalculating the EV after each inversion point. Assume the inversion happens after every 5th flip. After the first 5 flips, the amount might be inverted. Therefore, the EV must consider both the regular progression and the inversion effect. Let $ S_5 $ be the amount after 5 flips before inversion. If inverted, the new amount becomes: $$ S_5' = -S_5 $$ Then continue calculating the EV for the next 5 flips starting from $ S_5' $. ### Example Calculation Suppose: - Initial amount $ S_0 = 100 $ - Gain per head $ X = 10 $ - Loss per tail $ Y = 10 $ - Probability of heads $ p = 0.5 $ After 10 flips, the EV without inversion is: $$ EV = \sum_{k=0}^{10} \binom{10}{k} (0.5)^k (0.5)^{10-k} \cdot (100 + 10k - 10(10-k)) $$ Simplify the expression: $$ EV = \sum_{k=0}^{10} \binom{10}{k} (0.5)^{10} \cdot (100 + 20k - 100) $$ $$ EV = \sum_{k=0}^{10} \binom{10}{k} (0.5)^{10} \cdot (20k) $$ Using properties of binomial distributions, the expected value simplifies further. ### Python Code for Simulation Here’s a Python script to simulate the expected value: ```python from math import comb def expected_value(n, p, S0, X, Y): ev = 0 for k in range(n + 1): prob = comb(n, k) * (p**k) * ((1-p)**(n-k)) final_amount = S0 + k * X - (n - k) * Y ev += prob * final_amount return ev # Parameters n = 10 p = 0.5 S0 = 100 X = 10 Y = 10 result = expected_value(n, p, S0, X, Y) print(f"Expected Value: {result}") ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值