D. J.:

- Added the leetcode problems and solutions for 115, 279, 516, 518, 673, 712, 1143, 1534 and 1922

Author: nobodyPerfecZ

README.md

@@ -133,6 +133,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [108 Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
 - [112 Path Sum](https://leetcode.com/problems/path-sum/description/)
 - [114 Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/)
+- [115 Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/description/)
 - [117 Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/description/)
 - [118 Pascals Triangle](https://leetcode.com/problems/pascals-triangle/description/)
 - [120 Triangle](https://leetcode.com/problems/triangle/description/)
@@ -194,6 +195,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [238 Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/description/)
 - [242 Valid Anagram](https://leetcode.com/problems/valid-anagram/description/)
 - [274 H-Index](https://leetcode.com/problems/h-index/description/)
+- [279 Perfect Squares](https://leetcode.com/problems/perfect-squares/description/)
 - [289 Game of Life](https://leetcode.com/problems/game-of-life/description/)
 - [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/)
@@ -209,14 +211,21 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [452 Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
 - [502 IPO](https://leetcode.com/problems/ipo/description/)
 - [509 Fibonacci Number](https://leetcode.com/problems/fibonacci-number/description/)
+- [516 Longest Palindromic Subsequence](https://leetcode.com/problems/longest-palindromic-subsequence/description/)
+- [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/)
+- [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/)
 - [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/)
 - [909 Snakes and Ladders](https://leetcode.com/problems/snakes-and-ladders/description/)
 - [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/)
 - [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/)
+- [1534 Count Good Triplets](https://leetcode.com/problems/count-good-triplets/description)
+- [1922 Count Good Numbers](https://leetcode.com/problems/count-good-numbers/description/)
 
 ## Development 🔧
 

awesome_python_leetcode/_1143_longest_common_subsequence.py

@@ -0,0 +1,25 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        """
+        Given two strings text1 and text2, return the length of their longest common
+        subsequence. If there is no common subsequence, return 0.
+
+        A subsequence of a string is a new string generated from the original string
+        with some characters (can be none) deleted without changing the relative order
+        of the remaining characters.
+        - For example, "ace" is a subsequence of "abcde".
+
+        A common subsequence of two strings is a subsequence that is common to both
+        strings.
+
+        """
+        dp = [[0 for _ in range(len(text2) + 1)] for _ in range(len(text1) + 1)]
+        for i in range(len(text1) - 1, -1, -1):
+            for j in range(len(text2) - 1, -1, -1):
+                if text1[i] == text2[j]:
+                    dp[i][j] = 1 + dp[i + 1][j + 1]
+                else:
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j + 1])
+        return dp[0][0]

awesome_python_leetcode/_115_distinct_subsequences.py

@@ -0,0 +1,22 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numDistinct(self, s: str, t: str) -> int:
+        """
+        Given two strings s and t, return the number of distinct subsequences of s
+        which equals t.
+
+        The test cases are generated so that the answer fits on a 32-bit signed
+        integer.
+        """
+        dp = [[0 for _ in range(len(t) + 1)] for _ in range(len(s) + 1)]
+        for i in range(len(s)):
+            dp[i][0] = 1
+
+        for i in range(1, len(s) + 1):
+            for j in range(1, len(t) + 1):
+                if s[i - 1] == t[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
+                else:
+                    dp[i][j] = dp[i - 1][j]
+        return dp[-1][-1]

awesome_python_leetcode/_1534_count_good_triplets.py

@@ -0,0 +1,37 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
+        """
+        Given an array of integers arr, and three integers a, b and c. You need to
+        find the number of good triplets.
+
+        A triplet (arr[i], arr[j], arr[k]) is good if the following conditions are true:
+        - 0 <= i < j < k < arr.length
+        - |arr[i] - arr[j]| <= a
+        - |arr[j] - arr[k]| <= b
+        - |arr[i] - arr[k]| <= c
+
+        Where |x| denotes the absolute value of x.
+
+        Return the number of good triplets.
+        """
+        count = 0
+        prefix = [0 for i in range(1001)]
+        for j in range(len(arr)):
+            for k in range(j + 1, len(arr)):
+                if abs(arr[j] - arr[k]) <= b:
+                    right = min(arr[j] + a, arr[k] + c)
+                    right = min(right, 1000)
+                    left = max(arr[j] - a, arr[k] - c)
+                    left = max(left, 0)
+                    if left <= right:
+                        count += prefix[right] - (0 if left == 0 else prefix[left - 1])
+
+            for idx in range(arr[j], 1001):
+                prefix[idx] += 1
+
+        return count

awesome_python_leetcode/_1922_count_good_numbers.py

@@ -0,0 +1,36 @@
+import math
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def countGoodNumbers(self, n: int) -> int:
+        """
+        A digit string is good if the digits (0-indexed) at even indices are even and
+        the digits at odd indices are prime (2, 3, 5, or 7).
+        - For example, "2582" is good because the digits (2 and 8) at even positions are
+        even and the digits (5 and 2) at odd positions are prime. However, "3245" is
+        not good because 3 is at an even index but is not even.
+
+        Given an integer n, return the total number of good digit strings of length n.
+        Since the answer may be large, return it modulo 109 + 7.
+
+        A digit string is a string consisting of digits 0 through 9 that may contain
+        leading zeros.
+        """
+
+        def power(x: float, n: int):
+            if n == 0:
+                return 1
+            res = 1
+            while n > 1:
+                if n % 2:
+                    res = (res * x) % (10**9 + 7)
+                n = n // 2
+                x = (x * x) % (10**9 + 7)
+            return res * x
+
+        even = math.ceil(n / 2)
+        odd = n // 2
+
+        return power(5, even) * power(4, odd) % (10**9 + 7)

awesome_python_leetcode/_279_perfect_squares.py

@@ -0,0 +1,21 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numSquares(self, n: int) -> int:
+        """
+        Given an integer n, return the least number of perfect square numbers that sum
+        to n.
+
+        A perfect square is an integer that is the square of an integer; in other words,
+        it is the product of some integer with itself. For example, 1, 4, 9, and 16 are
+        perfect squares while 3 and 11 are not.
+        """
+        dp = [n for _ in range(n + 1)]
+        dp[0] = 0
+        for target in range(1, n + 1):
+            for s in range(1, target + 1):
+                square = s * s
+                if target - square < 0:
+                    break
+                dp[target] = min(dp[target], 1 + dp[target - square])
+        return dp[n]

awesome_python_leetcode/_516_longest_palindromic_subsequence.py

@@ -0,0 +1,19 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestPalindromeSubseq(self, s: str) -> int:
+        """
+        Given a string s, find the longest palindromic subsequence's length in s.
+
+        A subsequence is a sequence that can be derived from another sequence by
+        deleting some or no elements without changing the order of the remaining
+        elements.
+        """
+        dp = [[0 for _ in range(len(s) + 1)] for _ in range(len(s) + 1)]
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(len(s) - 1, -1, -1):
+                if s[len(s) - 1 - i] == s[j]:
+                    dp[i][j] = 1 + dp[i + 1][j + 1]
+                else:
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j + 1])
+        return dp[0][0]

awesome_python_leetcode/_518_coin_change_II.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def change(self, amount: int, coins: List[int]) -> int:
+        """
+        You are given an integer array coins representing coins of different
+        denominations and an integer amount representing a total amount of money.
+
+        Return the number of combinations that make up that amount. If that amount of
+        money cannot be made up by any combination of the coins, return 0.
+
+        You may assume that you have an infinite number of each kind of coin.
+
+        The answer is guaranteed to fit into a signed 32-bit integer.
+        """
+        dp = [[0 for _ in range(len(coins) + 1)] for _ in range(amount + 1)]
+        dp[0] = [1 for _ in range(len(coins) + 1)]
+
+        for i in range(1, amount + 1):
+            for j in range(len(coins) - 1, -1, -1):
+                dp[i][j] = dp[i][j + 1]
+                if i - coins[j] >= 0:
+                    dp[i][j] += dp[i - coins[j]][j]
+        return dp[amount][0]

awesome_python_leetcode/_673_number_of_longest_increasing_subsequence.py

@@ -0,0 +1,30 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findNumberOfLIS(self, nums: List[int]) -> int:
+        """
+        Given an integer array nums, return the number of longest increasing
+        subsequences.
+
+        Notice that the sequence has to be strictly increasing.
+        """
+        dp = {}
+        lenLIS, res = 0, 0
+        for i in range(len(nums) - 1, -1, -1):
+            maxLen, maxCnt = 1, 1
+            for j in range(i + 1, len(nums)):
+                if nums[i] < nums[j]:
+                    length, count = dp[j]
+                    if length + 1 > maxLen:
+                        maxLen, maxCnt = length + 1, count
+                    elif length + 1 == maxLen:
+                        maxCnt += count
+            if maxLen > lenLIS:
+                lenLIS, res = maxLen, maxCnt
+            elif maxLen == lenLIS:
+                res += maxCnt
+            dp[i] = [maxLen, maxCnt]
+        return res

awesome_python_leetcode/_712_minimum_ascii_delete_sum_for_two_strings.py

@@ -0,0 +1,25 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minimumDeleteSum(self, s1: str, s2: str) -> int:
+        """
+        Given two strings s1 and s2, return the lowest ASCII sum of deleted characters
+        to make two strings equal.
+        """
+        dp = [[0 for _ in range(len(s2) + 1)] for _ in range(len(s1) + 1)]
+
+        for i in range(1, len(s1) + 1):
+            dp[i][0] = dp[i - 1][0] + ord(s1[i - 1])
+
+        for j in range(1, len(s2) + 1):
+            dp[0][j] = dp[0][j - 1] + ord(s2[j - 1])
+
+        for i in range(1, len(s1) + 1):
+            for j in range(1, len(s2) + 1):
+                if s1[i - 1] == s2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    dp[i][j] = min(
+                        ord(s1[i - 1]) + dp[i - 1][j], ord(s2[j - 1]) + dp[i][j - 1]
+                    )
+        return dp[-1][-1]