D. J.:

- Added the Leetcode problems and solutions for 354, 646, 1027, 1218, and 1964

Author: nobodyPerfecZ

README.md

@@ -206,6 +206,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [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/)
+- [354 Russian Doll Envelopes](https://leetcode.com/problems/russian-doll-envelopes/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 +223,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [518 Coin Change II](https://leetcode.com/problems/coin-change-ii/description/)
 - [530 Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 - [637 Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
+- [646 Maximum Length of Pair Chain](https://leetcode.com/problems/maximum-length-of-pair-chain/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/)
@@ -232,12 +234,15 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [918 Maximum Sum Circular Subarray](https://leetcode.com/problems/maximum-sum-circular-subarray/description/)
 - [931 Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/description/)
 - [983 Minimum Cost for Tickets](https://leetcode.com/problems/minimum-cost-for-tickets/description/)
+- [1027 Longest Arithmetic Subsequence](https://leetcode.com/problems/longest-arithmetic-subsequence/description/)
 - [1035 Uncrossed Lines](https://leetcode.com/problems/uncrossed-lines/description/)
 - [1137 N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/description/)
 - [1143 Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/description/)
+- [1218 Longest Arithmetic Subsequence of Given Difference](https://leetcode.com/problems/longest-arithmetic-subsequence-of-given-difference/description/)
 - [1312 Minimum Insertion Steps to Make a String Palindrome](https://leetcode.com/problems/minimum-insertion-steps-to-make-a-string-palindrome/description/)
 - [1534 Count Good Triplets](https://leetcode.com/problems/count-good-triplets/description)
 - [1922 Count Good Numbers](https://leetcode.com/problems/count-good-numbers/description/)
+- [1964 Find the Longest Valid Obstacle Course at Each Position](https://leetcode.com/problems/find-the-longest-valid-obstacle-course-at-each-position/description/)
 - [2140 Solving Questions With Brainpower](https://leetcode.com/problems/solving-questions-with-brainpower/description/)
 - [2466 Count Ways To Build Good Strings](https://leetcode.com/problems/count-ways-to-build-good-strings/description/)
 

awesome_python_leetcode/_1027_longest_arithmetic_subsequence.py

@@ -0,0 +1,24 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestArithSeqLength(self, nums: List[int]) -> int:
+        """
+        Given an array nums of integers, return the length of the longest arithmetic
+        subsequence in nums.
+
+        Note that:
+        - A subsequence is an array that can be derived from another array by deleting
+        some or no elements without changing the order of the remaining elements.
+        - A sequence seq is arithmetic if seq[i + 1] - seq[i] are all the same value
+        (for 0 <= i < seq.length - 1).
+        """
+        dp = [collections.defaultdict(int) for _ in range(len(nums))]
+        for i in range(len(nums) - 2, -1, -1):
+            for j in range(i + 1, len(nums)):
+                diff = nums[j] - nums[i]
+                dp[i][diff] = max(dp[i][diff], 1 + dp[j][diff])
+        return 1 + max([max(dp_i.values()) for dp_i in dp])

awesome_python_leetcode/_1218_longest_arithmetic_subsequence_of_given_difference.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestSubsequence(self, arr: List[int], difference: int) -> int:
+        """
+        Given an integer array arr and an integer difference, return the length of the
+        longest subsequence in arr which is an arithmetic sequence such that the
+        difference between adjacent elements in the subsequence equals difference.
+
+        A subsequence is a sequence that can be derived from arr by deleting some or no
+        elements without changing the order of the remaining elements.
+        """
+        dp = {}
+        result = 0
+        for i in range(len(arr)):
+            if arr[i] - difference in dp:
+                dp[arr[i]] = dp[arr[i] - difference] + 1
+            else:
+                dp[arr[i]] = 1
+            result = max(result, dp[arr[i]])
+        return result

awesome_python_leetcode/_1964_find_the_longest_valid_obstacle_course_at_each_position.py

@@ -0,0 +1,32 @@
+import bisect
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestObstacleCourseAtEachPosition(self, obstacles: List[int]) -> List[int]:
+        """
+        You want to build some obstacle courses. You are given a 0-indexed integer array
+        obstacles of length n, where obstacles[i] describes the height of the ith
+        obstacle.
+
+        For every index i between 0 and n - 1 (inclusive), find the length of the
+        longest obstacle course in obstacles such that:
+        - You choose any number of obstacles between 0 and i inclusive.
+        - You must include the ith obstacle in the course.
+        - You must put the chosen obstacles in the same order as they appear in
+        obstacles.
+        - Every obstacle (except the first) is taller than or the same height as the
+        obstacle immediately before it.
+
+        Return an array ans of length n, where ans[i] is the length of the longest
+        obstacle course for index i as described above.
+        """
+        results = []
+        dp = [float("inf") for _ in range(len(obstacles) + 1)]
+        for k in range(len(obstacles)):
+            i = bisect.bisect(dp, obstacles[k])
+            results.append(i + 1)
+            dp[i] = obstacles[k]
+        return results

awesome_python_leetcode/_354_russian_doll_envelopes.py

@@ -0,0 +1,56 @@
+import bisect
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxEnvelopesBS(self, envelopes: List[List[int]]) -> int:
+        """
+        You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi]
+        represents the width and the height of an envelope.
+
+        One envelope can fit into another if and only if both the width and height of
+        one envelope are greater than the other envelope's width and height.
+
+        Return the maximum number of envelopes you can Russian doll (i.e., put one
+        inside the other).
+
+        Note: You cannot rotate an envelope.
+        """
+        # BS Solution: O(n log n)
+        envelopes = sorted(envelopes, key=lambda x: (x[0], -x[1]))
+        seq = [envelopes[0]]
+        for k in range(1, len(envelopes)):
+            if envelopes[k][1] > seq[-1][1]:
+                seq.append(envelopes[k])
+            else:
+                i = bisect.bisect_left(seq, envelopes[k][1], key=lambda x: x[1])
+                seq[i] = envelopes[k]
+        return len(seq)
+
+    def maxEnvelopesDP(self, envelopes: List[List[int]]) -> int:
+        """
+        You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi]
+        represents the width and the height of an envelope.
+
+        One envelope can fit into another if and only if both the width and height of
+        one envelope are greater than the other envelope's width and height.
+
+        Return the maximum number of envelopes you can Russian doll (i.e., put one
+        inside the other).
+
+        Note: You cannot rotate an envelope.
+        """
+        # DP (LIS) Solution: O(n^2)
+        # Invalid: TLE
+        envelopes = sorted(envelopes)
+        dp = [1 for _ in range(len(envelopes))]
+        for i in range(len(envelopes) - 2, -1, -1):
+            for j in range(i + 1, len(envelopes)):
+                if (
+                    envelopes[i][0] < envelopes[j][0]
+                    and envelopes[i][1] < envelopes[j][1]
+                ):
+                    dp[i] = max(dp[i], 1 + dp[j])
+        return max(dp)

awesome_python_leetcode/_646_maximum_length_of_pair_chain.py

@@ -0,0 +1,26 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findLongestChain(self, pairs: List[List[int]]) -> int:
+        """
+        You are given an array of n pairs pairs where pairs[i] = [lefti, righti] and
+        lefti < righti.
+
+        A pair p2 = [c, d] follows a pair p1 = [a, b] if b < c. A chain of pairs can be
+        formed in this fashion.
+
+        Return the length longest chain which can be formed.
+
+        You do not need to use up all the given intervals. You can select pairs in any
+        order.
+        """
+        pairs = sorted(pairs)
+        dp = [1 for _ in range(len(pairs))]
+        for i in range(len(pairs) - 2, -1, -1):
+            for j in range(i + 1, len(pairs)):
+                if pairs[i][1] < pairs[j][0]:
+                    dp[i] = max(dp[i], 1 + dp[j])
+        return max(dp)

tests/test_1027_longest_arithmetic_subsequence.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._1027_longest_arithmetic_subsequence import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([3, 6, 9, 12], 4),
+        ([9, 4, 7, 2, 10], 3),
+        ([20, 1, 15, 3, 10, 5, 8], 4),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    longest_arithmetic_sequence = Solution().longestArithSeqLength(nums)
+    assert longest_arithmetic_sequence == expected

tests/test_1218_longest_arithmetic_subsequence_of_given_difference.py

@@ -0,0 +1,22 @@
+# flake8: noqa
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._1218_longest_arithmetic_subsequence_of_given_difference import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["arr", "difference", "expected"],
+    argvalues=[
+        ([1, 2, 3, 4], 1, 4),
+        ([1, 3, 5, 7], 1, 1),
+        ([1, 5, 7, 8, 5, 3, 4, 2, 1], -2, 4),
+    ],
+)
+def test_func(arr: List[int], difference: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    longest_subsequence = Solution().longestSubsequence(arr, difference)
+    assert longest_subsequence == expected

tests/test_1964_find_the_longest_valid_obstacle_course_at_each_position.py

@@ -0,0 +1,22 @@
+# flake8: noqa
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._1964_find_the_longest_valid_obstacle_course_at_each_position import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["obstacles", "expected"],
+    argvalues=[
+        ([1, 2, 3, 2], [1, 2, 3, 3]),
+        ([2, 2, 1], [1, 2, 1]),
+        ([3, 1, 5, 6, 4, 2], [1, 1, 2, 3, 2, 2]),
+    ],
+)
+def test_func(obstacles: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    longest_obstacles = Solution().longestObstacleCourseAtEachPosition(obstacles)
+    assert longest_obstacles == expected

tests/test_354_russian_doll_envelopes.py

@@ -0,0 +1,33 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._354_russian_doll_envelopes import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["envelopes", "expected"],
+    argvalues=[
+        ([[5, 4], [6, 4], [6, 7], [2, 3]], 3),
+        ([[1, 1], [1, 1], [1, 1]], 1),
+        ([[4, 5], [4, 6], [6, 7], [2, 3], [1, 1]], 4),
+    ],
+)
+def test_func_bs(envelopes: List[List[int]], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_envelopes = Solution().maxEnvelopesBS(envelopes)
+    assert max_envelopes == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["envelopes", "expected"],
+    argvalues=[
+        ([[5, 4], [6, 4], [6, 7], [2, 3]], 3),
+        ([[1, 1], [1, 1], [1, 1]], 1),
+        ([[4, 5], [4, 6], [6, 7], [2, 3], [1, 1]], 4),
+    ],
+)
+def test_func_dp(envelopes: List[List[int]], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_envelopes = Solution().maxEnvelopesDP(envelopes)
+    assert max_envelopes == expected