Merge pull request neetcode-gh#71 from jenishk20/main

C++ Solution to Problem 226,70,746 [ Invert Binary Tree ] , [ Climbing Stairs ] , [ Min-Cost-Climbing-Stairs ]

Author: neetcode-gh

cpp/226_Invert_Binary_Tree.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    void invert(TreeNode *curr)
+    {
+        if(!curr)
+            return;
+        
+        invert(curr->left);
+        invert(curr->right);
+        
+        swap(curr->left,curr->right);
+    }
+    TreeNode* invertTree(TreeNode* root) {
+        
+         invert(root);
+        return root;
+        
+    }
+};

cpp/70. Climbing_Stairs.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int dp[50];
+    int recur(int n)
+    {
+        if(n<=3)
+            return n ;
+        if(dp[n]!=-1)
+            return dp[n];
+        int op1=recur(n-1);
+        int op2=recur(n-2);
+        return dp[n]=op1+op2;
+    }
+    int climbStairs(int n) {
+        memset(dp,-1,sizeof dp);
+        return recur(n);
+    }
+};

cpp/746.Min-Cost-Climbing-Stairs.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int minCostClimbingStairs(vector<int>& cost) {
+        int n=cost.size();
+        int i;
+    int dp[n+1];
+        dp[0]=cost[0];
+        dp[1]=cost[1];
+        for(i=2;i<=n;i++)
+        {
+            dp[i]=min(dp[i-1],dp[i-2])+(i==n?0:cost[i]);
+        }
+        
+        return dp[n];
+    }
+};