g0801_0900.s0877_stone_game.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0801_0900.s0877_stone_game;

// #Medium #Array #Dynamic_Programming #Math #Game_Theory
// #2022_03_28_Time_0_ms_(100.00%)_Space_41.7_MB_(79.95%)

/**
 * 877 - Stone Game\.
 *
 * Medium
 *
 * Alice and Bob 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 across all the piles is **odd** , so there are no ties.
 *
 * Alice and Bob take turns, with **Alice starting first**. Each turn, a player takes the entire pile of stones either from the **beginning** or from 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 Alice and Bob play optimally, return `true` _if Alice wins the game, or_ `false` _if Bob wins_.
 *
 * **Example 1:**
 *
 * **Input:** piles = [5,3,4,5]
 *
 * **Output:** true
 *
 * **Explanation:**
 *
 * Alice starts first, and can only take the first 5 or the last 5.
 *
 * Say she takes the first 5, so that the row becomes [3, 4, 5].
 *
 * If Bob takes 3, then the board is [4, 5], and Alice takes 5 to win with 10 points.
 *
 * If Bob takes the last 5, then the board is [3, 4], and Alice takes 4 to win with 9 points.
 *
 * This demonstrated that taking the first 5 was a winning move for Alice, so we return true.
 *
 * **Example 2:**
 *
 * **Input:** piles = [3,7,2,3]
 *
 * **Output:** true
 *
 * **Constraints:**
 *
 * *   `2 <= piles.length <= 500`
 * *   `piles.length` is **even**.
 * *   `1 <= piles[i] <= 500`
 * *   `sum(piles[i])` is **odd**.
**/
public class Solution {
    public boolean stoneGame(int[] piles) {
        int low = 0;
        int high = piles.length - 1;
        int alice = 0;
        int bob = 0;
        while (low < high) {
            alice += Math.max(piles[low], piles[high]);
            bob += Math.min(piles[low], piles[high]);
            low++;
            high--;
        }
        return alice > bob;
    }
}