Відео

seriously, these videos are supper good

thankyou!!!! you are the best!

as we do more and more union-find operations, the path gets even more compressed making it efficient . such a wonderful concept .

we use this concept in implementation of segment trees .

this concept is used in segment trees

Note that Singly Linked List also can have Head and Tail Node, But only one pointer to next node. When remove at tail in Singly, We can remove last Node using Tail Node. But Tail Node doesn't know what is previous Node only know next is NULL. So we have to throw away Tail node after removing that.

great explanation

.....................................................................................................................................................................

Extremely good job of explaining! Some people are gifted at teaching! (I know it's not a "gift" it's the result of mainly hard work of looking at problems a zillion times from different perspectives and finding a suitable one to tell the new comer)

owo

4:50 how is the predessecor is 7? it should be 8

Oh how I hate all of you, PHD supremacists, with all your self absorbed big big words, super-scientific encryption from planet Jupiter... "Thiss blue arrow incorporates that triangulation within dissonance of Pythagorean uncertainty of current white arrow that is equilibrium of the cosmic entropy... " Then they are saying why beginners hate any type of science and give up on everything... dude 2 + 2 = 4 that's it ! All this could be simply said is that CURRENT capacity value = [previous capacity (one row above, but same column #) - newer/current given capacity(weight)] add number(value it holds) to newer/current number(value) and that's the value that gets to current cell.....But nooooo it has to go trough rigorous BS

Thank you so much it is extremely helpful. One image's worth 1000 of words

I was having a really hard time with DP but it's so much easier to imagine the solution every dp problem as the shortest paths tree of a directed acyclic graph. so in this case it would follow the topological sort and ONLY update cell (or relax it) if DP's condition is met. In cases of actual graphs this is exactly what we do to find shortest paths tree for a DAG.

Why have you used Object instead of Generics T as arguments in the remove(), indexOf(), and contains() methods?

Brilliant video, thank you so much for these. I think you could also modify solve() to return a prev collection as in the BFS Shortest Path video, and add the end cell coordinates or marker character ('E') as a parameter to the enclosing function. Then you no longer need all the global counting variables (nodes_left_in_layer etc). You would need to perform [number of steps in shortes path] iterations over prev to get the shortest path and return shortest_path.size() - 1. Maybe not optimal since you have to iterate over the shortest path too, but as long as you still break inside solve() when reached_end = True, the time complexity should stay the same.

This channel is amazing but youre a sick individual for putting on socks first before anything else

Is that always lawful to change the root of the heap?

great explanation sir, thank you

Thx

You sound like MoistCritikal before he got into chain smoking

ape dzveris chhi

Great explanation, thank you :)

......WOW

None of C++ STL, Java Collections and Python Collections have Indexed Priority Queue. Golang has a 'Fix' method, which allows updating a value, but it does not have an index function to find the value and it's not obvious how to find items after a Fix call, which takes an index as input.

8:23 why does it say 11, not10?

Great explanation! Thank you.

Very clearly explained. You need V-1 times in the worst case. However, if in a round there were no relaxations performed, obviously the next round will also not have any too, so you can stop by detecting the number of relaxations made in a round to be zero.

Satisfactory

at 16:45 we are setting low[node] to ids[at] would it not have already happened above when low[at] = min(low[at], low[to]) this seems redundant. what am I missing??

🎯 Key points for quick navigation: 00:01 *🔑 Explains the union and find operations in a union-find data structure.* 00:17 *📝 Creates a bijective mapping between objects and integers to construct an array-based union-find.* 01:05 *🗃️ Stores the mappings in a hash table for efficient lookup.* 01:34 *📐 Initially, each node in the array points to itself as a root node.* 02:30 *🔗 To unify objects, the smaller component's root node is set as the parent of the larger component's root node.* 04:34 *🧰 Explains the process of merging smaller components into larger ones during unification.* 06:24 *🌳 If two objects belong to the same component, no unification is needed.* 07:42 *🔍 To find the component an element belongs to, follow the parent nodes until reaching the root node.* 08:41 *🚩 The number of components equals the number of remaining root nodes and never increases.* 09:48 *⚡ Path compression, covered in the next video, improves the time complexity of union-find operations.* Made with HARPA AI

what the fuck are you talking about

can anybody tell me the meaning of the line state = subset ^ (1<<next) in 14:59

great explanation thank you so much🥰🥰

thank you so much

This is a great explanation!

What are more complex areas of graph theory beyond this or connection to other parts of mathematics?

It was great how you explained all the states and how we could compute the current states from previous states, but as soon as I saw the long and messy code, I lost my interest completely. You could have used a simple code with an array of length 4 containing all possible states and computing the values based on the last array(state)

this looks like implementation of ArrayList in java. Is that right?

brilliant explanation = thank you so much

Dude this rocks..

WATCH IN 1.5X SPEED 🗣🗣🗣🗣

Golden Standards for teaching! Great work man!

Beautiful! :)

subscribe++;

What I don’t understand if you could please explain is why h-1 is used on every subtree, so for example, x root, go right have a z node, left of z node is another Y node, left of the Y node we have just a triangle (working on double rotation) which has a height of h-1, right of the Y node we have another triangle which has the height of h-2, right of Z node we have a triangle which is again h-1. Left of root x we have one triangle that is h-1, now where do these h-2 and h-1 come from. Also when checking the imbalance, a h+1 comes in to make it an imbalance of 2. How does this work, I can’t wrap my head around it. PLEASE HELP

What I don’t understand if you could please explain is why h-1 is used on every subtree, so for example, x root, go right have a z node, left of z node is another Y node, left of the Y node we have just a triangle (working on double rotation) which has a height of h-1, right of the Y node we have another triangle which has the height of h-2, right of Z node we have a triangle which is again h-1. Left of root x we have one triangle that is h-1, now where do these h-2 and h-1 come from. Also when checking the imbalance, a h+1 comes in to make it an imbalance of 2. How does this work, I can’t wrap my head around it. PLEASE HELP

I hate algorithms. nice video tho

Thank you very much sir!!

Wow, just wow! On a side note, I think it's better to consider the position of the LSB in the 0-indexed way, since in that case an index is directly responsible for 2^(0-indexed position of LSB) element below it, inclusive of itself. Then cascading to the appropriate next element is intuitive, just remove the LSB. Essentially going down 2^(0-indexed position of LSB) :D. Anyways, fantastic job!