DP

Author: Skm2000

Diff for: Diameter_Of_Binary_Tree.cpp

@@ -0,0 +1,15 @@
+//Function Written only
+int helper(Node* node,int &res){
+    if(node==NULL) return 0;
+    int left=helper(node->left,res);
+    int right=helper(node->right,res);
+    int tempAns=1+max(left,right);
+    int ans=max(tempAns,1+left+right);
+    res=max(res,ans);
+    return tempAns;
+}
+int diameter(Node* node) {
+    int res=INT_MIN;
+    helper(node,res);
+    return res;
+}

Diff for: Jump_Game_3.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool canReach(vector<int>& arr, int start) {
+        int N = arr.size();
+        vector<int> tab(N, 0);
+        return help(arr, start, tab, N);
+    }
+    bool help(vector<int>& arr, int start, vector<int>& tab, int N) {
+        if ((start < 0 || start > N - 1) || tab[start] == 1) {
+            return false;
+        }
+        if (arr[start] == 0) {
+            return true;
+        }
+        tab[start] = 1;
+        if (help(arr, start-arr[start], tab, N)) {
+            return true;
+        }
+        if (help(arr, start+arr[start], tab, N)) {
+            return true;
+        }
+        return false;
+    }
+};

Diff for: Jump_Game_5.cpp

@@ -0,0 +1,20 @@
+#include<bits/stdc++.h>
+using namespace std;
+//LEETCODE QUESTION
+
+int dp[1001];
+int helper(vector<int>& arr,int d,int i){
+        if(dp[i]!=-1) return dp[i];
+        int ans=1,n=arr.size();
+        //right
+        for(int j=i+1;j<=min(n-1,i+d)&&arr[i]>arr[j];j++)ans=max(ans,1+helper(arr,d,j));
+        //left
+        for(int j=i-1;j>=max(0,i-d)&&arr[i]>arr[j];j--)ans=max(ans,1+helper(arr,d,j));
+        return dp[i]=ans;
+}
+int maxJumps(vector<int>& arr, int d) {
+        int ans=1;
+        for(int i=0;i<arr.size();i++)dp[i]=-1;
+        for(int i=0;i<arr.size();i++)ans=max(ans,helper(arr,d,i));
+        return ans;
+}

Diff for: Last_Stone_3.cpp

@@ -0,0 +1,62 @@
+#include<bits/stdc++.h>
+using namespace std;
+//Leetcode Question
+
+//Recurssion base soln
+int helper(vector<int>& s,int i){
+        if(i>=s.size()) return 0;
+        else{
+            int ans=INT_MIN;
+            ans=max(ans,s[i]-helper(s,i+1));
+            if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));
+            if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-helper(s,i+3));
+            return ans;
+        }
+    }
+string stoneGameIII(vector<int>& s) {
+    int ans=helper(s,0);
+    if(ans<0) return "Bob";
+    else if(ans==0) return "Tie";
+    return "Alice";
+}
+//Memonization based soln
+int dp[500001];
+int helper(vector<int>&s,int i){
+    if(i>=s.size()) return 0;
+    if(dp[i]!=-1) return dp[i];
+    else{
+        int ans=INT_MIN;
+        ans=max(ans,s[i]-helper(s,i+1));
+        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-helper(s,i+2));
+        if(i+2<s.size()) ans=max(ans,dp[i]+dp[i+1]+dp[i+2]-helper(s,i+3));
+        return dp[i]=ans;
+    }
+}
+string stoneGameIII(vector<int>& s) {
+    for(int i=0;i<s.size();i++)dp[i]=-1;
+    int ans=helper(s,0);
+    if(ans<0) return "Bob";
+    else if(ans==0) return "Tie";
+    return "Alice";
+}
+//Bottom Up approach
+string stoneGameIII(vector<int>& s) {
+    int n=s.size();
+    vector<int>dp(n+1,0);
+    int i=n-1;
+    while(i>=0){
+        int ans=INT_MIN;
+        ans=max(ans,s[i]-dp[i+1]);
+        if(i+1<s.size()) ans=max(ans,s[i]+s[i+1]-dp[i+2]);
+        if(i+2<s.size()) ans=max(ans,s[i]+s[i+1]+s[i+2]-dp[i+3]);
+        dp[i]=ans;
+    }
+    int ans=dp[0];
+    if(ans<0) return "Bob";
+    else if(ans==0) return "Tie";
+    return "Alice";
+}
+
+int main(){
+    //take input
+}

Diff for: Maximum_Path_Sum_in_Binary_tree.cpp

@@ -0,0 +1,18 @@
+//Only function Written
+class Solution {
+    int maxToRoot(TreeNode *root, int &re) {
+        if (!root) return 0;
+        int l = maxToRoot(root->left, re);
+        int r = maxToRoot(root->right, re);
+        if (l < 0) l = 0;
+        if (r < 0) r = 0;
+        re=max(re,l+r+root->val);
+        return root->val += max(l, r);
+    }
+public:
+    int maxPathSum(TreeNode *root) {
+        int re = -2147483648;
+        maxToRoot(root, re);
+        return re;
+    }
+};