add: previously solved DP questions

Author: Ashutosh00710

Diff for: DynamicProgramming/CounSquareSubmatricesWithAllOnes.cpp

@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    int countSquares(vector<vector<int>>& matrix) {
+        int col = matrix[0].size(), row = matrix.size();
+        int result = 0;
+        for(int i = 0; i < row; i++) {
+            for(int j = 0; j < col; j++) {
+                if(matrix[i][j] == 1) {
+                    if(i == 0 || j == 0) {
+                        result += 1;
+                    }
+                    else {
+                       int res = min(
+                           { matrix[i - 1][j - 1], matrix[i][j - 1], matrix[i - 1][j] }
+                       ) + matrix[i][j];
+                       result += res;
+                       matrix[i][j] = res;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};
+
+int main () {
+    Solution s;
+    vector<vector<int>> matrix = {{1,0,1,0,0},
+                                  {1,0,1,1,1},
+                                  {1,1,1,1,1},
+                                  {1,0,0,1,0}};
+    cout << s.countSquares(matrix) << endl;
+    return 0;
+}

Diff for: DynamicProgramming/CountSortedVowelStrings.js

@@ -0,0 +1,18 @@
+function countVowelStrings(n) {
+  const chars = ["a", "e", "i", "o", "u"];
+  let res = [];
+  function dfs(word) {
+    if (word.length === n) {
+      res.push(word);
+      return;
+    }
+
+    for (let i = 0; i < chars.length; i++) {
+      if (chars[i] >= word.charAt(word.length - 1)) {
+        dfs(word + chars[i]);
+      }
+    }
+  }
+  dfs("");
+  return res.length;
+}

Diff for: DynamicProgramming/MinCostClimbingStairs.js

@@ -0,0 +1,13 @@
+function minCostClimbingStairs(costs) {
+  let first = costs[0];
+  let second = costs[1];
+  let i = 0;
+  if (costs.length <= 2) return Math.min(first, second);
+  else i = 2;
+  for (; i < costs.length; i++) {
+    let current = costs[i] + Math.min(first, second);
+    first = second;
+    second = current;
+  }
+  return Math.min(first, second);
+}

Diff for: DynamicProgramming/PascalsTriangle.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+const generate = function (numRows) {
+  let pascalTriangle = [];
+  for (let i = 0; i < numRows; i++) {
+    const col = new Array(i + 1).fill(1);
+    for (let j = 1; j < i; j++) {
+      col[j] = pascalTriangle[i - 1][j - 1] + pascalTriangle[i - 1][j];
+    }
+    pascalTriangle.push(col);
+  }
+  return pascalTriangle;
+};

Diff for: array/BestTimeToBuyandSell.cpp

@@ -14,21 +14,13 @@ class Solution {
         }
         return maxSoFar;
     }
-
-    int maxProfitSecondApproach(vector<int>& prices) {
-        int max = 0;
-        for(int i = 1;  i < prices.size(); i++) {
-            if(prices[i] > prices[i - 1]) max += prices[i] - prices[i - 1];
-        }
-        return max;
-    }
 };
 
 int main() {
     Solution sol;
     vector<int> test1 = {7,1,5,3,6,4};
     vector<int> test2 = {7,6,4,3,1};
-    cout << sol.maxProfitSecondApproach(test1) << endl;
-    cout << sol.maxProfitSecondApproach(test2) << endl;
+    cout << sol.maxProfit(test1) << endl;
+    cout << sol.maxProfit(test2) << endl;
     return 0;
 }