Видео

Still confused over infinite loop😅

DSA brain rot

Just take a data structures and algorithms class instead, Im begging you

THANKS DUDE FOR THE ADVICE

Best explanation

why does the dfs call return the number of current passengers?

This dude literally looks like me

I never would have thought of this solution. Thank you

The correct time complexity is O(n⋅log n + k⋅log n) when you take into account the `heapq.heapify(minCapital)` call.

I've been a bit rusty with leetcode for sometime because of finals exams at school, I've still been trying to do leetcode fairly regularly, however, Immediately you mentioned using another heap for accessing other profits, my heart broke..... I came up with a solution that passed all the test cases except the last remaining 2 with the expected error being (Time Limit Exceeded).... I knew exactly what my problem was (which was updating what projects we have access to now that MIB aka money in the bank has increased).... THANKS!!!!! I wonder what topic in computer science theory could have helped with me thinking about this much faster (🤔)

Leetcode is also a fun mental activity

because heapify should it be O(k log n + n)?

Nice Video Brother

Thank you so much for the explanation. But why the time complexity will be O(log n) if the tree was a balanced binary tree?

How am i getting TLE with this solution, it's the same thing class Solution: def checkRecord(self, n: int) -> int: pre = [[1,1,0], [1,0,0]] next = [[0]*3 for i in range(2)] for i in range(2,n+1): next[0][0] = pre[0][0] + pre[0][1] + pre[0][2] next[0][1] = pre[0][0] next[0][2] = pre[0][1] next[1][0] = pre[0][0] + pre[0][1] + pre[0][2] + pre[1][0] + pre[1][1] + pre[1][2] next[1][1] = pre[1][0] next[1][2] = pre[1][1] pre = next next = [[0]*3 for i in range(2)] res = 0 for l in pre: res += sum(l) % (10**9 + 7) return res % (10**9 + 7)

bro discovered learning

can this be solved in the knapsack 0/1 way?

Speechless superb approach thank you so much

leetcode style questions is not a good measure of a good engineer. its just measuring if you prepared for those questions or not. i got a computer science degree and even for some specific use cases for these algorithms, a good engineer only should be familiar with the concepts and everyone can just google the details and implement the best solutions in daily job, but those interviews just expecting to write most efficient codes in a short amount time. because if you dont, somebody else will and they will be hired. so leetcode style interviews only measure how good you prepared for interviews not how good engineer you are. even the best engineers around cannot solve that kind of questions without preparing. they are not riddles or iq tests.

Can we just use a two-demension array for python solution?

why hash set is failed here?

thanks bud, appreciate it !

The explanation for this solution is amazing!

Not sure why it was only me who thought it could be a DP problem.

I can not understand you from the first time theeplanation some times is s stochastic, but I return to your videos always.

c programming you are not really using a lot of external deps. X We still use libraries, but we know what's the complexity of adding deps. C and C++ developer are usually more aware of deps. And usually c library developer maintains interface compability better than web-dev's. And you are more likely to stuck at compile time and found interface mismatch easier and earlier.

Great explanation!

anyone not understanding this solution? Any other recommendations?

thankyou so much it helps me alot

I got recommenced to buy cracking the coding interview on codecademy

crying at 8:30 haha

Web dev with C.

Why do we have to iterate n+max times? Can't we just iterate until the max number? Knowing that there's no more elements bigger than this one we can just calculate the triangle number of the remaining duplicates on one operation. Something like this: class Solution: def minIncrementForUnique(self, nums: List[int]) -> int: count = Counter(nums) res = 0 for i in range(max(nums)): if count[i] > 1: extra = count[i] - 1 count[i + 1] += extra res += extra n = count[max(nums)]-1 res+= n * (n +1)/2 return res

It takes a lot of skill to not only conjur the idea but to bring it into code. I thought of the second solution as in how to fill in the gap but was stuck on how to iterate from key to key in a map.

1. Sort both array. 2. Add abs different of same index value.

Following you since last 4 month with 95 percent consistency

... and they hated him because he told the truth. ... and, when you understand the algorithm, you'll never need to memorize it, just translate your thought process into the context of the problem.

BEST EVER!!!!!!!!!!!!!!!!

how do u know all of this

To get an O(n) solution, you can also do count sort instead of python's built in sort method in your first solution. Imo, this is easier to understand than your second solution even if it may take more lines of code. this is my python solution. class Solution: def minIncrementForUnique(self, nums: List[int]) -> int: large = max(nums) small = min(nums) counts = Counter(nums) nums = [] for i in range(small, large +1): for j in range(counts[i]): nums.append(i) ans = 0 minimum = nums[0] for i in range(len(nums)): if nums[i] < minimum: ans += minimum - nums[i] minimum += 1 else: minimum = nums[i] + 1 return ans

So clear thx bro

I came with the optimal solution easily, but I still must watch your videos

In second solution : range(min(nums),max(nums)+len(nums)) instead of range(0,max(nums)+len(nums)).....min and max can be calculated simultaneously in single pass first

Bro, do you ever get outside? Cause I see you always talking about Algorithms.

I did DP for this !

Only catch of this problem is how you prove if value at i is less than value i - 1 means there was a duplicate.

did both by myself 🤧🤧

You can just iterate to the max(nums) Let carry = count[max(nums)] if carry > 1, then add carry*(carry -1)/2 to the result Here is my C++ solution class Solution { public: int minIncrementForUnique(vector<int>& nums) { vector<int> counter(1e5 + 1); for (const auto& x : nums) { ++counter[x]; } int carry = 0; int res = 0; for (int x = 0; x < counter.size(); ++x) { counter[x] += carry; carry = max(counter[x] - 1, 0); res += carry; } res += max(carry - 1, 0) * carry / 2; return res; } };

if we take the first solution, but use radix sort, will the solution improve to O(n + d), where n - length array, d - max number