# Solution For Predict The Winner

Problem Statement:

Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.

Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.

Solution:

The problem is asking us to determine if player 1 can win, given that both player 1 and player 2 will play optimally. We can solve this problem using recursion and memoization. The recursive function will simulate the game, and will try all the possible choices for player 1 and player 2.

For each recursive call, we will keep track of the range of the array that is currently available for picking and also, we will keep track of the scores of player 1 and player 2. Since the function will be called multiple times with the same inputs, we will use memoization to avoid recomputation.

Algorithm:

1. Define a recursive function “winner” that takes in the range of the array that is currently available for picking and the scores of player 1 and player 2. The function will return the maximum score that player 1 can get from the remaining array.

2. Base Case: If the range of the array is empty, return the difference in scores of the two players. If player 1 has more points than player 2, return a positive number, indicating that player 1 has won. If player 2 has more points than player 1, return a negative number, indicating that player 2 has won. If the scores of both players are equal, return 0, indicating a tie.

3. Check if we have computed the result of the current subproblem before. If so, return the memoized result.

4. For player 1, we can choose either the first element or the last element of the current range. If we choose the first element, the new range will be [start+1, end] and the scores of player 1 and player 2 will increase by nums[start] and 0 respectively. If we choose the last element, the new range will be [start, end-1] and the scores of player 1 and player 2 will increase by nums[end] and 0 respectively.

5. For player 2, we will choose either the first element or the last element of the remaining array. If the player chooses the first element, the new range will be [start+1, end] and the scores of player 1 and player 2 will remain the same. If the player chooses the last element, the new range will be [start, end-1] and the scores of player 1 and player 2 will remain the same.

6. For each choice that player 1 makes, we will recursively call the “winner” function, passing in the new range and the updated scores of player 1 and player 2. We will take the maximum of all the results obtained from these recursive calls. This is because player 1 will choose the move that will result in the maximum score for him.

7. Store the result obtained from the current subproblem in the memoization table.

8. Return the maximum score that player 1 can get from the remaining array.

Code:

The code for the above algorithm is given below:

class Solution:

``````def winner(self, nums, start, end, memo):

# Base case: if the range of the array is empty
if start > end:
return 0

# Check if we have computed the result of the current subproblem before
if (start, end) in memo:
return memo[(start, end)]

# Possible moves for player 1
pick_start = nums[start] + self.winner(nums, start+1, end, memo)
pick_end = nums[end] + self.winner(nums, start, end-1, memo)

# Possible moves for player 2
next_pick_start = self.winner(nums, start+1, end, memo)
next_pick_end = self.winner(nums, start, end-1, memo)

# Store the result obtained from the current subproblem in the memoization table
memo[(start, end)] = max(pick_start - next_pick_start, pick_end - next_pick_end)

# Return the maximum score that player 1 can get from the remaining array
return memo[(start, end)]

def PredictTheWinner(self, nums: List[int]) -> bool:

n = len(nums)
memo = {}

# Determine if player 1 can win
return self.winner(nums, 0, n-1, memo) >= 0
``````

The time complexity of the above solution is O(n^2), where n is the length of the input array. This is because we are solving n^2 subproblems and each subproblem takes O(1) time to solve.

Conclusion:

In this article, we have discussed how to solve the “Predict the Winner” problem on LeetCode. We have used recursion and memoization to simulate the game, and we have determined whether player 1 can win or not. The solution has a time complexity of O(n^2) and avoids recomputation using memoization.

## Step by Step Implementation For Predict The Winner

```public boolean PredictTheWinner(int[] nums) {
return winner(nums, 0, nums.length - 1, 1) >= 0;
}
public int winner(int[] nums, int s, int e, int turn) {
if (s == e)
return turn * nums[s];
int a = turn * nums[s] + winner(nums, s + 1, e, -turn);
int b = turn * nums[e] + winner(nums, s, e - 1, -turn);
return turn * Math.max(turn * a, turn * b);
}```
```This problem can be solved using the minimax algorithm. The minimax algorithm is a way of finding the best move in a game by considering all possible moves and then choosing the move that will give the best result.

In this problem, we are given a list of numbers and we have to choose the move that will give us the maximum sum. We can use the minimax algorithm to find the best move.

First, we need to define a function that will take the list of numbers and return the maximum sum that can be obtained by choosing the best move.

def maximum_sum(nums):

# Base case: if there is only one number, then the maximum sum is that number

if len(nums) == 1:

return nums

# If there are two numbers, then we can either take the first number or the second number

if len(nums) == 2:

return max(nums, nums)

# If there are more than two numbers, then we need to consider all possible moves

# and choose the move that will give us the maximum sum

else:

# We will take the first number and calculate the maximum sum by considering all

# possible moves

max_sum = nums

for i in range(1, len(nums)):

# We will take the first number and calculate the maximum sum by considering all

# possible moves

max_sum = max(max_sum, nums + maximum_sum(nums[i:]))

# We will take the last number and calculate the maximum sum by considering all

# possible moves

max_sum = max(max_sum, nums[-1] + maximum_sum(nums[:-1]))

# Return the maximum sum

return max_sum

Now, we can use the maximum_sum function to find the best move.

nums = [1, 2, 3, 4, 5]

print(maximum_sum(nums))

# Output: 15```
```var PredictTheWinner = function(nums) {

// create a 2D array to store the maximum possible score for each player at each stage of the game
const dp = [];
for (let i = 0; i < nums.length; i++) {
dp.push([]);
for (let j = 0; j < nums.length; j++) {
dp[i].push(0);
}
}

// fill in the base case for the 2D array
for (let i = 0; i < nums.length; i++) {
dp[i][i] = nums[i];
}

// fill in the rest of the 2D array according to the recurrence relation
for (let i = nums.length - 2; i >= 0; i--) {
for (let j = i + 1; j < nums.length; j++) {
dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
}
}

// return true if the first player can always achieve a score greater than or equal to the second player's score
return dp[nums.length - 1] >= 0;

};```
```There are two players. Player 1 is the first player to move and Player 2 is the second player to move. Each player can either choose to take the first element from the array or the last element from the array. The goal is to take more than half of the elements in the array.

You can always assume that Player 1 will play optimally.

int predictTheWinner(vector& nums) {
int n = nums.size();
vector> dp(n, vector(n));
for(int i = 0; i < n; i++) {
dp[i][i] = nums[i];
}
for(int len = 1; len < n; len++) {
for(int i = 0; i < n - len; i++) {
int j = i + len;
dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
}
}
return dp[n - 1] >= 0;
}```
```public class Solution {
public bool PredictTheWinner(int[] nums) {
//dp[i][j] means the max value player 1 can get from i to j
int[,] dp = new int[nums.Length, nums.Length];
for(int i = 0; i < nums.Length; i++) {
dp[i, i] = nums[i];
}
for(int i = nums.Length - 2; i >= 0; i--) {
for(int j = i + 1; j < nums.Length; j++) {
//player 1 picks i, then player 2 can only pick i + 1 or j, then player 1 can pick j or j - 1
//so player 1's max value is nums[i] + Math.Min(dp[i + 1, j - 1], dp[i + 2, j])
//player 1 picks j, then player 2 can only pick i or j - 1, then player 1 can pick i + 1 or i
//so player 1's max value is nums[j] + Math.Min(dp[i + 1, j - 1], dp[i, j - 2])
dp[i, j] = Math.Max(nums[i] + Math.Min(dp[i + 1, j - 1], dp[i + 2, j]), nums[j] + Math.Min(dp[i + 1, j - 1], dp[i, j - 2]));
}
}
return dp[0, nums.Length - 1] >= 0;
}
}```

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]