From bba7ed13de1d5ae0f6424d1fe169790007e79ca4 Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Wed, 5 Jan 2022 16:37:04 -0500 Subject: [PATCH 1/7] Create delete_and_earn.py --- delete_and_earn.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 delete_and_earn.py diff --git a/delete_and_earn.py b/delete_and_earn.py new file mode 100644 index 00000000..2cb25c84 --- /dev/null +++ b/delete_and_earn.py @@ -0,0 +1,19 @@ + # Time Complexity - O(n) + # Space Complexity - O(n) + + def deleteAndEarn(nums): + hmap={} + a=max(nums) + for i in nums: + if i in hmap: + hmap[i]+=i + else: + hmap[i]=i + for i in range(a+1): + if i not in hmap: + hmap[i]=0 + b=[[0]*2 for _ in range(a+1)] + for i in range(1,a+1): + b[i][0]=max(b[i-1][0],b[i-1][1]) + b[i][1]=b[i-1][0]+hmap[i] + return max(b[a][0],b[a][1]) From 18de2604027550c6aaf1b92581e591f32d80255c Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Wed, 5 Jan 2022 16:52:52 -0500 Subject: [PATCH 2/7] Create min_falling_path_sum.py --- min_falling_path_sum.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 min_falling_path_sum.py diff --git a/min_falling_path_sum.py b/min_falling_path_sum.py new file mode 100644 index 00000000..3439b67c --- /dev/null +++ b/min_falling_path_sum.py @@ -0,0 +1,22 @@ +# Time Complexity - O(mn) +# Space Complexity - O(mn) + +class Solution: + + def minFallingPathSum(self, matrix: List[List[int]]) -> int: + dp = matrix[0][:] + temp = [0] * len(matrix[0]) + for i in range(1, len(matrix)): + for j in range(len(matrix[0])): + if j-1<0: + left = float('inf') + else: + left = dp[j-1] + if j+1>=len(matrix[0]): + right = float('inf') + else: + right = dp[j+1] + top = dp[j] + temp[j] = min(left, right, top) + matrix[i][j] + dp = temp[:] + return min(dp) From 3c363ece322dd81b85a0ae650f83eda338dd0750 Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Mon, 20 Apr 2026 20:58:02 -0700 Subject: [PATCH 3/7] Delete delete_and_earn.py --- delete_and_earn.py | 19 ------------------- 1 file changed, 19 deletions(-) delete mode 100644 delete_and_earn.py diff --git a/delete_and_earn.py b/delete_and_earn.py deleted file mode 100644 index 2cb25c84..00000000 --- a/delete_and_earn.py +++ /dev/null @@ -1,19 +0,0 @@ - # Time Complexity - O(n) - # Space Complexity - O(n) - - def deleteAndEarn(nums): - hmap={} - a=max(nums) - for i in nums: - if i in hmap: - hmap[i]+=i - else: - hmap[i]=i - for i in range(a+1): - if i not in hmap: - hmap[i]=0 - b=[[0]*2 for _ in range(a+1)] - for i in range(1,a+1): - b[i][0]=max(b[i-1][0],b[i-1][1]) - b[i][1]=b[i-1][0]+hmap[i] - return max(b[a][0],b[a][1]) From 9145839aedd7279447c604e823d7bc6bf084d594 Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Mon, 20 Apr 2026 20:58:14 -0700 Subject: [PATCH 4/7] Delete min_falling_path_sum.py --- min_falling_path_sum.py | 22 ---------------------- 1 file changed, 22 deletions(-) delete mode 100644 min_falling_path_sum.py diff --git a/min_falling_path_sum.py b/min_falling_path_sum.py deleted file mode 100644 index 3439b67c..00000000 --- a/min_falling_path_sum.py +++ /dev/null @@ -1,22 +0,0 @@ -# Time Complexity - O(mn) -# Space Complexity - O(mn) - -class Solution: - - def minFallingPathSum(self, matrix: List[List[int]]) -> int: - dp = matrix[0][:] - temp = [0] * len(matrix[0]) - for i in range(1, len(matrix)): - for j in range(len(matrix[0])): - if j-1<0: - left = float('inf') - else: - left = dp[j-1] - if j+1>=len(matrix[0]): - right = float('inf') - else: - right = dp[j+1] - top = dp[j] - temp[j] = min(left, right, top) + matrix[i][j] - dp = temp[:] - return min(dp) From 0b90ee4f5aa05c7bb74cb02699c9162574a4e010 Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Mon, 20 Apr 2026 21:01:30 -0700 Subject: [PATCH 5/7] Add deleteAndEarn function in delete and earn.py Implement deleteAndEarn function to calculate maximum points. --- delete and earn.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 delete and earn.py diff --git a/delete and earn.py b/delete and earn.py new file mode 100644 index 00000000..5783d45d --- /dev/null +++ b/delete and earn.py @@ -0,0 +1,14 @@ +# Time Complexity --> O(n) where n is the max value available in the input list +# Space Complexity --> O(n) +# Approach --> creating an array where the indices would represent the number available in nums list. The values would be the sum of all its occurrences +class Solution: + def deleteAndEarn(self, nums: List[int]) -> int: + arr = [0]*(max(nums)+1) + for i in range(len(nums)): + arr[nums[i]] = arr[nums[i]]+nums[i] + + + for i in range(2, len(arr)): + arr[i] = max(arr[i-1], arr[i]+arr[i-2]) + return arr[-1] + From 11ceba3fd32963de1936b40a29f83c07a829ea95 Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Mon, 20 Apr 2026 22:11:59 -0700 Subject: [PATCH 6/7] Create Minimum Falling Path Sum.py --- Minimum Falling Path Sum.py | 52 +++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Minimum Falling Path Sum.py diff --git a/Minimum Falling Path Sum.py b/Minimum Falling Path Sum.py new file mode 100644 index 00000000..b78340af --- /dev/null +++ b/Minimum Falling Path Sum.py @@ -0,0 +1,52 @@ +# Time Complexity --> O(n*n) where n*n are the dimensions of matrix +# Space Complexity --> O(n*n) +class Solution: + def minFallingPathSum(self, matrix: List[List[int]]) -> int: + n = len(matrix) + if n==1: + return matrix[0][0] + + dp = [[0]*(n) for i in range(n+1)] + for i in range(1,n+1): + for j in range(n): + if j==0: + dp[i][j] = matrix[i-1][j] + min(dp[i-1][j], dp[i-1][j+1]) + elif j==n-1: + dp[i][j] = matrix[i-1][j] + min(dp[i-1][j-1], dp[i-1][j]) + else: + dp[i][j] = matrix[i-1][j] + min(dp[i-1][j-1], dp[i-1][j], dp[i-1][j+1]) + + return min(dp[-1][:]) + + + +''' +# Time Complexity --> O(n*n) where n*n are the dimensions of matrix +# Space Complexity --> O(n*n) +class Solution: + def minFallingPathSum(self, matrix: List[List[int]]) -> int: + + re = float('inf') + n = len(matrix) + self.memo = [[float('inf')]*(n) for i in range(n)] + for i in range(n): + re = min(re, self.helper(matrix, 0, i)) + return re + + + def helper(self, matrix, row, col): + # base + if row==len(matrix): + return 0 + if self.memo[row][col]!=float('inf'): + return self.memo[row][col] + # logic + if col==0: + case = matrix[row][col] + min(self.helper(matrix, row+1, col), self.helper(matrix, row+1, col+1)) + elif col==len(matrix)-1: + case = matrix[row][col] + min(self.helper(matrix, row+1, col-1), self.helper(matrix, row+1, col)) + else: + case = matrix[row][col]+min(self.helper(matrix, row+1, col-1), self.helper(matrix, row+1, col), self.helper(matrix, row+1, col+1)) + self.memo[row][col] = case + return case +''' From af082a5b4f098b22353972cfd98bc79dad8dcdaf Mon Sep 17 00:00:00 2001 From: "M.Hitesh" <54840773+hiteshmadapathi@users.noreply.github.com> Date: Mon, 20 Apr 2026 22:33:14 -0700 Subject: [PATCH 7/7] Optimize space complexity for minFallingPathSum Updated space complexity from O(n*n) to O(n) by optimizing the dp array to a single dimension. --- Minimum Falling Path Sum.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/Minimum Falling Path Sum.py b/Minimum Falling Path Sum.py index b78340af..7acf7a6f 100644 --- a/Minimum Falling Path Sum.py +++ b/Minimum Falling Path Sum.py @@ -1,22 +1,25 @@ # Time Complexity --> O(n*n) where n*n are the dimensions of matrix -# Space Complexity --> O(n*n) +# Space Complexity --> O(n) class Solution: def minFallingPathSum(self, matrix: List[List[int]]) -> int: n = len(matrix) if n==1: return matrix[0][0] - dp = [[0]*(n) for i in range(n+1)] - for i in range(1,n+1): + dp = [0 for i in range(n)] + for i in range(n): + left = 0 for j in range(n): + temp = dp[j] if j==0: - dp[i][j] = matrix[i-1][j] + min(dp[i-1][j], dp[i-1][j+1]) + dp[j] = matrix[i][j] + min(dp[j], dp[j+1]) elif j==n-1: - dp[i][j] = matrix[i-1][j] + min(dp[i-1][j-1], dp[i-1][j]) + dp[j] = matrix[i][j] + min(left, dp[j]) else: - dp[i][j] = matrix[i-1][j] + min(dp[i-1][j-1], dp[i-1][j], dp[i-1][j+1]) + dp[j] = matrix[i][j] + min(left, dp[j], dp[j+1]) + left = temp - return min(dp[-1][:]) + return min(dp)