D. J.:

- Added the leetcode problem and solution for 309, 337 and 714

Author: nobodyPerfecZ

README.md

@@ -203,7 +203,9 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
 - [295 Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/description/)
 - [300 Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+- [309 Best Time to Buy and Sell Stock with Cooldown](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
 - [322 Coin Change](https://leetcode.com/problems/coin-change/description/)
+- [337 House Robber III](https://leetcode.com/problems/house-robber-iii/description/)
 - [373 Find K Pairs with Smallest Sums](https://leetcode.com/problems/find-k-pairs-with-smallest-sums/description/)
 - [377 Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/description/)
 - [380 Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/description/)
@@ -222,6 +224,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [637 Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
 - [673 Number of Longest Increasing Subsequence](https://leetcode.com/problems/number-of-longest-increasing-subsequence/description/)
 - [712 Minimum ASCII Delete Sum for Two Strings](https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/description/)
+- [714 Best Time to Buy and Sell Stock with Transaction Fee](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
 - [740 Delete and Earn](https://leetcode.com/problems/delete-and-earn/description/)
 - [746 Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/description/)
 - [790 Domino and Tromino Tiling](https://leetcode.com/problems/domino-and-tromino-tiling/description/)

awesome_python_leetcode/_309_best_time_to_buy_and_sell_stock_with_cooldown.py

@@ -0,0 +1,42 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+        You are given an array prices where prices[i] is the price of a given stock on
+        the ith day.
+
+        Find the maximum profit you can achieve. You may complete as many transactions
+        as you like (i.e., buy one and sell one share of the stock multiple times) with
+        the following restrictions:
+        - After you sell your stock, you cannot buy stock on the next day
+        (i.e., cooldown one day).
+
+        Note: You may not engage in multiple transactions simultaneously (i.e., you
+        must sell the stock before you buy again).
+        """
+        dp = {}
+
+        def dfs(i: int, buy: bool):
+            if i >= len(prices):
+                return 0
+            if (i, buy) in dp:
+                return dp[(i, buy)]
+            if buy:
+                # Case: Either BUY or COOLDOWN
+                dp[(i, buy)] = max(
+                    dfs(i + 1, not buy) - prices[i],  # BUY
+                    dfs(i + 1, buy),  # COOLDOWN
+                )
+            else:
+                # Case: Either SELL + COOLDOWN or COOLDOWN
+                dp[(i, buy)] = max(
+                    dfs(i + 2, not buy) + prices[i],  # SELL + COOLDOWN
+                    dfs(i + 1, buy),  # COOLDOWN
+                )
+            return dp[(i, buy)]
+
+        return dfs(0, True)

awesome_python_leetcode/_337_house_robber_III.py

@@ -0,0 +1,33 @@
+from typing import Optional, Tuple
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def rob(self, root: Optional[TreeNode]) -> int:
+        """
+        The thief has found himself a new place for his thievery again. There is only
+        one entrance to this area, called root.
+
+        Besides the root, each house has one and only one parent house. After a tour,
+        the smart thief realized that all houses in this place form a binary tree. It
+        will automatically contact the police if two directly-linked houses were broken
+        into on the same night.
+
+        Given the root of the binary tree, return the maximum amount of money the thief
+        can rob without alerting the police.
+        """
+
+        def dfs(root: Optional[TreeNode]) -> Tuple[int, int]:
+            if root is None:
+                return 0, 0
+            left_first, left_second = dfs(root.left)
+            right_first, right_second = dfs(root.right)
+            tmp = max(root.val + left_second + right_second, left_first + right_first)
+            second = left_first + right_first
+            first = tmp
+            return first, second
+
+        return dfs(root)[0]

awesome_python_leetcode/_714_best_time_to_buy_and_sell_stock_with_transaction_fee.py

@@ -0,0 +1,41 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxProfit(self, prices: List[int], fee: int) -> int:
+        """
+        You are given an array prices where prices[i] is the price of a given stock on
+        the ith day, and an integer fee representing a transaction fee.
+
+        Find the maximum profit you can achieve. You may complete as many transactions
+        as you like, but you need to pay the transaction fee for each transaction.
+
+        Note:
+        - You may not engage in multiple transactions simultaneously (i.e., you must
+        sell the stock before you buy again).
+        - The transaction fee is only charged once for each stock purchase and sale.
+        """
+        dp = {}
+
+        def dfs(i: int, buy: bool):
+            if i >= len(prices):
+                return 0
+            if (i, buy) in dp:
+                return dp[(i, buy)]
+            if buy:
+                # Case: Either BUY or SKIP
+                dp[(i, buy)] = max(
+                    dfs(i + 1, not buy) - prices[i],  # BUY
+                    dfs(i + 1, buy),  # SKIP
+                )
+            else:
+                # Case: Either SELL or SKIP
+                dp[(i, buy)] = max(
+                    dfs(i + 1, not buy) + prices[i] - fee,  # SELL
+                    dfs(i + 1, buy),  # SKIP
+                )
+            return dp[(i, buy)]
+
+        return dfs(0, True)

tests/test_309_best_time_to_buy_and_sell_stock_with_cooldown.py

@@ -0,0 +1,20 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._309_best_time_to_buy_and_sell_stock_with_cooldown import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["prices", "expected"],
+    argvalues=[
+        ([1, 2, 3, 0, 2], 3),
+        ([1], 0),
+    ],
+)
+def test_func(prices: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_profit = Solution().maxProfit(prices)
+    assert max_profit == expected

tests/test_337_house_robber_III.py

@@ -0,0 +1,20 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._337_house_robber_III import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "expected"],
+    argvalues=[
+        ([3, 2, 3, None, 3, None, 1], 7),
+        ([3, 4, 5, 1, 3, None, 1], 9),
+    ],
+)
+def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    max_amount = Solution().rob(root)
+    assert max_amount == expected

tests/test_714_best_time_to_buy_and_sell_stock_with_transaction_fee.py

@@ -0,0 +1,21 @@
+# flake8: noqa
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._714_best_time_to_buy_and_sell_stock_with_transaction_fee import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["prices", "fee", "expected"],
+    argvalues=[
+        ([1, 3, 2, 8, 4, 9], 2, 8),
+        ([1, 3, 7, 5, 10, 3], 3, 6),
+    ],
+)
+def test_func(prices: List[int], fee: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_profit = Solution().maxProfit(prices, fee)
+    assert max_profit == expected