git

Author: walkccc

solutions/3562. Maximum Profit from Trading Stocks with Discounts/3562.py

@@ -0,0 +1,51 @@
+class Solution:
+  def maxProfit(
+      self,
+      n: int,
+      present: list[int],
+      future: list[int],
+      hierarchy: list[list[int]],
+      budget: int,
+  ) -> int:
+    tree = [[] for _ in range(n)]
+
+    for u, v in hierarchy:
+      tree[u - 1].append(v - 1)
+
+    @functools.lru_cache(None)
+    def dp(u: int, parent: int) -> tuple[list[int], list[int]]:
+      noDiscount = [0] * (budget + 1)
+      withDiscount = [0] * (budget + 1)
+
+      for v in tree[u]:
+        if v == parent:
+          continue
+        childNoDiscount, childWithDiscount = dp(v, u)
+        noDiscount = self._merge(noDiscount, childNoDiscount)
+        withDiscount = self._merge(withDiscount, childWithDiscount)
+
+      newDp0 = noDiscount[:]
+      newDp1 = noDiscount[:]
+
+      # 1. Buy current node at full cost (no discount)
+      fullCost = present[u]
+      for b in range(fullCost, budget + 1):
+        profit = future[u] - fullCost
+        newDp0[b] = max(newDp0[b], withDiscount[b - fullCost] + profit)
+
+      # 2. Buy current node at half cost (discounted by parent)
+      halfCost = present[u] // 2
+      for b in range(halfCost, budget + 1):
+        profit = future[u] - halfCost
+        newDp1[b] = max(newDp1[b], withDiscount[b - halfCost] + profit)
+
+      return newDp0, newDp1
+
+    return max(dp(0, -1)[0])
+
+  def _merge(self, dpA: list[int], dpB: list[int]) -> list[int]:
+    merged = [-math.inf] * len(dpA)
+    for i, a in enumerate(dpA):
+      for j in range(len(dpA) - i):
+        merged[i + j] = max(merged[i + j], a + dpB[j])
+    return merged

solutions/3563. Lexicographically Smallest String After Adjacent Removals/3563.cpp

@@ -0,0 +1,28 @@
+class Solution {
+ public:
+  string lexicographicallySmallestString(string s) {
+    const int n = s.size();
+    // dp[i][j] := the lexicographically smallest string by removing adjacent
+    // letters from s[i..j)
+    vector<vector<string>> dp(n + 1, vector<string>(n + 1));
+
+    for (int d = 1; d <= n; ++d)
+      for (int i = 0; i + d <= n; ++i) {
+        const int j = i + d;
+        // 1. Keep s[i].
+        string minString = s[i] + dp[i + 1][j];
+        // 2. Remove s[i] and s[k] if possible.
+        for (int k = i + 1; k < j; ++k)
+          if (isConsecutive(s[i], s[k]) && dp[i + 1][k].empty())
+            minString = min(minString, dp[k + 1][j]);
+        dp[i][j] = minString;
+      }
+
+    return dp[0][n];
+  }
+
+ private:
+  bool isConsecutive(char a, char b) {
+    return abs(a - b) == 1 || abs(a - b) == 25;
+  }
+};

solutions/3563. Lexicographically Smallest String After Adjacent Removals/3563.java

@@ -0,0 +1,32 @@
+class Solution {
+  public String lexicographicallySmallestString(String s) {
+    final int n = s.length();
+    // dp[i][j]: the lexicographically smallest string by removing adjacent letters from s[i..j)
+    String[][] dp = new String[n + 1][n + 1];
+
+    // Initialize dp[i][i] = "" for all i.
+    for (int i = 0; i <= n; ++i)
+      dp[i][i] = "";
+
+    for (int d = 1; d <= n; ++d)
+      for (int i = 0; i + d <= n; ++i) {
+        final int j = i + d;
+        // 1. Keep s[i].
+        String minString = s.charAt(i) + dp[i + 1][j];
+        // 2. Remove s[i] and s[k] if possible.
+        for (int k = i + 1; k < j; ++k)
+          if (isConsecutive(s.charAt(i), s.charAt(k)) && dp[i + 1][k].isEmpty()) {
+            final String candidate = dp[k + 1][j];
+            if (candidate.compareTo(minString) < 0)
+              minString = candidate;
+          }
+        dp[i][j] = minString;
+      }
+
+    return dp[0][n];
+  }
+
+  private boolean isConsecutive(char a, char b) {
+    return Math.abs(a - b) == 1 || Math.abs(a - b) == 25;
+  }
+}

solutions/3563. Lexicographically Smallest String After Adjacent Removals/3563.py

@@ -0,0 +1,24 @@
+class Solution:
+  def lexicographicallySmallestString(self, s: str) -> str:
+    n = len(s)
+    # dp[i][j]: the lexicographically smallest string by removing adjacent
+    # letters from s[i..j)
+    dp = [[''] * (n + 1) for _ in range(n + 1)]
+
+    for d in range(1, n + 1):
+      for i in range(n - d + 1):
+        j = i + d
+        # 1. Keep s[i].
+        minString = s[i] + dp[i + 1][j]
+        # 2. Remove s[i] and s[k] if possible.
+        for k in range(i + 1, j):
+          if self._isConsecutive(s[i], s[k]) and dp[i + 1][k] == '':
+            candidate = dp[k + 1][j]
+            if candidate < minString:
+              minString = candidate
+        dp[i][j] = minString
+
+    return dp[0][n]
+
+  def _isConsecutive(self, a: str, b: str) -> bool:
+    return abs(ord(a) - ord(b)) == 1 or abs(ord(a) - ord(b)) == 25