Відео

clear and creative, respect +

why is the bottom-up approach called a "true DP"? Is it because you are starting from smaller problem and building it up to the end result? If so, doesn't top-down, in principal, do the same thing by reaching the base case then unwinding the recursive stack from there?

Crazy clean solution - would love to see the recursive proof behind this

I mean, wont it grab the 8 since you are using num % 10, and not 3? And when you divide with 10, it wont take away 3, it will take away 8:)

This one was a fun problem!

The problem becomes clear once you realize computing the actual product is irrelevant.

This is the 3rd video I watched. Simplest explanation, I think.

Hmm, I kinda miss the point where you explain why the reset actually works.. Does it require to have a certain amount of items or does the cycle needs to have a certain length? Cause I read that it doesnt matter where the pointers meet initially, resetting will always make sure you get the start. But thats complete nonsense right? Cause if i have a list 1-2-3-4-5-6 and a cycle 456 with 6 pointing to 4, thats mathematically not possible, right?

I came here from Cracking the Interview because I was stumped by problem 4.3 which is this same problem, nice explanation!

Please provide the create & insert statement for every question you practice on leetcode. Provide questions in your github account.

Thanks, you really simplified the problem

Can't we deduce the whitespace_count by subtracting charr_array.length - actual_length?

Sorry But what is the point of leetcode or exercising if you still use some library which abstract the solution?

it seemed like a monotonic stack worked from right to left -- was really hoping it would also work from left to right

I cant thank you enough I was literally looking for someone to explain why we are using inclusion and exclusion!!!!!!! damn. I was using the initial intuition approach that you should was wrong and it was counting multiple times. And i was tryna use sets but that would be real inefficient. I still might have to understand it more, to really hit the spot but It was a really nice ice breaker. Basically I was thinking to prove how the code prevents {1,2,3} and {3,2,1} !

Hi, I am a beginner in sql, just started learning and side by side solving problems, I understood till half I kept myself stick to the concepts you were delivering, then at some point I lost, is it normal or it means I still need to study sql a lot?

Hello....can you please provide us the all pattern playlist....like two pointers, backtracking, dp , graphs , trees , sliding window and so on ...

Very good solution.

Please finish all blind 75 plsssss! Your video is so well explained! It's the best resource to learn using python to leetcode

My solution goes like that: for key in hash_map: key_end = key start = 0 While key_end <= len(hash_map[key]): res2 = [] for i in range(start_end, key_end): res_2.append(hash_map[key][i]) start = key_end key_end += key res.append(res2)

Hey Carter, Thanks

Love the blind 75 collection videos, I do leetcode a lot faster when I do it with you!

Thanks Man . Best solution video on yt by far for this question. 😄

FYI - the code used is not directed towards the most efficient time and space complexity, it's more so to understand the data structures in Python and the methods/functions applied on top of it. If you really want the time space complexity, refer to the original NeetCode videos. Thank you Carter, the videos are a good way of refresher for DE interviews

you made this problem look so easy 😲

thank you kind sir

thank you from Egypt you are great

wow!!!!!!!!!!! thankyouu!!!

Good

what tool do you use to write on the screen? I could really use that tool to help me organize my thoughts

This was very helpful. The way that you step through and explain why certain things were done really helps to understand the bigger picture. Keep it up!!

the edge case was very confusing. I did not get any of it

What is the intuition behind starting at node after head for the hare ptr in has_cycle?

great video! what program do you use to write on the screen?

wonderful.. thanks

This solution is so much better than any others

Hey can this be written in tabulation. I mean in the same way that you wrote the memoization? Because i tried but couldn't able to make it

