LintCode 395. Coins in a Line II

395. Coins in a Line II

There are n coins with different value in a line. Two players take turns to take one or two coins from left side until there are no more coins left. The player who take the coins with the most value wins.

Could you please decide the first player will win or lose?

Example

Given values array A = [1,2,2], return true.

Given A = [1,2,4], return false.

Input test data (one parameter per line.)

"""
dp[n] 表示在数组还剩下n个数的时候 能够拿到的最大值

dp[n] > 2/n True

case [1,2,3,4]
画出树状图

dp[4] = max(    
(1) min(dp[2],dp[1]) + 1,
(2) min(dp[1],dp[0]) + 3
)
min表示后手在有得选的情况下，他会在那种状态下使你拿到最小
max 表示我在对手对我不利的情况下，最优的操作

注意:
(1)n = 3时的情况
(2)另外 还剩n个的时候,第1个是 -n  第2个是 -n + 1
"""
class Solution:
    """
    @param values: a vector of integers
    @return: a boolean which equals to true if the first player will win
    """
    def firstWillWin(self, values):
        # write your code here
        n = len(values)
        if n == 0:
            return False
        elif n == 1 or n ==2:
            return True
        elif n == 3:
            return values[-3] + values[-2] >= sum(values) * 1.0 / 2
            
    
        dp = [0 for i in xrange(n + 1)]
        visited = [0 for i in xrange(n + 1)]
        
        dp[0] = 0
        dp[1] = values[-1]
        dp[2] = values[-1] + values[-2]
        dp[3] = values[-3] + values[-2]
        visited[0] = 1
        visited[1] = 1
        visited[2] = 1
        visited[3] = 1
        
        dp[n] = self.memorySearch(n,values,dp,visited)
        #print dp
        #在这道题中,平手也算赢，直接比较int 和 float有点危险
        return dp[n] >= sum(values) * 1.0 / 2 
        
        
    #返回在数组还剩下n个数的时候(从右到左数n个) 能够拿到的最大值
    def memorySearch(self,n,values,dp,visited):
        if visited[n] == 1:
            return dp[n]

        first_index =  -n     #能拿到的第1个数 举例子 只剩2个数 -1 和 -2
        second_index = -n + 1 #能拿到的第2个数
        
        dp[n] = max( 
            min(
                self.memorySearch(n - 2,values,dp,visited) ,
                self.memorySearch(n - 3,values,dp,visited)
            ) + values[first_index],
            
            min(
                self.memorySearch(n - 3,values,dp,visited) ,
                self.memorySearch(n - 4,values,dp,visited)
            ) + values[first_index] + values[second_index]
        
        )
        
        visited[n] = 1
        return dp[n]