In this guide, you will get 486. Predict the Winner LeetCode Solution with the best time and space complexity. The solution to Predict the Winner problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.
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.
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
Complexity Analysis
Time Complexity: O(n^2)
Space Complexity: O(n^2)
486. Predict the Winner LeetCode Solution in C++
class Solution {
public:
bool PredictTheWinner(vector<int>& nums) {
const int n = nums.size();
// dp[i][j] := the maximum number you can get more than your opponent in
// nums[i..j]
vector<vector<int>> dp(n, vector<int>(n));
for (int i = 0; i < n; ++i)
dp[i][i] = nums[i];
for (int d = 1; d < n; ++d)
for (int i = 0; i + d < n; ++i) {
const int j = i + d;
dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
}
return dp[0][n - 1] >= 0;
}
}; /* code provided by PROGIEZ */
486. Predict the Winner LeetCode Solution in Java
class Solution {
public boolean PredictTheWinner(int[] nums) {
final int n = nums.length;
// dp[i][j] := the maximum number you can get more than your opponent in nums[i..j]
int[][] dp = new int[n][n];
for (int i = 0; i < n; ++i)
dp[i][i] = nums[i];
for (int d = 1; d < n; ++d)
for (int i = 0; i + d < n; ++i) {
final int j = i + d;
dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
}
return dp[0][n - 1] >= 0;
}
} // code provided by PROGIEZ
486. Predict the Winner LeetCode Solution in Python
class Solution {
public:
bool PredictTheWinner(vector<int>& nums) {
const int n = nums.size();
vector<int> dp = nums;
for (int d = 1; d < n; ++d)
for (int j = n - 1; j - d >= 0; --j) {
const int i = j - d;
dp[j] = max(nums[i] - dp[j], // Pick the leftmost number.
nums[j] - dp[j - 1]); // Pick the rightmost number.
}
return dp[n - 1] >= 0;
}
}; # code by PROGIEZ
