LeetCode 39 - Combination Sum

Sdílet
Vložit
  • čas přidán 7. 09. 2024

Komentáře • 50

  • @sarahzhang8258
    @sarahzhang8258 Před 3 lety +11

    This is the only one that talks about the backtracking very clearly from the thinking to code. Like this one.

  • @prakad97
    @prakad97 Před 4 lety +33

    Dude seriously the best explanation on youtube..

  • @seungjinkim8860
    @seungjinkim8860 Před 4 lety +9

    Visualizing the recursion tree was key for me to understand the code. Thank you

  • @010101dddm
    @010101dddm Před rokem +1

    best explanation on youtube hands down

  • @changjoey6403
    @changjoey6403 Před 4 lety +7

    That is the best explanation series of leetcode problem I can find on CZcams! It may be perfect if you write the solution in C++.

  • @shriniwasbharadwaz1183
    @shriniwasbharadwaz1183 Před 3 lety +1

    I watched a lot of video for this same problem but couldn't understand,but when I saw this one all concepts were clear

  • @zukoric
    @zukoric Před 8 měsíci

    Great job, nobody explains like you do on YT

  • @udaykulkarni5639
    @udaykulkarni5639 Před 11 měsíci

    Woww!! M gonna remember this for the rest of my life!

  • @vidhishah9154
    @vidhishah9154 Před 4 lety

    Your way of explaining using recursion tree and then applying the same in code explanation is awesome. Best video I have seen so far. Thank you so much and keep making good videos.

  • @DJSamijon
    @DJSamijon Před rokem

    i love that you did it in the execution order

  • @2012Misanthrope
    @2012Misanthrope Před 3 lety +1

    Excellent explanation. The DFS recursion tree was perfect.

  • @andyhujian
    @andyhujian Před 4 lety +2

    My two cents about time complexity. min is the minimal value of among the numbers. The search tree level is target/min. At each level, the number of fan out is n. Then the upper bound is O(n^(target/min)). It should be the upper bound, but it's not tight because the fan out is getting smaller when traverse down the tree.

  • @user-dw6zi4yo3i
    @user-dw6zi4yo3i Před rokem

    Wow, truly the best explanation of this topic

  • @shubamsharma5745
    @shubamsharma5745 Před 4 lety +1

    Simple sweet and awesome explanation on the whole internet
    I am beginner and u just explained it so beautifully I understood it very clearly. Thanks for the video and please keep making these wonderful and amazing videos

  • @karanchandramandi1967
    @karanchandramandi1967 Před 9 měsíci

    Thanks man for explaining that recursive tree as well as code explanation.

  • @brandoncontreras343
    @brandoncontreras343 Před 3 lety +1

    Thank you so much for the tree visual.

  • @marktheimmortal
    @marktheimmortal Před 2 lety

    Great explanation of the problem and solution! Nice one!

  • @jxujessica
    @jxujessica Před 3 lety

    best explanation I've ever watched

  • @zuojimmy1198
    @zuojimmy1198 Před 3 lety

    great explanation for the backtracking, very clear! thank you very much!

  • @soninirav
    @soninirav Před 2 lety

    Keep going man....your explanation skills are just awesome :)😃

  • @mohammednishad4055
    @mohammednishad4055 Před 3 lety

    nice and simple explanation, expecting more videos like this.

  • @electra7840
    @electra7840 Před 3 lety +1

    Time complexity is O(N^target) where N is a length of candidates array.
    Space complexity is O(target).

  • @MiddleEasternInAmerica

    PLEASE, make more videos, this is awesome explanation

  • @vijayakumareyunni6010

    Good explanation. Thank you

  • @MsSk8trboy
    @MsSk8trboy Před 4 lety

    Exactly what I was looking for man!!! Great job

  • @arrows8367
    @arrows8367 Před rokem

    An excellent teacher ❤

  • @ankuradhey
    @ankuradhey Před 4 lety

    Beautifully done.

  • @spicytuna08
    @spicytuna08 Před 2 lety

    nice

  • @tonyz2203
    @tonyz2203 Před 2 lety

    no more updates?
    best video

  • @sachinkolachana6384
    @sachinkolachana6384 Před 5 lety

    Very clear explanation. Thank you.

  • @DMDRPBHU
    @DMDRPBHU Před 4 lety

    what a legend

  • @antoniomartinez3429
    @antoniomartinez3429 Před 4 lety

    Really amazing! Thanks!

  • @yakovkemer5062
    @yakovkemer5062 Před 3 lety

    Very nice explanation. Time complexion will O(nm) where n is number of candidates and m is a target. You have 2 inputs. So first shit * second shit.

  • @kensword
    @kensword Před 4 lety

    great explanation. thank you!

  • @codetolive27
    @codetolive27 Před 5 lety

    That was awesome.Thanks :)

  • @nETSETOStECH
    @nETSETOStECH Před 5 lety

    nicely explained, cheers

  • @lifehacks9450
    @lifehacks9450 Před 4 lety

    U r awesome pls upload more dfs questions

  • @aishwaryam1052
    @aishwaryam1052 Před 4 lety

    U are the best

  • @adeshmatkar5859
    @adeshmatkar5859 Před 3 lety

    Best!

  • @sahulrajhansa8363
    @sahulrajhansa8363 Před 4 lety

    Subscribed.....

  • @sahulrajhansa8363
    @sahulrajhansa8363 Před 4 lety +1

    What portal or web UI you are using to create the recursive tree??
    please respond!!!

  • @soldiers4838
    @soldiers4838 Před 2 lety

    hello sir i have a problem regarding making combination can you solve it please

  • @lifehacks9450
    @lifehacks9450 Před 4 lety

    U r amazing

  • @krishmpa
    @krishmpa Před 4 lety

    Thank You !

  • @sophiaj6810
    @sophiaj6810 Před rokem

    It would be nice if you have java and python verison.

  • @riturathinsharma5931
    @riturathinsharma5931 Před rokem

    O(n!)

  • @huizhao2050
    @huizhao2050 Před 4 lety

    Can you sort the array first?

  • @AdityaNMurthy
    @AdityaNMurthy Před 5 lety

    I'm not entirely sure, but could the time complexity be O(ArraySize * targetSum) ?