วีดีโอ

thank you!

Thank you for the video! Learned a lot, and your pacing is amazing! One question though, since we could be pushing n - 1 ancestors at the line 39 when our graph is just a list, shouldn't the time complexity be O(n^2 + m) -- Given that m is the size of the edges list, and we'd need to iterate over it to create the adjacency list -- ?

Very good 👍

in your note, T.C should be NLog N, Since we are sorting the array in the first place.

exlain the problem before you show how to solve

one of the best solutions so far <3

great

Minor thing: char is indeed a primitive type but char[] is an object. You don't need to use Character[] to make use of Arrays.sort(). Cool video though =)

Yaay let's go!

Huge fan of the consistent videos. Keep up the good work!!!🙌

Thanks for this.

Perfect explanation thank you

Love your solution. Thank you!

It's not obvious from the first sight what would one even need the backward mapping, they should've included that into examples. I just made a lookup through all entries of a single hashmap to look for a backward mapping. It's maximum size is constant I didn't have to worry about that lookup in terms of overall time/space compexity. But, I guess, keeping two hashmaps is more clear and obvious though.

"Promo sm"

very well expalined, Thank you

I am sure there is some gap in the test cases. Assume this Dictionary words - [abc, adc, aec] isUnique - adc The hash map will store - a1c -> "" So this will return false as per above code as empty string won't match the "adc" but this should return true as per question.

Thanks for the video. but how can I enable code auto-completion in leetcode like you do?

This is awesome!

Why do we need HashMap in this solution?

why we used select max (num) ? How it's extra helping?

Your algo runs in linear time(o(n)) at the very least because in order for you to find the last index, you have to search almost the entire string in the worst case. Similar thing with substring, though before java 7 substring ran in constant time. So depending on the java version, this algo also takes an extra linear time cost. Also we don't need to check if the parent has a length of one as all we need to do is make sure our parent is not empty(as in we have a parent). So not empty or '... > 0' is also fine

Good explanation

It was a really challenging question and i went through the video twice to understand it but i request you to dry run few test cases before going to the approach so it would be even simpler to understand.

Subscribed!! Thanks for the amazing explanation

Could you make a playlist of imp sql queries asked in job interviews.

Well Explained...

So simple and effective, another easy way to do this would be SELECT name FROM ( SELECT ManagerID, name FROM Employee GROUP BY 1, 2 HAVING COUNT(*) >= 5)

AHA! I bet you didn't expect a comment.

bkl kch smjh nai aya

thank you maam

nicely solved

Hey, I think you should speak louder or add captions.

have to finish in O(N) !!

you're cool

so clean explanation. thanks!

I still don't understand 😭😭😭

wow

Good explainations!...

Please upload more of these

you could just find the sum of the AP and subtract the sum of the array elements..

Clean code😊

thanks for actually jumping right into the problem instead of spending the first half explaining what the problem is lol

Can we do better than O(N^2) time complexity?

Really Nice

could you kindly clarify why we need the min = Integer.MAX_VALUE defined on line 9 Also, kindly explain what line 20 does

The Voice is So low

Actually this is not O(n) time. If you are going only to the left/right of one tree, then it is O(n), if you are going through both of them, basically you are checking each node against all nodes in another tree. - Better way is to consider this just as a tree instead of a BST - Build hashset for 1st tree. - Traverse 2nd tree and look for map[target - node->val]. O(m+n) time O(m) space

so clear, thank you for making this video and explain the minus n!