leetcode讲解--877. Stone Game

最新推荐文章于 2025-08-13 10:25:05 发布

weixin_34161083

最新推荐文章于 2025-08-13 10:25:05 发布

阅读量128

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法 java

原文链接：https://segmentfault.com/a/1190000017578232

本文介绍了一种使用动态规划策略解决“石头游戏”的方法。游戏中，两名玩家轮流从一排堆叠的石头中取走最左侧或最右侧的石头堆，目标是获得比对手更多的石头。文章详细解释了动态规划的三个关键要素：最优子结构、无后效性和子问题重叠，并通过两种方法——自顶向下的递归和自底向上的迭代，展示了如何高效地找到最优解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

Alex and Lee play a game with piles of stones. There are an even number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].

The objective of the game is to end with the most stones. The total number of stones is odd, so there are no ties.

Alex and Lee take turns, with Alex starting first. Each turn, a player takes the entire pile of stones from either the beginning or the end of the row. This continues until there are no more piles left, at which point the person with the most stones wins.

Assuming Alex and Lee play optimally, return True if and only if Alex wins the game.

Example 1:

Input: [5,3,4,5]
Output: true
Explanation: 
Alex starts first, and can only take the first 5 or the last 5.
Say he takes the first 5, so that the row becomes [3, 4, 5].
If Lee takes 3, then the board is [4, 5], and Alex takes 5 to win with 10 points.
If Lee takes the last 5, then the board is [3, 4], and Alex takes 4 to win with 9 points.
This demonstrated that taking the first 5 was a winning move for Alex, so we return true.

Note:

2 <= piles.length <= 500
piles.length is even.
1 <= piles[i] <= 500
sum(piles) is odd.

题目地址

讲解

动态规划，好久没做动态规划了。三要素：最优子结构、无后效性、子问题重叠。核心思想是记录子问题的解（空间换时间）。具体做法有 自底向上（迭代，规模由小到大），自顶向下（递归，规模由大到小）。

Java代码

自顶向下：

递归的比较好理解一点，状态转移方程：f(n) = {拿左边+f(n-1)左，拿右边+f(n-1)右}

class Solution {
    int beginIndex;
    int endIndex;
    int[][] dp;
    public boolean stoneGame(int[] piles) {
        beginIndex = 0;
        endIndex = piles.length-1;
        dp = new int[piles.length][piles.length];
        for(int i=0;i<dp.length;i++){
            for(int j=0;j<dp[i].length;j++){
                dp[i][j]=-1;
            }
        }
        int sum=0;
        for(int x:piles){
            sum += x;
        }
        return Math.max(piles[beginIndex]+stoneGame(piles, beginIndex+1, endIndex), piles[endIndex]+stoneGame(piles, beginIndex, endIndex-1))>sum/2?true:false;
    }
    
    private int stoneGame(int[] piles, int begin, int end){
        if(begin>=end){
            return 0;
        }
        if(dp[begin][end]!=-1){
            return dp[begin][end];
        }else{
            dp[begin][end] = Math.max(piles[begin]+stoneGame(piles, begin+1, end), piles[end]+stoneGame(piles, begin, end-1));
            return dp[begin][end];
        }
    }
}

自底向上：

把另一个人拿的数当做减。
求piles[i]到piles[j]的最优解，并存起来。

class Solution {
    public boolean stoneGame(int[] piles) {
        int[][] dp = new int[piles.length][piles.length];
        for(int i=0;i<piles.length;i++){
            for(int j=i+1;j<piles.length;j++){
                int parity= (j-i)%2;
                if(parity==1){
                    dp[i][j] = Math.max(piles[i]+dp[i+1][j], piles[j]+dp[i][j-1]);
                }else{
                    dp[i][j] = Math.max(-piles[i]+dp[i+1][j], -piles[j]+dp[i][j-1]);
                }
            }
        }
        return dp[0][piles.length-1]>0;
    }
}