Example 1:

Input: nums = [11,7,2,15]
Output: 2
Explanation: The element 7 has the element 2 strictly smaller than it and the element 11 strictly greater than it.
Element 11 has element 7 strictly smaller than it and element 15 strictly greater than it.
In total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.

Example 2:

Input: nums = [-3,3,3,90]
Output: 2
Explanation: The element 3 has the element -3 strictly smaller than it and the element 90 strictly greater than it.
Since there are two elements with the value 3, in total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.

Constraints:

• 1 <= nums.length <= 100
• -105 <= nums[i] <= 105

Solution: Min / Max elements

Find min and max of the array, count elements other than those two.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countElements(vector<int>& nums) {
    auto [it1, it2] = minmax_element(begin(nums), end(nums));
    return count_if(begin(nums), end(nums), [lo=*it1, hi=*it2](int x) {
      return x != lo && x != hi;
    });
  }
};

The post 花花酱 LeetCode 2148. Count Elements With Strictly Smaller and Greater Elements appeared first on Huahua's Tech Road.

Alice and Bob take turns playing a game, with Alice starting first.

There are n stones arranged in a row. On each player’s turn, they can remove either the leftmost stone or the rightmost stone from the row and receive points equal to the sum of the remaining stones’ values in the row. The winner is the one with the higher score when there are no stones left to remove.

Bob found that he will always lose this game (poor Bob, he always loses), so he decided to minimize the score’s difference. Alice’s goal is to maximize the difference in the score.

Given an array of integers stones where stones[i] represents the value of the ith stone from the left, return the difference in Alice and Bob’s score if they both play optimally.

Example 1:

Input: stones = [5,3,1,4,2]
Output: 6
Explanation: 
- Alice removes 2 and gets 5 + 3 + 1 + 4 = 13 points. Alice = 13, Bob = 0, stones = [5,3,1,4].
- Bob removes 5 and gets 3 + 1 + 4 = 8 points. Alice = 13, Bob = 8, stones = [3,1,4].
- Alice removes 3 and gets 1 + 4 = 5 points. Alice = 18, Bob = 8, stones = [1,4].
- Bob removes 1 and gets 4 points. Alice = 18, Bob = 12, stones = [4].
- Alice removes 4 and gets 0 points. Alice = 18, Bob = 12, stones = [].
The score difference is 18 - 12 = 6.

Example 2:

Input: stones = [7,90,5,1,100,10,10,2]
Output: 122

Constraints:

• n == stones.length
• 2 <= n <= 1000
• 1 <= stones[i] <= 1000

Solution: MinMax + DP

For a sub game of stones[l~r] game(l, r), we have two choices:
Remove the left one: sum(stones[l + 1 ~ r]) – game(l + 1, r)
Remove the right one: sum(stones[l ~ r – 1]) – game(l, r – 1)
And take the best choice.

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  int stoneGameVII(vector<int>& A) {
    const int n = A.size();
    vector<vector<int>> cache(n, vector<int>(n, INT_MAX));
    function<int(int, int, int)> dp = [&](int l, int r, int s) {
      if (l >= r) return 0;
      if (cache[l][r] == INT_MAX)
        cache[l][r] = max(s - A[r] - dp(l, r - 1, s - A[r]),
                          s - A[l] - dp(l + 1, r, s - A[l]));
      return cache[l][r];
    };
    return dp(0, n - 1, accumulate(begin(A), end(A), 0));
  }
};

// Author: Huahua
class Solution {
public:
  int stoneGameVII(vector<int>& A) {
    const int n = A.size();
    vector<int> s(n + 1);
    for (int i = 0; i < n; ++i) s[i + 1] = s[i] + A[i];
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int c = 2; c <= n; ++c)
      for (int l = 0, r = l + c - 1; r < n; ++l, ++r)
        dp[l][r] = max(s[r + 1] - s[l + 1] - dp[l + 1][r],
                       s[r] - s[l] - dp[l][r - 1]);
    return dp[0][n - 1];
  }
};

# Author: Huahua
class Solution:
  def stoneGameVII(self, stones: List[int]) -> int:
    n = len(stones)
    s = [0] * (n + 1)
    for i in range(n): s[i + 1] = s[i] + stones[i]
    dp = [[0] * n for _ in range(n)]
    for c in range(2, n + 1):
      for l in range(0, n - c + 1):
        r = l + c - 1
        dp[l][r] = max(s[r + 1] - s[l + 1] - dp[l + 1][r],
                       s[r] - s[l] - dp[l][r - 1])
    return dp[0][n - 1]

