How to Solve ANY LeetCode Problem (Step-by-Step)

- Speaker A tells people that they don't need to solve 1000 plus leetcode questions to ace their interviews. Instead, they need a systematic approach and they can solve any problem using this approach. - The first step is to simplify the problem. Then identify the data structure and algorithm they should be using for a given problem. Finally, ask some clarifying questions during the interview. - The problem is straightforward, but it is not efficient. To find the optimal solution, we need to find the shortest path to get from begin word to end word. This is where the flowchart from algomonster helps.

Leetcode is the bane of many wannabe software engineers, as these are the questions asked in interviews for most tech companies. The truth is you don't need to solve 1000 plus leetcode questions to ace your interviews. All you need is a systematic approach and you can solve any problem using this approach. Myself, along with many other engineers I know, have landed jobs at FAANG companies with less than 100 problems solved. Every leetcode question or interview question can be broken down into simple steps, no matter how complicated it seems. Today we're going to go through those steps so that you can tackle any problem you're faced with, even if it seems impossible. I'll explain the exact steps you need to follow, how to figure out what data structure algorithms to use, and I'll even solve a popular hard leetcode question as we go showing you these steps in action. The first step is to simplify the problem. Most leetcode questions have lots of fluff that's hiding what actually matters. The truth is all leetcode questions are the same in nature. You're given inputs and you need to change them into the expected output. After reading any question, you should be able to repeat the problem to yourself or out loud if it's to an interviewer. In the following structure, the inputs are these, we do this to the inputs and finally we get this as the output. If you're struggling to understand how the inputs become the outputs manually walk through a test case. This often makes it clear exactly what's happening. Also, if its a real interview, ask lots of questions. Youre actually given bonus marks for asking clarifying questions, so dont be afraid to ask. In particular, make sure that you catch the edge cases. These are situations that might have a unique or unclear way of handling and interviewers expect you to catch these lets put this step into action for starting our leetcode problem word ladder. Firstly, lets simplify. The inputs are two strings, begin word and end word. We can change one letter at a time in the begin word to change it to a word in our word list until we reach our end word. Our output is an integer representing how many words it took to get from begin word to end word unless this was impossible in which case our output is zero. For our test case we have our starting word as hit and our ending word as cognitive. Lets change one letter of our beginning word to get another word in the word list. Hit becomes hot. Now lets change it again. Now hot becomes dot. As we keep doing this you can see were progressing through our word list. Changing one letter at a time. And finally we get to the end word cog after five total words. Now here are some clarifying questions we might ask an interviewer to get more insight. Is end word guaranteed to be in the word list? Are the words case sensitive? Lastly, these are some edge cases that we should get some clarification on. If begin word end word is the length one or do we return zero? If the word list is empty, do we return zero? Now that we know what we're solving, let's figure out how to solve it. Leetcode is really just pattern recognition most leetcode problems can be solved using the same data structures and algorithms. All you need to do is figure out which one you should use for a given problem. Now before you do this, you need to be familiar with two big o notation and data structures and algorithms. I have three great videos for these concepts which I would check out right now if you are not familiar. Now step one if you are a beginner, start out by explaining the most straightforward solution. By this I mean literally walk your way through the most obvious answer. Even if its not efficient, you dont need to code it, but identify what the time and space complexities would be. From doing this youll often see places that can be simplified and a better solution may pop into your head. Now the second step is to actually find our optimal solution. We need to identify the data structure and algorithm we should be using for this problem. Firstly, check to see if the problem provides any constraints. Often this can give away what you should be using. For example, if a problem has a time complexity of o of log n, there is one specific algorithm that accomplishes this binary search. If theres no obvious hints in the problem, youll need to use the context of the problem to identify the pattern. Luckily, the sponsor of todays video, Algomonster has a completely free flowchart you can use to identify what pattern to use. You can use this while solving leetcode problems to learn what to look for and as we get more familiar youll have the entire thing committed to memory. Algomonster also offers content for learning how to master every single pattern which you can get for $7 a month right now, which will be more than covered in just an hour or two of work. As a full time software engineer, try algomonsters free flowchart today using the link in my description and use the code bagel for an extra 10% off their full interview prep content. Lets apply this to our leethode problem, starting with the straightforward solution and then finding the optimal solution starting from begin word, generate all possible single letter transformations and recursively continue this for each new word until we reach our end word. Im not even going to type out the approach for this because it is clearly not efficient. How inefficient is it? Well for starters we know that each word can be transformed 25 different ways for each letter of the Alphabet except itself. This means each word has 25 times l transformations. Then we also know we have to do this for each word in the word list, which we can represent as nde. Therefore our time and space complexities for the straightforward approach are big o of 25 l to the power of n. Now lets move on to the optimal approach and start by finding the right algorithm to use. Lets use the flowchart from algomonster firstly, is it a graph problem? Well, if a problem can be represented as nodes and connections or has some element of pathfinding, it is likely a graph. So we can say yes to this. Now is it a tree? According to this flowchart, if the problem mentions roots or leaves, its a tree. Otherwise its probably not. So we can safely say no to this path. Now is the problem related to directed acyclic graphs? According to the flowchart, a directed graph has a clear sense of direction implied well for our problem. Do letters have any direction between them? No, they dont. We could easily change an a into a b and vice versa. Therefore we can say no to this as well. Is the problem related to shortest paths? This one is pretty clear with our question. We are looking for the shortest path to get from begin word to end word. So this one is a yes. Lastly, is the graph weighted according to the flowchart? If the edges between words have the same values, it is unweighted. In our case, every transformation of a letter counts as one transformation, so it is unweighted. Now we can clearly see what algorithm we should be using. Breadth first search at this point youve identified the pattern you need to use. The hard part is done. All you need to do now is put this pattern into action for this question. This is where practicing the various patterns becomes useful. Over time, youll realize that 90% of the question is just the same code youve used for other similar questions. This is best illustrated with our problem word ladder. We now know that we are using bfs to solve this problem. If youre not familiar with breadth first search, ive put the default implementation on screen for you to see. For our use case, we only need to make slight tweaks to this algorithm. Firstly, our starting node is just our starting word. On top of keeping track of each word, we also need to keep track of how many transformations or words weve already seen. As we go through each word in our queue, we want to attempt to transform it. To do this, we need to go through each letter in our current word and replace it with every possible letter. Now this will mean we are trying tons of new words, but we can actually rule out almost all of them right away. We only care about a transformed word if it fulfills three conditions. First, if it is a different word than we currently have, aka it's not the exact same word. Second, if it exists in our word list. And third, if we have not yet seen it, if all of these are true, then we need to check is this new word our end word? If it is, we just add one to our current number of transformations and boom. Thats our solution. If its not our end word, it must be a different word in our word list. So we now want to add this word to our queue to go through next and increase our level by one. Dont forget to also add it to our visited set so that we dont try it again. If another word can be transformed into this one again, now its time to code. Just translate your implementation plan to code and youre good to go. If you forget about syntax, don't worry. In a real interview, interviewers are usually good about letting you look at documentation or giving you some help. It's getting the approach that matters, not memorizing syntax. For our problem, I've actually mostly done the coding as I've explained my implementation. Now we can run it and see that everything runs as expected optimally. After you're done, your code runs perfectly, but if not, don't fret. Let's take some time to debug. Next my code ran perfectly and every test passed said no programmer ever there are two types of errors that can occur after you try to run your code. If your code doesn't even run, it's a syntax error which is easily fixable. Just read the error log and make the change. If your code runs but tests fail, it's an implementation error which requires a bit more digging. Firstly, how many tests are actually failing? If it's only one or two, they're likely edge cases you forgot about. Just make the fix to account for these edge cases. But if multiple tests are failing, then you've made a mistake with your implementation. To fix this, the first thing to do is manually walk the test case through your code line by line. Walk through what it's actually doing to the input. Most of the time, you'll catch the mistake here. If you still haven't caught it, you need to figure out where something is going wrong. Try adding print or logging statements to different parts of your code and seeing what the input outputs are at that point. This can show you exactly what is wrong, and now all you need to do is figure out why it's not working as you're expecting. Debugging is probably the hardest part of solving any coding questions. Finding the approach is easy once you've practiced enough, but inevitably little errors always pop up. The key is to practice lots. You'll start to become very familiar with common mistakes that can be made with each approach. That's it. Press submit if you're on leetcode or run your code with your interviewer and you're done. If you follow this step by step approach, combined with getting familiar with data structures and algorithms, you will be able to solve any leetcode question and any interview question that comes your way. Thanks so much for watching this video. If you liked this and wanna see more content like it, make sure to hit the subscribe button and hit the notification bell to stay up to date on the latest uploads. If you wanna learn more about data structures and algorithms, go check out these videos linked in the description below. Thanks and I'll see you all in the next video.