did some more DP problems

Author: Github11200

Solutions/Leetcode Solutions/medium/deleteAndEarn.cpp

@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/delete-and-earn/description/
+  Runtime: 67.76%
+  Memory: 61.45%
+******************************************/
+
+int deleteAndEarn(vector<int> &nums)
+{
+  unordered_map<int, int> counts;
+  vector<int> numsPrime;
+
+  sort(nums.begin(), nums.end());
+  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);
+  dp[0] = numsPrime[0] * counts[numsPrime[0]];
+  for (int i = 1; i < numsPrime.size(); ++i)
+  {
+    int value = 0;
+    value += numsPrime[i] * counts[numsPrime[i]];
+    if (numsPrime[i] - numsPrime[i - 1] > 1)
+      dp[i] = value + dp[i - 1];
+    else
+      dp[i] = max(value + (i >= 2 ? dp[i - 2] : 0), dp[i - 1]);
+  }
+
+  return dp[dp.size() - 1];
+}
+
+int main()
+{
+  vector<int> nums({2, 3, 4});
+  cout << deleteAndEarn(nums) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/minimumPathSum

@@ -0,0 +1,40 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/minimum-path-sum/description/
+  Runtime: 100.00%
+  Memory: 75.54%
+******************************************/
+
+int minimumPathSum(vector<vector<int>> &grid)
+{
+  vector<int> current(grid[0].size(), 0);
+  current[grid[0].size() - 1] = grid[grid.size() - 1][grid[0].size() - 1];
+  for (int i = grid[0].size() - 2; i >= 0; --i)
+    current[i] = grid[grid.size() - 1][i] + current[i + 1];
+
+  int right = 0;
+  int initialRight = 0;
+  for (int i = grid.size() - 2; i >= 0; --i)
+  {
+    initialRight = current[grid[0].size() - 1] + grid[i][grid[0].size() - 1];
+    right = current[grid[0].size() - 1] + grid[i][grid[0].size() - 1];
+    for (int j = grid[0].size() - 2; j >= 0; --j)
+    {
+      current[j] = min(grid[i][j] + current[j], grid[i][j] + right);
+      right = current[j];
+    }
+    current[grid[0].size() - 1] = initialRight;
+  }
+
+  return current[0];
+}
+
+int main()
+{
+  vector<vector<int>> grid({{1, 2}, {5, 6}, {1, 1}});
+  cout << minimumPathSum(grid) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/minimumPathSum.cpp

@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/unique-paths/description/
+  Runtime: 100.0%
+  Memory: 83.19%
+******************************************/
+
+int uniquePaths(int m, int n)
+{
+  if (m == 1 || n == 1)
+    return 1;
+
+  vector<int> current(n, 1);
+  int right = 1;
+  for (int i = m - 2; i >= 0; --i)
+  {
+    right = 1;
+    for (int j = n - 2; j >= 0; --j)
+    {
+      current[j] += right;
+      right = current[j];
+    }
+  }
+
+  return current[0];
+}
+
+int main()
+{
+  cout << uniquePaths(3, 7) << endl;
+  return 0;
+}