Related Problems

• https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-877-stone-game/
• https://zxi.mytechroad.com/blog/recursion/leetcode-1140-stone-game-ii/
• https://zxi.mytechroad.com/blog/game-theory/leetcode-1406-stone-game-iii/
• https://zxi.mytechroad.com/blog/game-theory/leetcode-1510-stone-game-iv/
• https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-1563-stone-game-v/
• https://zxi.mytechroad.com/blog/greedy/leetcode-1686-stone-game-vi/

The post 花花酱 LeetCode 1690. Stone Game VII appeared first on Huahua's Tech Road.

Alice and Bob continue their games with piles of stones. There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue.

Alice and Bob take turns, with Alice starting first. On each player’s turn, that player can take 1, 2 or 3 stones from the first remaining stones in the row.

The score of each player is the sum of values of the stones taken. The score of each player is 0 initially.

The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken.

Assume Alice and Bob play optimally.

Return “Alice” if Alice will win, “Bob” if Bob will win or “Tie” if they end the game with the same score.

Example 1:

Input: values = [1,2,3,7]
Output: "Bob"
Explanation: Alice will always lose. Her best move will be to take three piles and the score become 6. Now the score of Bob is 7 and Bob wins.

Example 2:

Input: values = [1,2,3,-9]
Output: "Alice"
Explanation: Alice must choose all the three piles at the first move to win and leave Bob with negative score.
If Alice chooses one pile her score will be 1 and the next move Bob's score becomes 5. The next move Alice will take the pile with value = -9 and lose.
If Alice chooses two piles her score will be 3 and the next move Bob's score becomes 3. The next move Alice will take the pile with value = -9 and also lose.
Remember that both play optimally so here Alice will choose the scenario that makes her win.

Example 3:

Input: values = [1,2,3,6]
Output: "Tie"
Explanation: Alice cannot win this game. She can end the game in a draw if she decided to choose all the first three piles, otherwise she will lose.

Example 4:

Input: values = [1,2,3,-1,-2,-3,7]
Output: "Alice"

Example 5:

Input: values = [-1,-2,-3]
Output: "Tie"

Constraints:

• 1 <= values.length <= 50000
• -1000 <= values[i] <= 1000

Solution: DP with memorization

dp(i) := max relative score the current player can get if start the game from the i-th stone.

dp(i) = max(sum(values[i:i+k]) – dp(i + k)) 1 <= k <= 3

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  string stoneGameIII(vector<int>& stoneValue) {
    const int n = stoneValue.size();
    vector<int> mem(n, INT_MIN);
    
    // Maximum `relative score` the current player can achieve
    // if start from the i-th stone.
    function<int(int)> dp = [&](int i) {
      if (i >= n) return 0; // end of game.
      if (mem[i] != INT_MIN) return mem[i];      
      for (int j = 0, s = 0; j < 3 && i + j < n; ++j) {
        s += stoneValue[i + j];
        // s - dp(.) to get `relative score`.
        mem[i] = max(mem[i], s - dp(i + j + 1));
      }      
      return mem[i];
    };
    
    const int score = dp(0);    
    return score > 0 ? "Alice" : (score == 0 ? "Tie" : "Bob");
  }
};

# Author: Huahua
class Solution:
  def stoneGameIII(self, stoneValue: List[int]) -> str:
    n = len(stoneValue)
    stoneValue += [0, 0, 0]
    dp = [-10**9] * n + [0, 0, 0]
    for i in range(n - 1, -1, -1):
      for k in (1, 2, 3):
        dp[i] = max(dp[i], sum(stoneValue[i:i+k]) - dp[i+k])    
    return "Alice" if dp[0] > 0 else "Bob" if dp[0] < 0 else "Tie"

Related Problems

• https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-877-stone-game/
• https://zxi.mytechroad.com/blog/recursion/leetcode-1140-stone-game-ii/
• https://zxi.mytechroad.com/blog/leetcode/leetcode-486-predict-the-winner/

The post 花花酱 LeetCode 1406. Stone Game III appeared first on Huahua's Tech Road.