For each problems, please click on the companies tab and show us the companies

Clear explanation. Thanks

For some reason my test case isn't passing when i try to submit

I was stuck for very long time, then eventually figure out the 'Long', lol

I was also stuck at the problem where you converted int into long for 30 minutes thankyou

Why didn't u put the sols of weekly contest 405 solution and biweekly contest sols😢

Best explanation of this problem I have seen so far, many thanks.

I assumed I was missing a constant time math proof, but I guess simulation is the only way ha

this kind of question is quite frequent in LC contest, I just use flag variable for direction and simulate

Very good explanation

Very nice explanation! And cool art in the thumb nail. I need to think about why, when generating a spanning tree, the method of first choosing type 3 edges when possible, and then secondarily choosing type 1 & 2 edges, always gives the maximal number of edges that can be removed.

only able to solve first 2. thanks for your editorials

i wrote this code class Solution: def modifiedGraphEdges(self, n: int, edges: List[List[int]], source: int, destination: int, target: int) -> List[List[int]]: graph = defaultdict(lambda:defaultdict(lambda:float("inf"))) for edge in edges: graph[edge[0]][edge[1]]=edge[2] graph[edge[1]][edge[0]]=edge[2] while(True): shortest={} minHeap=[] heapq.heappush(minHeap,(0,source)) while minHeap: cost,node = heapq.heappop(minHeap) if node in shortest: continue shortest[node]=cost for neighbour,cost_to_neighbour in graph[node].items(): if neighbour not in shortest: if cost_to_neighbour==-1: heapq.heappush(minHeap,(cost+1,neighbour)) else: heapq.heappush(minHeap,(cost+cost_to_neighbour,neighbour)) if shortest[destination]>target: return [] if shortest[destination]==target: for i in range(len(edges)): if edges[i][2]==-1: edges[i][2]=1 return edges l=[destination] pathh=[] def path(node,cost): nonlocal pathh if cost==0: pathh=l.copy() return for neighbour,cost_to_neighbour in graph[node].items(): if cost_to_neighbour==-1: cost_to_neighbour=1 if cost - cost_to_neighbour == shortest[neighbour]: l.append(neighbour) path(neighbour,cost-cost_to_neighbour) l.pop(-1) path(destination,shortest[destination]) flag=True pathh=pathh[::-1] a=10**9 b=10**9 for i in range(len(pathh)-1): if graph[pathh[i]][pathh[i+1]]==-1: a=pathh[i] b=pathh[i+1] flag=False break if flag: return [] for edge in edges: if (edge[0]==a and edge[1]==b) or (edge[1]==a and edge[0]==b): edge[2]=target-shortest[destination]+1 graph[edge[0]][edge[1]]=target-shortest[destination]+1 graph[edge[1]][edge[0]]=target-shortest[destination]+1 break

really appreciate it man

Great Video and explanation thanks a bunch!!

Cool thumbnail!!

please don't say problems were that easy😑, love your videos btw, solution for W-403 coming?

Great explanation. Is there any way we can connect? LinkedIn?

I'm a Java coder and I wasn't able to find any KZfaq channel where I could get solution explanations to daily leetcode problems which led me to breaking my streak many times. I was following a python guy but it was inconvenient to understand the python code and then write the same in java. Thanks to you that you upload videos everyday and now I'm able to solve problems easily.

i do not understand

In Java, Arrays.sort() is implemented using a variant of the Quick Sort algorithm which has a space complexity of O(logn) for sorting

i don't understand why the left position has to be 1 and not 0?

i got the time limit exceed through your code , please help me!!

would sliding windows make it concise or possible that way?

Great logic!!

Great video! I knew the last one was a Segment Tree but couldn't figure it out directly. Very smart to pose it as a range sum question. Was missing your vid last week 😆

well explained, thanks man!

I was expecting your video Yesterday

How did you come up with this approach many people are using treemap/priority queue/min heap for it ,how to decide the good one? I personally loved this solution since it is straight forward! Thanks

Beautiful explanation! Thank you very much

killin it with the streak man..🍏🍏

Solid solid content man - thank you!

Hey! Writing this comment from India. I've been watching your content for almost 6 months now, and your videos helped me clear DSA rounds. I recently got an MLE role at a startup here. Thanks a lot for the great content!

Nice explanation Thanks

Man, I really need to study up on bit operations lol

For some reason the video quality is not going beyond 360p

Very nice video,informative ,concept explained in a very simple way. keep it up

great solution, and I learned that python heappush sorts array entries lexicographically

Why brute force solution is faster than the optimal one? Is it the sorting? Brute force(checking for each element) is faster than 100%

Thank U great job👍

Great explanation

small error with counting from day 2 to 3 at 13:00. I skipped the value that had 1 absence and 0 late streak, so the results for day 3 were a bit off. But the logic should still be fine.

In the video you were saying about backtracking template , would you mind sharing that?

O(2^n) solution: class Solution { int count = 0; public int beautifulSubsets(int[] nums, int k) { Arrays.sort(nums); backtrackSubSets(nums, k, new HashMap<>(), 0); return count; } private void backtrackSubSets(int[] nums, int k, Map<Integer, Integer> currentSubsetMap, int index) { if (index > nums.length - 1) { if (!currentSubsetMap.isEmpty()) { count++; } return; } if (!currentSubsetMap.containsKey(nums[index] - k)) { currentSubsetMap.put(nums[index], currentSubsetMap.getOrDefault(nums[index], 0) + 1); backtrackSubSets(nums, k, currentSubsetMap, index + 1); currentSubsetMap.put(nums[index], currentSubsetMap.get(nums[index]) - 1); if (currentSubsetMap.get(nums[index]) == 0) { currentSubsetMap.remove(nums[index]); } } backtrackSubSets(nums, k, currentSubsetMap, index + 1); } }

thx, great work!

Holy cow. Clever solution and more importantly great explanation!

Great explanation bro, just a small suggestion, get a nice mic. Your content is way too good.

Hello, would you mind taking a look at LeetCode problem 128? I'm finding the time complexity and runtime behavior quite puzzling. Interestingly, O(n) seems to lag far behind O(n log n) in terms of speed. I would really appreciate it if you could shed some light on this matter!

Congrats on streak 300💥💥

6:27 : It should be 2 instead of 3.