leetcode-石子游戏III

 题目是LeetCode第183场周赛的第四题,链接:石子游戏 III。具体描述为:Alice 和 Bob 用几堆石子在做游戏。几堆石子排成一行,每堆石子都对应一个得分,由数组 stoneValue 给出。Alice 和 Bob 轮流取石子,Alice 总是先开始。在每个玩家的回合中,该玩家可以拿走剩下石子中的的前 1、2 或 3 堆石子 。比赛一直持续到所有石头都被拿走。每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 0 。比赛的目标是决出最高分,得分最高的选手将会赢得比赛,比赛也可能会出现平局。假设 Alice 和 Bob 都采取 最优策略 。如果 Alice 赢了就返回 “Alice” ,Bob 赢了就返回 “Bob”,平局(分数相同)返回 “Tie” 。

 示例1:

输入:values = [1,2,3,7]
输出:"Bob"
解释:Alice 总是会输,她的最佳选择是拿走前三堆,得分变成 6 。但是 Bob 的得分为 7,Bob 获胜。

 示例2:

输入:values = [1,2,3,-9]
输出:"Alice"
解释:Alice 要想获胜就必须在第一个回合拿走前三堆石子,给 Bob 留下负分。
如果 Alice 只拿走第一堆,那么她的得分为 1,接下来 Bob 拿走第二、三堆,得分为 5 。之后 Alice 只能拿到分数 -9 的石子堆,输掉比赛。
如果 Alice 拿走前两堆,那么她的得分为 3,接下来 Bob 拿走第三堆,得分为 3 。之后 Alice 只能拿到分数 -9 的石子堆,同样会输掉比赛。
注意,他们都应该采取 最优策略 ,所以在这里 Alice 将选择能够使她获胜的方案。

 示例3:

输入:values = [1,2,3,6]
输出:"Tie"
解释:Alice 无法赢得比赛。如果她决定选择前三堆,她可以以平局结束比赛,否则她就会输。

 示例4:

输入:values = [1,2,3,-1,-2,-3,7]
输出:"Alice"

 示例5:

输入:values = [-1,-2,-3]
输出:"Tie"

 这又是一道hard难度的动态规划题目,难点仍然在于找到状态方程。首先我们定义dp[i]的意义为从stoneValue[i]stoneValue[N-1]这堆石头里,从i开始取石头的人所能够拿到的最多石头数。因为从i开始取石头的人可以取1、2或3堆石头,然后下一个人取到的最多石头数就分别是dp[i+1]dp[i+2]dp[i+3],为了使从i开始取得的石头最多,等价于使下一个人取得的石头数最少即min(dp[i+1], dp[i+2], dp[i+3]),此时从i开始取得的最多石头数为 ∑ j = i N − 1 s t o n e V a l u e [ j ] − m i n ( d p [ i + 1 ] , d p [ i + 2 ] , d p [ i + 3 ] ) \sum_{j=i}^{N-1}stoneValue[j]-min(dp[i+1], dp[i+2], dp[i+3]) j=iN1stoneValue[j]min(dp[i+1],dp[i+2],dp[i+3])。最后根据2dp[0] ∑ j = 0 N − 1 s t o n e V a l u e [ j ] \sum_{j=0}^{N-1}stoneValue[j] j=0N1stoneValue[j]的大小关系即可知道最终结果。时间复杂度为 O ( n ) O(n) O(n),空间复杂度为 O ( n ) O(n) O(n)

 JAVA版代码如下:

class Solution {
    public String stoneGameIII(int[] stoneValue) {
        int N = stoneValue.length;
        int[] dp = new int[N + 1];
        dp[N] = 0;
        dp[N - 1] = stoneValue[N - 1];
        int sum = stoneValue[N - 1];
        if (N - 2 >= 0) {
            sum += stoneValue[N - 2];
            dp[N - 2] = sum - Math.min(dp[N - 1], dp[N]);
        }
        for (int i = N - 3; i >= 0; --i) {
            sum += stoneValue[i];
            dp[i] = sum - Math.min(Math.min(dp[i + 1], dp[i + 2]), dp[i + 3]);
        }
        if (dp[0] * 2 > sum) {
            return "Alice";
        }
        else if (dp[0] * 2 < sum) {
            return "Bob";
        }
        else {
            return "Tie";
        }
    }
}

 提交结果如下:


 进一步可以减少空间复杂度,这是因为每次的状态dp[i]最多只与另外三个状态dp[i+1]dp[i+2]dp[i+3]相关,因此可以用三个变量进行保存,从而将空间复杂度降到了 O ( 1 ) O(1) O(1)

 JAVA版代码如下:

class Solution {
    public String stoneGameIII(int[] stoneValue) {
        int N = stoneValue.length;
        int dp0, dp1 = stoneValue[N - 1], dp2 = 0;
        int sum = stoneValue[N - 1];
        if (N - 2 >= 0) {
            sum += stoneValue[N - 2];
            dp0 = sum - Math.min(dp1, dp2);
        }
        else {
            dp0 = dp1;
        }
        for (int i = N - 3; i >= 0; --i) {
            sum += stoneValue[i];
            int temp = dp0;
            dp0 = sum - Math.min(Math.min(dp0, dp1), dp2);
            dp2 = dp1;
            dp1 = temp;
        }
        if (dp0 * 2 > sum) {
            return "Alice";
        }
        else if (dp0 * 2 < sum) {
            return "Bob";
        }
        else {
            return "Tie";
        }
    }
}

在这里插入图片描述
 提交结果如下:


 Python版代码如下:

class Solution:
    def stoneGameIII(self, stoneValue: List[int]) -> str:
        N = len(stoneValue)
        dp0, dp1, dp2 = 0, stoneValue[N - 1], 0
        totalSum = stoneValue[N - 1]
        if N - 2 >= 0:
            totalSum += stoneValue[N - 2]
            dp0 = totalSum - min(dp1, dp2)
        else:
            dp0 = dp1
        for i in range(N - 3, -1, -1):
            totalSum += stoneValue[i]
            temp = dp0
            dp0 = totalSum - min(dp0, dp1, dp2)
            dp2 = dp1
            dp1 = temp
        if dp0 * 2 > totalSum:
            return 'Alice'
        elif dp0 * 2 < totalSum:
            return 'Bob'
        else:
            return 'Tie'

 提交结果如下:


你可能感兴趣的:(LeetCode)