LeetCode每日一题(Predict the Winner)

You are given an integer array nums. Two players are playing a game with this array: player 1 and player 2.

Player 1 and player 2 take turns, with player 1 starting first. Both players start the game with a score of 0. At each turn, the player takes one of the numbers from either end of the array (i.e., nums[0] or nums[nums.length - 1]) which reduces the size of the array by 1. The player adds the chosen number to their score. The game ends when there are no more elements in the array.

Return true if Player 1 can win the game. If the scores of both players are equal, then player 1 is still the winner, and you should also return true. You may assume that both players are playing optimally.

Example 1:

Input: nums = [1,5,2]
Output: false
Explanation: Initially, player 1 can choose between 1 and 2.
If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2).
So, final score of player 1 is 1 + 2 = 3, and player 2 is 5.
Hence, player 1 will never be the winner and you need to return false.
Example 2:

Input: nums = [1,5,233,7]
Output: true
Explanation: Player 1 first chooses 1. Then player 2 has to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.

Constraints:

1 <= nums.length <= 20
0 <= nums[i] <= 107

---

这题跟以前的Stone Game系列中的某一个一模一样，只是上次代码写的比较冗长，这次试着精简一下。大体上来说就是一个dp，只不过每一步要根据不同player来选择不同的拿取策略，因为我们是站在player1的立场上的，我们要让player1的分数最大化，我们返回的值也是player1的分数，所以在轮到player2的时候策略必须是反的。

---

use std::collections::HashMap;

impl Solution {
    fn predict(nums: &Vec<i32>, left: usize, right: usize, is_p1: bool, cache: &mut HashMap<(usize, usize, bool), i32>) -> i32 {
        if left == right {
            if is_p1 {
                return nums[left];
            } else {
                return 0;
            }
        }
        let mut pick_left = 0;
        if is_p1 {
            pick_left = nums[left]
                + if let Some(c) = cache.get(&(left + 1, right, !is_p1)) {
                    *c
                } else {
                    Solution::predict(nums, left + 1, right, !is_p1, cache)
                };
        } else {
            pick_left = if let Some(c) = cache.get(&(left + 1, right, !is_p1)) {
                *c
            } else {
                Solution::predict(nums, left + 1, right, !is_p1, cache)
            };
        }
        let mut pick_right = 0;
        if is_p1 {
            pick_right = nums[right]
                + if let Some(c) = cache.get(&(left, right - 1, !is_p1)) {
                    *c
                } else {
                    Solution::predict(nums, left, right - 1, !is_p1, cache)
                };
        } else {
            pick_right = if let Some(c) = cache.get(&(left, right - 1, !is_p1)) {
                *c
            } else {
                Solution::predict(nums, left, right - 1, !is_p1, cache)
            }
        }
        let ans = if is_p1 { pick_left.max(pick_right) } else { pick_left.min(pick_right) };
        cache.insert((left, right, is_p1), ans);
        ans
    }

    pub fn predict_the_winner(nums: Vec<i32>) -> bool {
        let total: i32 = nums.iter().sum();
        let mut cache = HashMap::new();
        let p1 = Solution::predict(&nums, 0, nums.len() - 1, true, &mut cache);
        p1 * 2 >= total
    }
}