The solution to the first problem doesn't work for me, but I think they've updated Neetcode's test for this question. In cases where the array has _not_ been rotated, we never achieve an answer here since it will continue to search the right side of the array in the default else statement, and we'll never find a situation where nums[m - 1] is greater than nums[m]. I needed to add a condition to return nums[l] when nums[m] is greater than or equal to nums[l], and less than nums[r]. This situation should always mean that the array between left and right are sorted, meaning the left pointer is pointing at the first index of sorted array. There is also an issue when the array has a length of one. That's easily solvable with an if statement before starting to return the one item. Last issue was with array of length 2. I needed to update my while statement to read: while (l <= r). In the provided solution here, in a two item array that's been rotated to [2, 1], it would correctly realize the dip is on the right side, move the left point at index 1, and keep the right pointer at index 1, making them equal and then exiting the loop, ultimately returning nothing. Adding the less than _or equal_ condition to the while loop makes sure it runs that last loop and checks the number you've found when you've drilled down to the last possible index. Maybe I messed something up, because I am working in JS, and not Python, but I don't think this solution as written would work in the circumstances that provide errors on Neetcode. The hangups were [4,5,6,7], [1], and [2,1] .... re-reading it, I think I made a mistake by not including the final return nums[l]... I think that alleviates all the issues in those 3 arrays. I'll leave the comment in case someone makes the same mistake.

Brilliant! I guess you used UnionBySize. Anyway, didn't think of tweaking the UnionFind by introducing a new variable num_comb. Thanks a lot! subbed :)

it makes sense, but how do I intuitively know to -6 or -29 when working with current index?

Great explanation bro, much easier to understand compared to other videos

for 242. Valid Anagram if we are allowed to use Counter, why not just ` return Counter(s)==Counter(t)'

what about time complexity? Seems like window function solution is O(n) and join solution is O(n^2) in case if nested loop is used, am i wrong?

And if the list has no intersecting node, what is the exit condition?

How does the row number approach work to group rows into buckets? I saw how you did it but don’t understand the intuition

what if the rows are unsorted?

# Here's an optimized version of the code: # leetcode runtime reduced from 44 ms to 26 ms class Solution: def uniquePaths(self, m: int, n: int) -> int: # Use a 1D array to store intermediate results dp = [1] * n for i in range(1, m): for j in range(1, n): dp[j] += dp[j-1] return dp[-1] This optimized version has the following advantages: 1. It uses a bottom-up approach, eliminating the overhead of recursive function calls. 2. It uses a 1D array instead of a 2D array, reducing space complexity from O(m*n) to O(n). 3. It iterates through the grid only once, making it more efficient for larger inputs. The time complexity remains O(m*n), but the constant factors are reduced, making it faster in practice. The space complexity is improved to O(n). This solution should be faster and more memory-efficient than the original recursive approach, especially for larger grid sizes. --- same code with comments: class Solution: def uniquePaths(self, m: int, n: int) -> int: # Initialize a 1D array with n elements, all set to 1 # This represents the first row of the grid, where there's only one way to reach each cell dp = [1] * n # Iterate through the rows of the grid (starting from the second row) for i in range(1, m): # Iterate through the columns of the grid (starting from the second column) for j in range(1, n): # Update the current cell by adding the number of paths from the cell above (dp[j]) # and the cell to the left (dp[j-1]) dp[j] += dp[j-1] # Return the last element of the dp array, which represents the bottom-right cell of the grid return dp[-1] Here's a more detailed explanation of the algorithm: 1. We initialize a 1D array `dp` with `n` elements, all set to 1. This represents the first row of the grid, where there's only one way to reach each cell (moving right). 2. We then iterate through the grid row by row, starting from the second row (index 1). 3. For each row, we iterate through the columns, starting from the second column (index 1). 4. For each cell, we update its value by adding the number of paths from the cell above (which is already stored in `dp[j]`) and the cell to the left (which is `dp[j-1]`). 5. After processing all cells, the last element of the `dp` array (`dp[-1]`) contains the total number of unique paths to reach the bottom-right corner of the grid. 6. We return this value as the final result. This approach efficiently calculates the number of unique paths by using dynamic programming with optimized space complexity, storing only one row of intermediate results at a time.

thanks Carter, that was helpful !

Clear...

Hello, can you also explain the time complexity and space complexity? As I am having a google interview and the time I have 2 and half weeks. I have 0% knowledge on dsa. It would be a great help. I know I am not able to crack it but atleast I don't want to give up.