Skip to content

Commit

Permalink
Batch-4/Neetcode-150/Added-hints (#3768)
Browse files Browse the repository at this point in the history
  • Loading branch information
@Srihari2222
Srihari2222 authored Dec 18, 2024
1 parent e3af24d commit d15fd78
Show file tree
Hide file tree
Showing 10 changed files with 374 additions and 0 deletions.
31 changes: 31 additions & 0 deletions hints/cheapest-flight-path.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,31 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n + (m * k))</code> time and <code>O(n)</code> space, where <code>n</code> is the number of cities, <code>m</code> is the number of flights, and <code>k</code> is the number of stops.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
Consider this as a graph problem where the cities are nodes and the flights are edges connecting two cities, with the ticket cost as the edge weight. Can you think of a shortest path algorithm to solve the problem? Perhaps a better algorithm than Dijkstra's that can intuitively handle the <code>k</code> stops condition.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
We can use the Bellman-Ford algorithm. Initialize a <code>prices</code> array of size <code>n</code> with <code>Infinity</code>, setting <code>prices[source] = 0</code>. THese values describe the cost to reach a city from the source city. Iterate <code>(k + 1)</code> times (stops are 0-indexed), updating the cost to each city by extending paths from cities with valid costs. We only update the cost for a city if it is less than the previous cost. How would you implement this?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
At each level of iteration, we go through the given flights and use them to update the price array with the minimum costs compared to the previous level. We use a temporary prices array at each level to store the updated costs. After completing all levels, we return the result stored in <code>prices[dst]</code>. If that value is <code>Infinity</code>, we return <code>-1</code> instead.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/climbing-stairs.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n)</code> time and <code>O(n)</code> space, where <code>n</code> is the number of steps.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
At each step, we have two choices: climb one step or climb two steps. We can solve this by considering both options and picking the minimum using recursion. However, this results in <code>O(2^n)</code> time complexity. Can you think of a better approach? Perhaps, try to avoid the repeated work of calling recursion more than once with same parameters.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
This is a Dynamic Programming problem. We can use Memoization to avoid repeated work. Create an <code>n</code>-sized array <code>cache</code> to store the results of recursive calls. When the recursion is called with specific parameters, return the stored value if it has already been computed. How would you implement this?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
We start the initial recursion with <code>i = 0</code>, indicating that we are at position <code>i</code>. We first check if the current recursion with the given <code>i</code> is already cached. If it is, we immediately return the stored value. Otherwise, we perform the recursion, store the result in the cache, and then return it. Can you think of the base condition to stop the recursion?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
At each recursion, we perform two recursive calls: one for climbing one step and another for climbing two steps. The minimum return value between the two is the result for the current recursion. The base condition is to return <code>0</code> if <code>i == n</code>. This is a one-dimensional dynamic programming problem, which can be further optimized using more advanced techniques.
</p>
</details>
31 changes: 31 additions & 0 deletions hints/coin-change.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,31 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution with <code>O(n * t)</code> time and <code>O(t)</code> space, where <code>n</code> is the number of coins and <code>t</code> is the given amount.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
Think of this problem in terms of recursion and try to visualize the decision tree, as there are multiple choices at each step. We start with the given amount. At each step of recursion, we have <code>n</code> coins and branch into paths using coins that are less than or equal to the current amount. Can you express this in terms of a recurrence relation? Also, try to determine the base condition to stop the recursion.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
If the amount is <code>0</code>, we return <code>0</code> coins. The recurrence relation can be expressed as <code>min(1 + dfs(amount - coins[i]))</code>, where we return the minimum coins among all paths. This results in an <code>O(n ^ t)</code> solution, where <code>n</code> is the number of coins and <code>t</code> is the total amount. Can you think of a better approach? Perhaps consider the repeated work and find a way to avoid it.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
We can use memoization to avoid the repeated work of calculating the result for each recursive call. A hash map or an array of size <code>t</code> can be used to cache the computed values for a specific <code>amount</code>. At each recursion step, we iterate over every coin and extend only the valid paths. If a result has already been computed, we return it from the cache instead of recalculating it.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/decode-ways.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n)</code> time and <code>O(n)</code> space, where <code>n</code> is the length of the given string.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
The characters <code>A</code> through <code>Z</code> are mapped to the numbers from <code>1</code> to <code>26</code>. A mapped number can have at most <code>2</code> digits. In the given string of digits, we can explore all possible decodings by combining one or two consecutive digits. Think of this in terms of a decision tree and explore all paths. Can you derive a recurrence relation for this?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
Iterate over the string with index <code>i</code>. At each index, we have two choices: decode the current digit as a character with its mapped value, or combine the current digit with the next digit to form a two-digit value. The recurrence relation can be expressed as <code>dfs(i + 1) + dfs(i + 2)</code> where <code>dfs</code> is the recursive function. Also, consider edge cases, as not every two-digit number or a number with a leading zero is valid. How would you implement this?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
A brute-force recursive solution would result in <code>O(2^n)</code> time complexity. Can you think of a better way? Perhaps you should consider the repeated work of calling the recursion multiple times with the same parameter values and find a way to avoid this. Also, can you think about the base condition of this recursive function?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
The base condition is to return <code>1</code> if <code>i</code> goes out of bounds. If the current digit is <code>'0'</code>, return <code>0</code>, as no character maps to <code>'0'</code>, making the string invalid. Use memoization to avoid repeated work by caching recursion results in an array or hash map and returning the stored value when the result is already calculated.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/foreign-dictionary.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution with <code>O(N + V + E)</code> time and <code>O(V + E)</code> space, where <code>N</code> is the sum of the lengths of all the strings, <code>V</code> is the number of unique characters (vertices), and <code>E</code> is the number of edges.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
Can you think of this as a graph problem? Characters from <code>a</code> through <code>z</code> are nodes. What could the edges represent here? How can you create edges from the given words? Perhaps you should try comparing two adjacent words.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
The relative ordering of the characters can be treated as edges. For example, consider the words ordered as <code>["ape", "apple"]</code>. <code>"ape"</code> comes before <code>"apple"</code>, which indicates that <code>'e'</code> is a predecessor of <code>'p'</code>. Therefore, there is a directed edge <code>e -> p</code>, and this dependency should be valid across all the words. In this way, we can build an adjacency list by comparing adjacent words. Can you think of an algorithm that is suitable to find a valid ordering?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
We can use Topological Sort to ensure every node appears after its predecessor. Using DFS, we traverse the graph built from the adjacency list. A visited map tracks nodes in the current DFS path: <code>False</code> means not in the path, and <code>True</code> means in the path. If any DFS call returns <code>True</code>, it indicates a cycle and we return immediately. How do we extract the ordering from this DFS?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
When we visit a node and its children and don't find a cycle, we mark the node as <code>False</code> in the map and append it to the result, treating this as a post-order traversal. If we find a cycle, we return an empty string; otherwise, we return the result list.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/house-robber-ii.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n)</code> time and <code>O(n)</code> space, where <code>n</code> is the number of houses.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
First, consider solving the problem to get the maximum money after robbing without the condition that 'the first and last houses are adjacent'. Can you express this using a recurrence relation? Perhaps you could draw a decision tree, as at each step, you can either rob the current house and skip the next one or skip the current house and move to the next.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
The recurrence relation can be expressed as <code>max(nums[i] + dfs(i + 2), dfs(i + 1))</code>, where <code>i</code> is the current house and <code>dfs</code> is the recursive function. The base condition for this recursion would be to return <code>0</code> when <code>i</code> goes out of bounds. This solution results in <code>O(2^n)</code> time complexity because, at each recursive step, we branch into two paths. Can you think of a way to avoid recalculating the result for the same recursive call multiple times?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
We can use memoization to store the result of a recursive function in a hash map or an array and immediately return this value when the function is called again with the same parameter values. How would you implement this? How would you solve the problem if the first and last houses are adjacent to each other? Perhaps you should consider skipping any one house between the two.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
We can create two arrays from the given array. The first will include houses from the first house to the second-to-last house, and the second will include houses from the second house to the last house. We can run the recursive function on both arrays independently and return the maximum result between the two. Advanced techniques such as bottom-up dynamic programming can further optimize the solution.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/house-robber.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n)</code> time and <code>O(n)</code> space, where <code>n</code> is the number of houses.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
Can you think of this problem in terms of recursion? Consider drawing a decision tree where, at each step, we can choose to rob the house or skip it. If we rob the current house, we cannot rob the next or the previous house. Can you derive a recurrence relation to solve the problem?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
We can recursively start from the first house and branch paths accordingly. If we rob the current house, we skip the next house; otherwise, we move to the next house. The recurrence relation can be expressed as <code>max(nums[i] + dfs(i + 2), dfs(i + 1))</code>, where <code>i</code> is the current house and <code>dfs</code> is the recursive function. Can you determine the base condition to stop the recursion?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
The base condition would be to return <code>0</code> when <code>i</code> goes out of bounds. This recursion can leads to <code>O(2^n)</code> time solution. Can you think of a better way? Maybe you should try to avoid recalculating the result for a recursive call.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
We can use Memoization to avoid recalculating the result multiple times for a recursive call. By storing the result of each recursive call in a hash map or an array using <code>i</code> as the parameter, we can immediately return the stored result if the recursion is called with the same <code>i</code> value again. Further optimization can be achieved using advanced techniques like Bottom-Up dynamic programming.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/longest-palindromic-substring.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n^2)</code> time and <code>O(1)</code> space, where <code>n</code> is the length of the given string.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
A brute-force solution would be to check if every substring is a palindrome and return the maximum length among all the palindromic substring lengths. This would be an <code>O(n^3)</code> time solution. Can you think of a better way? Perhaps you should consider thinking in terms of the center of a palindrome.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
Iterate over the string with index <code>i</code> and treat the current character as the center. For this character, try to extend outward to the left and right simultaneously, but only if both characters are equal. Update the result variable accordingly. How would you implement this? Can you consider both cases: even-length and odd-length palindromes?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
Maintain two variables, <code>resLen</code> and <code>res</code>, which denote the length of the longest palindrome and the start index of that palindrome, respectively. At each index, you can create an odd-length palindrome starting at that index extending outward from both its left and right indices, i.e., <code>i - 1</code> and <code>i + 1</code>. How can you find the even-length palindrome for this index?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
For an even-length palindrome, consider expanding from indices <code>i</code> and <code>i + 1</code>. This two-pointer approach, extending from the center of the palindrome, will help find all palindromic substrings in the given string. Update the two result variables and return the substring starting at <code>res</code> with a length of <code>resLen</code>.
</p>
</details>
39 changes: 39 additions & 0 deletions hints/min-cost-climbing-stairs.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
<br>
<details class="hint-accordion">
<summary>Recommended Time & Space Complexity</summary>
<p>
You should aim for a solution as good or better than <code>O(n)</code> time and <code>O(n)</code> space, where <code>n</code> is the number of steps on the staircase.
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 1</summary>
<p>
Can you find the recurrence relation to solve the problem, given that at each step we have two options: going one step or two steps? Consider drawing a decision tree where we branch into two paths at each step. By exploring every path, we can get the minimum cost. However, this results in an <code>O(2^n)</code> time solution. Can you think of a better approach? Is there any repeated work in the decision tree that we can optimize?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 2</summary>
<p>
The recurrence relation can be expressed as <code>cost[i] + min(dfs(i + 1), dfs(i + 2))</code>, where <code>i</code> is the current position and <code>dfs</code> is the recursive function. To avoid recalculating the result of a recursive call multiple times, we can use Memoization. Initialize a <code>cache</code> array of size <code>n</code>, where <code>n</code> is the number of steps on the staircase. How would you implement this?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 3</summary>
<p>
We start the recursion from positions <code>0</code> and <code>1</code>. At each recursive step, before computing the result, we check if the result for the current position has already been calculated. If it has, we return the stored value. Otherwise, we calculate the result for the current position, store it in the cache, and then return the result. What can be the base condition for this recursion to stop?
</p>
</details>

<br>
<details class="hint-accordion">
<summary>Hint 4</summary>
<p>
The base condition would be to return <code>0</code> if we are at the top of the staircase <code>i >= n</code>. This is a one-dimensional dynamic programming problem. We can further optimize the memoization solution by using advanced techniques such as Bottom-Up dynamic programming based on the recurrance relation.
</p>
</details>
Loading

0 comments on commit d15fd78

Please sign in to comment.