did some DP problems from leetcode

Author: Github11200

Solutions/Leetcode Solutions/medium/maximalSquare.cpp

@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/maximal-square/description/
+  Runtime: 53.92%
+  Memory: 33.98%
+******************************************/
+
+int maximalSquare(vector<vector<char>> &matrix)
+{
+  int width = matrix[0].size();
+  int height = matrix.size();
+  int maxLength = INT_MIN;
+
+  vector<vector<int>> dp(height, vector<int>(width, 0));
+  for (int i = 0; i < height; ++i)
+  {
+    for (int j = 0; j < width; ++j)
+    {
+      if (matrix[i][j] == '1')
+      {
+        dp[i][j] = 1;
+        if (i > 0 && j > 0)
+          dp[i][j] += min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]});
+        maxLength = max(maxLength, dp[i][j]);
+      }
+    }
+  }
+
+  return maxLength * maxLength;
+}
+
+int main()
+{
+  vector<vector<char>> matrix({{'1', '1', '1', '1', '0'},
+                               {'1', '1', '1', '1', '0'},
+                               {'1', '1', '1', '1', '1'},
+                               {'1', '1', '1', '1', '1'},
+                               {'0', '0', '1', '1', '1'}});
+
+  cout << maximalSquare(matrix) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/minimumFallingPathSum.cpp

@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/minimum-falling-path-sum/description/
+  Runtime: 100.00%
+  Memory: 91.04%
+******************************************/
+
+int minimumFallingPathSum(vector<vector<int>> &matrix)
+{
+  int width = matrix[0].size();
+  int height = matrix.size();
+
+  vector<int> row = matrix[height - 1];
+
+  for (int i = height - 2; i >= 0; --i)
+  {
+    for (int j = 0; j < width; ++j)
+    {
+      int minSum = INT_MAX;
+      for (int k = (j > 0 ? j - 1 : 0); k <= (j < width - 1 ? j + 1 : j); ++k)
+        minSum = min(minSum, row[k] + matrix[i][j]);
+      matrix[i][j] = minSum;
+    }
+    row = matrix[i];
+  }
+
+  int minElement = INT_MAX;
+  for (int i = 0; i < row.size(); ++i)
+    minElement = min(minElement, row[i]);
+  return minElement;
+}
+
+int main()
+{
+  vector<vector<int>> matrix({{100, -42, -46, -41}, {31, 97, 10, -10}, {-58, -51, 82, 89}, {51, 81, 69, -51}});
+  cout << minimumFallingPathSum(matrix) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/minimumPathSum

@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/triangle/description/
+  Runtime: 100.00%
+  Memory: 82.28%
+******************************************/
+
+int Triangle(vector<vector<int>> &triangle)
+{
+  vector<int> sums(triangle[triangle.size() - 1].size(), 0);
+  for (int i = 0; i < sums.size(); ++i)
+    sums[i] = triangle[triangle.size() - 1][i];
+
+  for (int i = triangle.size() - 1; i > 0; --i)
+    for (int j = 0; j < i; ++j)
+      sums[j] = min(sums[j], sums[j + 1]) + triangle[i - 1][j];
+
+  return sums[0];
+}
+
+int main()
+{
+  vector<vector<int>> triangle({{2}, {3, 4}, {6, 5, 7}, {4, 1, 8, 3}});
+  cout << Triangle(triangle) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/triangle.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/unique-paths-ii/description/
+  Runtime: 100.00%
+  Memory: 89.22%
+******************************************/
+
+int uniquePaths2(vector<vector<int>> &obstacleGrid)
+{
+  int width = obstacleGrid[0].size();
+  int height = obstacleGrid.size();
+
+  if (obstacleGrid[height - 1][width - 1] == 1 || obstacleGrid[0][0] == 1)
+    return 0;
+
+  vector<int> previousRow(width, 1);
+  for (int i = width - 2; i >= 0; --i)
+  {
+    previousRow[i] = previousRow[i + 1];
+    if (obstacleGrid[height - 1][i] == 1)
+      previousRow[i] = 0;
+  }
+
+  int right = 0;
+  for (int i = height - 2; i >= 0; --i)
+  {
+    if (obstacleGrid[i][width - 1] == 1)
+      right = 0;
+    else
+      right = previousRow[width - 1];
+    previousRow[width - 1] = right;
+    for (int j = width - 2; j >= 0; --j)
+    {
+      if (obstacleGrid[i][j] == 1)
+        previousRow[j] = 0;
+      else
+        previousRow[j] += right;
+      right = previousRow[j];
+    }
+  }
+
+  return previousRow[0];
+}
+
+int main()
+{
+  vector<vector<int>> obstacles({{0, 0}, {1, 1}, {0, 0}});
+  cout << uniquePaths2(obstacles) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/uniquePaths2.cpp

@@ -2,24 +2,63 @@
 
 using namespace std;
 
-void interativeInOrderTraversal(TreeNode *root)
+int deleteAndEarn(vector<int> &nums)
 {
-  stack<TreeNode *> nextNodes;
-  while (!nextNodes.empty() || root != nullptr)
+  sort(nums.begin(), nums.end());
+  vector<int> numsPrime;
+
+  unordered_map<int, int> counts;
+
+  for (int i = 0; i < nums.size(); ++i)
+  {
+    if (i == 0 || nums[i] != nums[i - 1])
+      numsPrime.push_back(nums[i]);
+    ++counts[nums[i]];
+  }
+
+  vector<int> dp(numsPrime.size(), 0);
+  for (int i = 0; i < numsPrime.size(); ++i)
   {
-    while (root != nullptr)
-    {
-      nextNodes.push(root);
-      root = root->left;
-    }
-    root = nextNodes.top();
-    printf("%d ", root->val);
-    nextNodes.pop();
-    root = root->right;
+    int value = numsPrime[i] * counts[numsPrime[i]];
+    if (i > 0 && numsPrime[i] - numsPrime[i - 1] == 1)
+      dp[i] = max(dp[i - 1], value + (i >= 2 ? dp[i - 2] : 0));
+    else if (i > 0)
+      dp[i] = value + dp[i - 1];
+    else
+      dp[i] = value;
   }
+
+  return dp[dp.size() - 1];
+}
+
+int subarraySumEqualsK(vector<int> &nums, int k)
+{
+  unordered_map<int, int> prefixSumsCount;
+  prefixSumsCount[0] = 1;
+
+  int prefixSum = 0;
+  int diff = 0;
+  int numberOfSubarrays = 0;
+
+  for (int i = 0; i < nums.size(); ++i)
+  {
+    prefixSum += nums[i];
+    diff = prefixSum - k;
+
+    if (prefixSumsCount.count(diff))
+      numberOfSubarrays += prefixSumsCount[diff];
+    if (prefixSumsCount.count(prefixSum))
+      ++prefixSumsCount[prefixSum];
+    else
+      prefixSumsCount[prefixSum] = 1;
+  }
+
+  return numberOfSubarrays;
 }
 
 int main()
 {
+  vector<int> nums({2, 2, 3, 3, 3, 4});
+  cout << deleteAndEarn(nums) << endl;
   return 0;
 }