Merge pull request rachitiitr#50 from rachitiitr/youtube_live_hindi

LIVE_YOUTUBE - Developer Bhaiya - 3 problems
https://youtu.be/_I8q2nFu47I
First Problem:
https://leetcode.com/problems/best-time-to-buy-and-sell-stock
Second problem: https://leetcode.com/problems/stone-game/
Third problem: https://leetcode.com/problems/jump-game/
https://www.youtube.com/watch?v=4KAQ6UViDoE
+1 -1 trick: https://www.youtube.com/watch?v=ERAHSoAk2Yo

Author: rachitiitr

LeetCode/121.best-time-to-buy-and-sell-stock.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int n = prices.size();
+        int ans = 0, suff_max = prices.back();
+        for(int i = n-2; i >= 0; i--) {
+            ans = max(ans, suff_max - prices[i]);
+            suff_max = max(suff_max, prices[i]);
+            /*
+            for(int j = i+1; j < n; j++) {
+                ans = max(ans, prices[j] - prices[i]);
+            }
+            */
+        }
+        return ans;     
+    }
+};
+/*
+        <---100--->
+_ _ _ 120 _ _ _ _ _ _ 
+    i            
+    
+    max = 100
+    */
+
+

LeetCode/55.jump-game.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int n = nums.size();
+        vector<bool> allowed(n, 0); // O(n) extra space
+        allowed[0] = 1;
+        for (int i = 0; i < n; i++) {
+            if (allowed[i]) {
+                for(int j = min(n-1, i+nums[i]); j >= i+1; j--) {
+                    if(allowed[j]) break;
+                    allowed[j] = 1;
+                }
+            }
+        }
+        return allowed[n-1];
+    }
+};
+
+/*
+_ _ _ 7 _ _ 1 1 1 1 1 _ 
+      i x x x x x x x
+      
+if i is allowerd and 100
+      i+1,i+2,...,i+100 <-- allowed
+      
+whether n-1 is allowed <-- true / false
+      
+   */   
+      
+     

LeetCode/877.stone-game.cpp

@@ -0,0 +1,63 @@
+#define deb(x1, x2, x3) cout << #x1 << "=" << x1 << " " << #x2 << "=" << x2 << " "<< #x3 << "=" << x3 << endl;
+
+class Solution {
+public:
+    bool stoneGame(vector<int>& piles) {
+        int n = piles.size();
+    // dp[i][j] = max profit for first player when the game is at state [i..j]
+        vector<vector<int>> dp(n, vector<int>(n, 0));
+        for(int i = 0; i < n; i++) {
+            dp[i][i] = piles[i]; // 1 size subarrays have been computed
+            // if(i+1 < n) {
+            //     dp[i][i+1] = abs(piles[i] - piles[i+1]); // subarrays of size 2
+            // }
+        }
+        for(int len = 2; len <= n; len++) {
+            for(int i = 0; i < n; i++) {
+                int j = i + len - 1;
+                if(j >= n) continue;
+                // i .. j
+                // take the Lth stone
+                int choice1 = piles[i] - dp[i+1][j];
+
+                // take the Rth stone
+                int choice2 = piles[j] - dp[i][j-1];
+                dp[i][j] = max(choice1, choice2);
+                // cout << i << " " << j << " " << dp[i][j] << endl;
+                // deb(i, j, dp[i][j]);
+            }
+        }
+        
+        
+        return dp[0][n-1] > 0;
+    }
+};
+
+/*
+5, 3, 4, 5 -> 3,4,5 -> 3,4 -> 3
+    
+    5
+    <---------------------->17 ==> 17 - 5 = 12
+    23,....................,17
+    23<----------------------> ===> 23-7 = 16
+            7 
+    
+    
+state = [L, R] => by how much quantity the first player wins
+
+
+[0, n-1] => +ve => first player can win -> true
+[0, n-1] => -ve => first player cant win -> false
+    
+// take the Lth stone
+choice1 = piles[L] - win(L+1, R)
+    
+// take the Rth stone
+choice2 = piles[R] - win(L, R-1)
+    
+win(L, R) = max(choice1, choice2);
+
+return win(0, n-1) > 0 
+    
+*/
+