Video

i am from leetcode solution page comment section, keep doing contents like this bro, thank you so much for your solution

Hi Viewers, Apologies for the confusion. In the provided example, please consider 1 as a local minima. We hope this clarification does not affect your understanding of the logic and approach. Best regards, MPC (Mayur Programming Club) 🖥🔍

Thanks bro, you are a life saver. Keep the videos coming!!!!!!!!!

u can give better explain , explain without the code

Wow. It was a great explanation. For the first 5 minutes I could not really follow you. Maybe think if you can become little bit clearer on the mask part and why you using it. Overall totally worth of 11 minutes. Thank you!

Thanks a ton for the analogy!!

sexy brooo

Thank you for your explanation. As a tip, your microphone seems to be clipping a lot. Maybe adjusting your microphone level and/or hoe close you are to it can help. Maybe it is caused by the microphone itself though.

There were some issues with the audio quality today. We regret the inconvenience caused. They will be fixed from the next video onwards.

Keep up the great work

good

Around 4:05 Please consider division of overall product by each number(if divsion operator would have been allowed).

seen videos of 2-3 person but couldn't got the logic , you explained it so well. here's my like

Thanks Bhai ab jaa kar samaj aaya

thanks sir your videos are very helpful 🥰

could you please explain how you deleted the prefix sum values in hashmap?

Please note a correction in time complexity analysis. Consider it O(len1 + len2), where len1 and len2 are lengths of two input arrays.

can u do python version pls

try in java also

how did u come up with this? like the thought process behind it

Thanks 🤍

Thanks man 👍

There were some issues with audio quality today due to a technical glitch. They will be resolved in upcoming videos. We apologized for the inconvenience caused.

Good Work, keep going. One Suggestion: try to upload in some faster speed.

Good work

Note : Consider 31st bit as the MSB(Most Significant Bit) in the illustration

can you please tell me how to build logic for such code?

Just a feedback: The explaination is good! what I wanted you to improve that if you are saying something and then taking time to write the same thing makes the video slow and boring which will make people disinterested. So maybe try avoiding or finding an alternate approach to it. Otherwise thanx for explaining:)

Your approach is very satisfying 😄explaining every small chunk of code and concept associated with it is really helpful for a beginner like me Thanks!!

Keep up the good work.

Time complexity: O(n * log n), n is the number of unique player participating in matches. Space complexity: O(n)

Masya Alloh 👍🏻

14:55 If I'm understanding this correctly, the condition in line 13 is checking if indx is an index outside of the current available indices in the vector lis. Meaning len is the same as lis.end() which will always be increasing the subsequence? EDIT: I replaced line 13 with this "if (lower_bound(lis.begin(), lis.end(), num) == lis.end())" and it seemed to work the same, so I believe my reasoning is correct. Thank you for the solution.

A great solution and a great explanation absolutely loved it

freq = 10 , freq = 9 how ans is 7??

bro, you are not confident with your explanation.

Thanks buddy, this question wasted my entire day. Your logic is simple.

🎉 Promo sm

Bro aaj vala kiya kya ?

Nice Explanation

Correction of Complexities in the video explanation: Time Complexity: O(N) where N is the number of nodes in the binary tree. Auxiliary Space: O(N) where N is the number of nodes in the binary tree.

In which year you are ?

class Solution { public: int minimumTime(int n, vector<vector<int>>& rel, vector<int>& time) { //first you will be making up a graph to show the relation between different courses unordered_map<int, vector<int>> graph; //this data structure will help you to find the zero dependency courses and relax them while doing topological sort vector<int>deg(time.size()+1, 0); //this queue will be used to do BFS of relations in topological sort queue<int> que; //forming the graph from the given realtion array and degree vector to calculate number of dependencies for(auto &r : rel){ int prev = r[0], curr = r[1]; deg[curr]++; graph[prev].push_back(curr); } //this data structure will be used to find the minimum time it will require for say 'i'th course to be completed vector<int> dist(time.size() + 1, 0); int tTime = 0; //enqueing zero dependency courses first for(int vert = 1; vert<deg.size(); vert++){ int d = deg[vert]; if(d == 0){ que.push(vert); dist[vert] = time[vert-1]; } } // then for each of the zero dependency course in the queue you will be relaxing the neighbours of that course i.e. the courses dependent on the current course being explored for it's neighbours, as soon as course reaches zero dependecy you will enqueue it into the queue while(!que.empty()){ int size = que.size(); while(size -- > 0){ int vert = que.front(); que.pop(); for(auto neigh : graph[vert]){ //updating the time required to finish each course along with relaxation dist[neigh] = max(dist[neigh], time[neigh-1] + dist[vert]); if(--deg[neigh] == 0)que.push(neigh); } } } //maximum time taking course's time will be returned return *max_element(dist.begin(), dist.end()); } };

Explanation is great

Great work

Great work

Good explanation

Top floor can be reached from last second or last floor by taking 2 or 1 steps respectively. That's is the logic that we missed while returning answer when we tried submitting for the first few times.

Great work