leetcode

Author: ayoubzulfiqar

PredictTheWinner/predict_the_winner.dart

@@ -0,0 +1,73 @@
+/*
+
+
+486. 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
+
+*/
+
+
+// BitMask
+class A {
+  bool PredictTheWinner(List<int> arr) {
+    if (arr.length <= 1) return true;
+    final List<int> dp = List.filled(1 << arr.length, 0);
+    int tar = 0;
+    for (int i = 0; i < arr.length; i++) tar += 1 << i;
+    final int val = solve(arr, 0, dp, tar);
+    return val >= 0;
+  }
+
+  int solve(List<int> arr, int current, List<int> dp, int tar) {
+    if (current == tar) return 0; // all integers have been picked
+    if (dp[current] != 0) return dp[current]; // cache
+    int max = -2147483648; // equivalent to Integer.MIN_VALUE
+
+    for (int i = 0; i < arr.length; i++) {
+      // finding first unpicked integer
+      if ((current & (1 << i)) == 0) {
+        max = _max(max, arr[i] - solve(arr, (current | (1 << i)), dp, tar));
+        break;
+      }
+    }
+
+    for (int i = arr.length - 1; i >= 0; i--) {
+      // finding last unpicked integer
+      if ((current & (1 << i)) == 0) {
+        max = _max(max, arr[i] - solve(arr, (current | (1 << i)), dp, tar));
+        break;
+      }
+    }
+    return dp[current] = max;
+  }
+
+  int _max(int a, int b) => a > b ? a : b;
+}

PredictTheWinner/predict_the_winner.go

@@ -0,0 +1,144 @@
+package main
+
+
+/* 
+Slow BitMask
+func PredictTheWinner(arr []int) bool {
+	if len(arr) <= 1 {
+		return true
+	}
+	dp := make([]int, 1<<len(arr))
+	tar := 0
+	for i := 0; i < len(arr); i++ {
+		tar += 1 << i
+	}
+	val := solve(arr, 0, dp, tar)
+	return val >= 0
+}
+
+func solve(arr []int, current int, dp []int, tar int) int {
+	if current == tar {
+		return 0 // all integers have been picked
+	}
+	if dp[current] != 0 {
+		return dp[current] // cache
+	}
+	// max := math.MinInt32
+	max := -2147483648
+
+	for i := 0; i < len(arr); i++ {
+		// finding first unpicked integer
+		if current&(1<<i) == 0 {
+			max = _max(max, arr[i]-solve(arr, (current|(1<<i)), dp, tar))
+			break
+		}
+	}
+
+	for i := len(arr) - 1; i >= 0; i-- {
+		// finding last unpicked integer
+		if current&(1<<i) == 0 {
+			max = _max(max, arr[i]-solve(arr, (current|(1<<i)), dp, tar))
+			break
+		}
+	}
+	dp[current] = max
+	return max
+}
+
+func _max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+
+
+
+// Dynamic Programming
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func PredictTheWinner(nums []int) bool {
+	n := len(nums)
+	dp := make([][]int, n)
+	for i := 0; i < n; i++ {
+		dp[i] = make([]int, n)
+	}
+
+	for i := n - 1; i >= 0; i-- {
+		for j := i; j < n; j++ {
+			if i == j {
+				dp[i][j] = nums[i]
+			} else {
+				dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])
+			}
+		}
+	}
+
+	return dp[0][n-1] >= 0
+}
+
+
+*/
+
+
+
+
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func PredictTheWinner(nums []int) bool {
+	n := len(nums)
+	t := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		t[i] = make([]int, n+1)
+		for j := 0; j <= n; j++ {
+			t[i][j] = -1
+		}
+	}
+	rangeSum := 0
+	for _, n := range nums {
+		rangeSum += n
+	}
+
+	max1 := maxPosAmount(nums, 0, n-1, t)
+	max2 := rangeSum - max1
+	return max1 >= max2
+}
+
+func maxPosAmount(nums []int, i, j int, t [][]int) int {
+	if i > j || i < 0 || j >= len(nums) || i >= len(nums) || j < 0 {
+		return 0
+	}
+	if t[i][j] != -1 {
+		return t[i][j]
+	}
+	f1 := nums[i] + min(maxPosAmount(nums, i+1, j-1, t), maxPosAmount(nums, i+2, j, t))
+	f2 := nums[j] + min(maxPosAmount(nums, i, j-2, t), maxPosAmount(nums, i+1, j-1, t))
+	t[i][j] = max(f1, f2)
+	return t[i][j]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+
+
+
+
+