-Now, you can see the list of problems in a table format. You can click on the problem link to view the problem on the LeetCode website. You can also click on the solution link to view the solution of the problem.
\ No newline at end of file
+Now, you can see the list of problems in a table format. You can click on the problem link to view the problem on the LeetCode website. You can also click on the solution link to view the solution of the problem.
diff --git a/dsa-solutions/lc-solutions/0000-0099/0017-Letter-Combinations-of-a-Phone-Number.md b/dsa-solutions/lc-solutions/0000-0099/0017-Letter-Combinations-of-a-Phone-Number.md
index 26cf596b7..76a29c9c4 100644
--- a/dsa-solutions/lc-solutions/0000-0099/0017-Letter-Combinations-of-a-Phone-Number.md
+++ b/dsa-solutions/lc-solutions/0000-0099/0017-Letter-Combinations-of-a-Phone-Number.md
@@ -3,21 +3,23 @@ id: letter-combinations-of-a-phone-number
title: Letter Combinations of a Phone Number (LeetCode)
sidebar_label: 0017 Letter Combinations of a Phone Number
tags:
- - Back Tracking
- - Mapping
- - String
+ - Back Tracking
+ - Mapping
+ - String
description: The problem requires generating all letter combinations corresponding to given digits (2-9). The solution utilizes backtracking to explore all combinations efficiently, employing a recursive approach in Java.
+sidebar_position: 17
---
## Problem Description
-| Problem Statement | Solution Link | LeetCode Profile |
-| :----------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------- |
-| [Letter Combinations of a Phone Number](https://leetcode.com/problems/Letter Combinations of a Phone Number/) | [Letter Combinations of a Phone Number Solution on LeetCode](https://leetcode.com/problems/Letter Combinations of a Phone Number/solutions/5055810/video-two-pointer-solution/) | [gabaniyash846](https://leetcode.com/u/gabaniyash846/) |
+| Problem Statement | Solution Link | LeetCode Profile |
+| :------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------------- |
+| [Letter Combinations of a Phone Number](https://leetcode.com/problems/Letter Combinations of a Phone Number/) | [Letter Combinations of a Phone Number Solution on LeetCode](https://leetcode.com/problems/Letter Combinations of a Phone Number/solutions/5055810/video-two-pointer-solution/) | [gabaniyash846](https://leetcode.com/u/gabaniyash846/) |
### Problem Description
## Problem Statement:
+
Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.
### Examples
@@ -32,7 +34,6 @@ Given a string containing digits from 2-9 inclusive, return all possible letter
- **Input:** `digits = ""`
- **Output:** `[]`
-
#### Example 3
- **Input:** `2`
@@ -47,9 +48,11 @@ Given a string containing digits from 2-9 inclusive, return all possible letter
### Approach
1. **Mapping Digits to Letters:**
+
- Define a mapping of digits to their corresponding letters, similar to telephone buttons.
2. **Backtracking Function:**
+
- Define a recursive backtracking function to generate all possible combinations.
- The function takes four parameters:
- `index`: The current index in the digits string.
@@ -59,6 +62,7 @@ Given a string containing digits from 2-9 inclusive, return all possible letter
- After the recursive call, we remove the last character from the combination (backtracking).
3. **Base Case:**
+
- If the length of the current combination is equal to the length of the input digits string, we add the combination to the result list.
4. **Main Function:**
@@ -153,6 +157,7 @@ public class Solution {
```
#### CPP:
+
```cpp
#include
#include
@@ -208,40 +213,41 @@ int main() {
```
#### JavaScript
+
```js
/**
* @param {string} digits
* @return {string[]}
*/
-var letterCombinations = function(digits) {
- if (digits.length === 0) return [];
-
- const digitToLetters = {
- '2': 'abc',
- '3': 'def',
- '4': 'ghi',
- '5': 'jkl',
- '6': 'mno',
- '7': 'pqrs',
- '8': 'tuv',
- '9': 'wxyz'
- };
-
- const combinations = [];
-
- const backtrack = (index, path) => {
- if (index === digits.length) {
- combinations.push(path);
- return;
- }
- const letters = digitToLetters[digits.charAt(index)];
- for (let letter of letters) {
- backtrack(index + 1, path + letter);
- }
- };
-
- backtrack(0, '');
- return combinations;
+var letterCombinations = function (digits) {
+ if (digits.length === 0) return [];
+
+ const digitToLetters = {
+ 2: "abc",
+ 3: "def",
+ 4: "ghi",
+ 5: "jkl",
+ 6: "mno",
+ 7: "pqrs",
+ 8: "tuv",
+ 9: "wxyz",
+ };
+
+ const combinations = [];
+
+ const backtrack = (index, path) => {
+ if (index === digits.length) {
+ combinations.push(path);
+ return;
+ }
+ const letters = digitToLetters[digits.charAt(index)];
+ for (let letter of letters) {
+ backtrack(index + 1, path + letter);
+ }
+ };
+
+ backtrack(0, "");
+ return combinations;
};
// Example usage:
@@ -249,39 +255,40 @@ console.log(letterCombinations("23")); // Output: ["ad","ae","af","bd","be","bf"
```
#### TypeScript
+
```ts
class Solution {
- private digitToLetters: { [key: string]: string } = {
- '2': 'abc',
- '3': 'def',
- '4': 'ghi',
- '5': 'jkl',
- '6': 'mno',
- '7': 'pqrs',
- '8': 'tuv',
- '9': 'wxyz'
+ private digitToLetters: { [key: string]: string } = {
+ "2": "abc",
+ "3": "def",
+ "4": "ghi",
+ "5": "jkl",
+ "6": "mno",
+ "7": "pqrs",
+ "8": "tuv",
+ "9": "wxyz",
+ };
+
+ letterCombinations(digits: string): string[] {
+ const combinations: string[] = [];
+
+ const backtrack = (index: number, path: string): void => {
+ if (index === digits.length) {
+ combinations.push(path);
+ return;
+ }
+ const letters = this.digitToLetters[digits.charAt(index)];
+ for (let letter of letters) {
+ backtrack(index + 1, path + letter);
+ }
};
- letterCombinations(digits: string): string[] {
- const combinations: string[] = [];
-
- const backtrack = (index: number, path: string): void => {
- if (index === digits.length) {
- combinations.push(path);
- return;
- }
- const letters = this.digitToLetters[digits.charAt(index)];
- for (let letter of letters) {
- backtrack(index + 1, path + letter);
- }
- };
-
- if (digits.length !== 0) {
- backtrack(0, '');
- }
-
- return combinations;
+ if (digits.length !== 0) {
+ backtrack(0, "");
}
+
+ return combinations;
+ }
}
// Example usage:
@@ -294,9 +301,11 @@ console.log(solution.letterCombinations("23")); // Output: ["ad","ae","af","bd",
Here's a step-by-step algorithm for generating all possible letter combinations of a given string of digits using backtracking:
1. **Define a mapping of digits to letters:**
+
- Create a map where each digit from 2 to 9 is mapped to its corresponding letters on a telephone keypad.
2. **Define a backtracking function:**
+
- The function will take the following parameters:
- `index`: The current index in the digits string.
- `path`: The current combination of letters.
@@ -305,6 +314,7 @@ Here's a step-by-step algorithm for generating all possible letter combinations
- After the recursive call, remove the last character from the combination (backtracking).
3. **Base Case:**
+
- If the length of the current combination is equal to the length of the input digits string, add the combination to the result list.
4. **Main Function:**
@@ -312,4 +322,4 @@ Here's a step-by-step algorithm for generating all possible letter combinations
- Call the backtracking function with the initial index set to 0 and an empty string as the initial combination.
- Return the list of combinations.
-This algorithm ensures that all possible combinations are generated by exploring all valid paths through backtracking.
\ No newline at end of file
+This algorithm ensures that all possible combinations are generated by exploring all valid paths through backtracking.
diff --git a/dsa-solutions/lc-solutions/0200-0299/0198-house-robber.md b/dsa-solutions/lc-solutions/0200-0299/0198-house-robber.md
deleted file mode 100644
index 5d95f9320..000000000
--- a/dsa-solutions/lc-solutions/0200-0299/0198-house-robber.md
+++ /dev/null
@@ -1,218 +0,0 @@
----
-id: house-robber
-title: House Robber
-sidebar_label: 0198 House Robber
-tags:
-- Dynamic Programming
-- Array
-- C++
-- Java
-- Python
-description: "This document provides a solution to the House Robber problem, where houses are arranged in a line."
----
-
-## Problem
-You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
-
-Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
-
-### Example 1:
-Input: nums = [1,2,3,1]
-Output: 4
-Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
-
-### Example 2:
-Input: nums = [2,7,9,3,1]
-Output: 12
-Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1). Total amount you can rob = 2 + 9 + 1 = 12.
-
-### Constraints:
-- $1 <= nums.length <= 100$
-- $0 <= nums[i] <= 400$
-
-## Solution
-There is some frustration when people publish their perfect fine-grained algorithms without sharing any information about how they were derived. This is an attempt to change the situation. There is not much more explanation but it's rather an example of higher-level improvements. Converting a solution to the next step shouldn't be as hard as attempting to come up with the perfect algorithm at first attempt.
-
-This particular problem and most others can be approached using the following sequence:
-
-1. Find recursive relation
-2. Recursive (top-down)
-3. Recursive + memo (top-down)
-4. Iterative + memo (bottom-up)
-5. Iterative + N variables (bottom-up)
-
-### Step 1. Figure out recursive relation
-A robber has 2 options:
-a) rob current house i;
-b) don't rob current house.
-If option "a" is selected it means she can't rob the previous i-1 house but can safely proceed to the one before previous i-2 and gets all cumulative loot that follows.
-If option "b" is selected the robber gets all the possible loot from the robbery of i-1 and all the following buildings.
-So it boils down to calculating what is more profitable:
-- robbery of the current house + loot from houses before the previous
-- loot from the previous house robbery and any loot captured before that
-
-rob(i) = Math.max(rob(i - 2) + currentHouseValue, rob(i - 1))
-
-### Step 2. Recursive (top-down)
-Converting the recurrent relation from Step 1 shouldn't be very hard.
-
-```java
-public int rob(int[] nums) {
- return rob(nums, nums.length - 1);
-}
-
-private int rob(int[] nums, int i) {
- if (i < 0) {
- return 0;
- }
- return Math.max(rob(nums, i - 2) + nums[i], rob(nums, i - 1));
-}
-```
-
-This algorithm will process the same i multiple times and it needs improvement.
-
-### Step 3. Recursive + memo (top-down)
-```java
-int[] memo;
-public int rob(int[] nums) {
- memo = new int[nums.length + 1];
- Arrays.fill(memo, -1);
- return rob(nums, nums.length - 1);
-}
-
-private int rob(int[] nums, int i) {
- if (i < 0) {
- return 0;
- }
- if (memo[i] >= 0) {
- return memo[i];
- }
- int result = Math.max(rob(nums, i - 2) + nums[i], rob(nums, i - 1));
- memo[i] = result;
- return result;
-}
-```
-Much better, this should run in O(n) time. Space complexity is O(n) as well, because of the recursion stack, let's try to get rid of it.
-
-### Step 4. Iterative + memo (bottom-up)
-```java
-public int rob(int[] nums) {
- if (nums.length == 0) return 0;
- int[] memo = new int[nums.length + 1];
- memo[0] = 0;
- memo[1] = nums[0];
- for (int i = 1; i < nums.length; i++) {
- int val = nums[i];
- memo[i + 1] = Math.max(memo[i], memo[i - 1] + val);
- }
- return memo[nums.length];
-}
-```
-
-### Step 5. Iterative + 2 variables (bottom-up)
-We can notice that in the previous step we use only memo[i] and memo[i-1], so going just 2 steps back. We can hold them in 2 variables instead. This optimization is met in Fibonacci sequence creation and some other problems.
-
-```java
-public int rob(int[] nums) {
- if (nums.length == 0) return 0;
- int prev1 = 0;
- int prev2 = 0;
- for (int num : nums) {
- int tmp = prev1;
- prev1 = Math.max(prev2 + num, prev1);
- prev2 = tmp;
- }
- return prev1;
-}
-```
-
-## Code in Different Languages
-
-
-
-
-
-```cpp
-#include
-using namespace std;
-
-int rob(vector& nums) {
- int n = nums.size();
- if (n == 0) return 0;
- int prev1 = 0, prev2 = 0;
- for (int num : nums) {
- int tmp = prev1;
- prev1 = max(prev2 + num, prev1);
- prev2 = tmp;
- }
- return prev1;
-}
-
-int main() {
- vector nums = {2, 7, 9, 3, 1};
- cout << rob(nums); // Output: 12
- return 0;
-}
-```
-
-
-
-
-```java
-public class HouseRobber {
- public int rob(int[] nums) {
- if (nums.length == 0) return 0;
- int prev1 = 0;
- int prev2 = 0;
- for (int num : nums) {
- int tmp = prev1;
- prev1 = Math.max(prev2 + num, prev1);
- prev2 = tmp;
- }
- return prev1;
- }
-
- public static void main(String[] args) {
- HouseRobber hr = new HouseRobber();
- int[] nums = {2, 7, 9, 3, 1};
- System.out.println(hr.rob(nums)); // Output: 12
- }
-}
-```
-
-
-
-
-
-```python
-def rob(nums):
- if not nums:
- return 0
- prev1, prev2 = 0, 0
- for num in nums:
- tmp = prev1
- prev1 = max(prev2 + num, prev1)
- prev2 = tmp
- return prev1
-
-nums = [2, 7, 9, 3, 1]
-print(rob(nums)) # Output: 12
-```
-
-
-
-## Complexity Analysis
-
-### Time Complexity: O(N)
-
-> **Reason**: We are running a simple iterative loop, two times. Therefore total time complexity will be O(N) + O(N) ≈ O(N)
-
-### Space Complexity: O(1)
-
-> **Reason**: We are not using extra space.
-
-## References
-
-- **LeetCode Problem**: [House Robber](https://leetcode.com/problems/house-robber/)
-
-- **Author's GeeksforGeeks Profile:** [Vipul Lakum](https://leetcode.com/u/vipul_lakum_02/)
\ No newline at end of file
diff --git a/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md b/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md
new file mode 100644
index 000000000..162d1d8e0
--- /dev/null
+++ b/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md
@@ -0,0 +1,299 @@
+---
+id: Reverse-LinkedList
+title: Reverse LinkedList
+sidebar_label: 206-Reverse-LinkedList
+tags:
+ - Linkedlist
+ - Recursion
+ - Java
+ - C++
+ - Python
+description: "This document provides solutions for determining the Reverse Linkedlist."
+---
+
+# 0206-Reverse LinkedList
+
+### Problem Statement
+
+Given the head of a singly linked list, reverse the list, and return the reversed list.
+
+Example 1:
+
+ 
+
+ Input: head = [1,2,3,4,5]
+ Output: [5,4,3,2,1]
+
+Example 2:
+
+ 
+
+ Input: head = [1,2]
+ Output: [2,1]
+
+Example 3:
+Input: head = []
+Output: []
+
+### Solutions
+
+#### Intuition :
+
+The problem is asking to reverse a singly-linked list. One common approach to reverse a linked list is to use recursion. The idea is to reverse the rest of the list and then move the current node to the end. The base case of the recursion is when the current node is null, in which case the head of the reversed list is set to the previous node.
+
+#### Approach :
+
+1. The solve function is a recursive function that reverses the linked list. It takes three parameters: head (a reference to the head of the reversed list), prev (the previous node in the reversed list), and curr (the current node in the original list).
+
+2. If curr is null, it means we have reached the end of the original list. In this case, we set the head to prev, effectively updating the head of the reversed list, and return.
+
+3. Otherwise, we store the next node in a variable (nextNode) to prevent losing the reference to the rest of the list.
+
+4. We make a recursive call to solve with updated parameters: head remains the same, curr becomes the next node (nextNode), and prev becomes the current node (curr).
+
+5. After the recursive call, we update the next pointer of the current node (curr->next) to point to the previous node (prev), effectively reversing the link.
+
+6. The reverseList function is a wrapper function that checks if the list is empty or has only one element. If so, it returns the head unchanged. Otherwise, it calls the solve function to reverse the list and returns the updated head.
+
+
+
+
+ ```cpp
+ #include
+
+ // Definition for singly-linked list.
+ struct ListNode {
+ int val;
+ ListNode *next;
+ ListNode() : val(0), next(nullptr) {}
+ ListNode(int x) : val(x), next(nullptr) {}
+ ListNode(int x, ListNode *next) : val(x), next(next) {}
+ };
+
+ class Solution {
+ public:
+ void solve(ListNode* &head, ListNode* prev, ListNode* curr) {
+ if (curr == nullptr) {
+ head = prev;
+ return;
+ }
+ ListNode* nextNode = curr->next;
+ solve(head, curr, nextNode);
+ curr->next = prev;
+ }
+
+ ListNode* reverseList(ListNode* head) {
+ if (head == nullptr || head->next == nullptr) {
+ return head;
+ }
+ solve(head, nullptr, head);
+ return head;
+ }
+ };
+
+ // Helper function to print the linked list
+ void printList(ListNode* node) {
+ while (node != nullptr) {
+ std::cout << node->val << " ";
+ node = node->next;
+ }
+ }
+
+ // Driver code
+ int main() {
+ Solution solution;
+ ListNode* head = new ListNode(1);
+ head->next = new ListNode(2);
+ head->next->next = new ListNode(3);
+ head->next->next->next = new ListNode(4);
+ head->next->next->next->next = new ListNode(5);
+
+ std::cout << "Original list: ";
+ printList(head);
+
+ head = solution.reverseList(head);
+
+ std::cout << "\nReversed list: ";
+ printList(head);
+
+ return 0;
+ }
+ ```
+
+
+
+ ```java
+ // Definition for singly-linked list.
+ class ListNode {
+ int val;
+ ListNode next;
+ ListNode() {}
+ ListNode(int val) { this.val = val; }
+ ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ }
+
+ public class Solution {
+ public void solve(ListNode head, ListNode prev, ListNode curr) {
+ if (curr == null) {
+ head = prev;
+ return;
+ }
+ ListNode nextNode = curr.next;
+ solve(head, curr, nextNode);
+ curr.next = prev;
+ }
+
+ public ListNode reverseList(ListNode head) {
+ if (head == null || head.next == null) {
+ return head;
+ }
+ solve(head, null, head);
+ return head;
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+ ListNode head = new ListNode(1);
+ head.next = new ListNode(2);
+ head.next.next = new ListNode(3);
+ head.next.next.next = new ListNode(4);
+ head.next.next.next.next = new ListNode(5);
+
+ System.out.print("Original list: ");
+ printList(head);
+
+ head = solution.reverseList(head);
+
+ System.out.print("\nReversed list: ");
+ printList(head);
+ }
+
+ // Helper function to print the linked list
+ public static void printList(ListNode node) {
+ while (node != null) {
+ System.out.print(node.val + " ");
+ node = node.next;
+ }
+ }
+ }
+ ```
+
+
+
+ ```python
+ # Definition for singly-linked list.
+ class ListNode:
+ def __init__(self, val=0, next=None):
+ self.val = val
+ self.next = next
+
+ class Solution:
+ def solve(self, head: 'ListNode', prev: 'ListNode', curr: 'ListNode') -> None:
+ if curr is None:
+ head[0] = prev
+ return
+ nextNode = curr.next
+ self.solve(head, curr, nextNode)
+ curr.next = prev
+
+ def reverseList(self, head: 'ListNode') -> 'ListNode':
+ if head is None or head.next is None:
+ return head
+ head_ref = [head]
+ self.solve(head_ref, None, head)
+ return head_ref[0]
+
+ # Helper function to print the linked list
+ def printList(node):
+ while node:
+ print(node.val, end=" ")
+ node = node.next
+
+ # Driver code
+ if __name__ == "__main__":
+ solution = Solution()
+ head = ListNode(1)
+ head.next = ListNode(2)
+ head.next.next = ListNode(3)
+ head.next.next.next = ListNode(4)
+ head.next.next.next.next = ListNode(5)
+
+ print("Original list: ", end="")
+ printList(head)
+
+ head = solution.reverseList(head)
+
+ print("\nReversed list: ", end="")
+ printList(head)
+ ```
+
+
+
+ ```c
+ #include
+ #include
+
+ // Definition for singly-linked list.
+ struct ListNode {
+ int val;
+ struct ListNode *next;
+ };
+
+ void solve(struct ListNode** head, struct ListNode* prev, struct ListNode* curr) {
+ if (curr == NULL) {
+ *head = prev;
+ return;
+ }
+ struct ListNode* nextNode = curr->next;
+ solve(head, curr, nextNode);
+ curr->next = prev;
+ }
+
+ struct ListNode* reverseList(struct ListNode* head) {
+ if (head == NULL || head->next == NULL) {
+ return head;
+ }
+ solve(&head, NULL, head);
+ return head;
+ }
+
+ // Helper function to print the linked list
+ void printList(struct ListNode* node) {
+ while (node != NULL) {
+ printf("%d ", node->val);
+ node = node->next;
+ }
+ }
+
+ // Driver code
+ int main() {
+ struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
+ head->val = 1;
+ head->next = (struct ListNode*)malloc(sizeof(struct ListNode));
+ head->next->val = 2;
+ head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
+ head->next->next->val = 3;
+ head->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
+ head->next->next->next->val = 4;
+ head->next->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
+ head->next->next->next->next->val = 5;
+ head->next->next->next->next->next = NULL;
+
+ printf("Original list: ");
+ printList(head);
+
+ head = reverseList(head);
+
+ printf("\nReversed list: ");
+ printList(head);
+
+ return 0;
+ }
+ ```
+
+
+
+
+## Video lecture
+
+
diff --git a/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md b/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md
new file mode 100644
index 000000000..b63c4a2e5
--- /dev/null
+++ b/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md
@@ -0,0 +1,303 @@
+---
+id: Implement-Trie
+title: Implement Trie
+sidebar_label: 0208 Implement-Trie
+tags:
+ - Trie
+ - java
+ - python
+ - c++
+ - Recursion
+description: "This document provides a solution to the Implementation of Trie."
+---
+
+# 0208- Implement Trie (Prefix Tree)
+
+## Problem Statement
+
+A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.
+
+Implement the Trie class:
+
+1. Trie() Initializes the trie object.
+
+2. void insert(String word) Inserts the string word into the trie.
+
+3. boolean search(String word) Returns true if the string word is in the trie (i.e., was inserted before), and false otherwise.
+
+4. boolean startsWith(String prefix) Returns true if there is a previously inserted string word that has the prefix prefix, and false otherwise.
+
+### Example 1:
+
+Input:
+["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
+[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
+Output
+[null, null, true, false, true, null, true]
+
+Explanation
+
+```
+ Trie trie = new Trie();
+
+ trie.insert("apple");
+ trie.search("apple"); // return True
+ trie.search("app"); // return False
+ trie.startsWith("app"); // return True
+ trie.insert("app");
+ trie.search("app"); // return True
+```
+
+## Solutions
+
+ A Trie prefix tree is a tree data structure which is used to store the strings. Each node in the Trie represents a character of the string and stores the boolean value to indicate whether it is the end of a word. The Trie tree is used to find all the possible words by traversing all the nodes of the tree. Insertion in the Trie tree is performed by iterating each character of the string and checking if the character is already present in the Trie tree. If it is present, then move to the corresponding node of that character, otherwise create a new node and connect it with the Trie tree.
+
+
+
+
+ ```cpp
+ #include
+ #include
+
+ class TrieNode {
+ public:
+ TrieNode *child[26];
+ bool isWord;
+ TrieNode() {
+ isWord = false;
+ for (auto &a : child) a = nullptr;
+ }
+ };
+
+ class Trie {
+ TrieNode* root;
+ public:
+ Trie() {
+ root = new TrieNode();
+ }
+ void insert(std::string s) {
+ TrieNode *p = root;
+ for (auto &a : s) {
+ int i = a - 'a';
+ if (!p->child[i]) p->child[i] = new TrieNode();
+ p = p->child[i];
+ }
+ p->isWord = true;
+ }
+ bool search(std::string key, bool prefix=false) {
+ TrieNode *p = root;
+ for (auto &a : key) {
+ int i = a - 'a';
+ if (!p->child[i]) return false;
+ p = p->child[i];
+ }
+ if (prefix == false) return p->isWord;
+ return true;
+ }
+ bool startsWith(std::string prefix) {
+ return search(prefix, true);
+ }
+ };
+
+ // Driver code
+ int main() {
+ Trie trie;
+ trie.insert("apple");
+ std::cout << trie.search("apple") << "\n"; // returns true
+ std::cout << trie.search("app") << "\n"; // returns false
+ std::cout << trie.startsWith("app") << "\n"; // returns true
+ trie.insert("app");
+ std::cout << trie.search("app") << "\n"; // returns true
+ return 0;
+ }
+ ```
+
+
+
+ ```java
+ class TrieNode {
+ TrieNode[] child;
+ boolean isWord;
+
+ public TrieNode() {
+ child = new TrieNode[26];
+ isWord = false;
+ for (int i = 0; i < 26; i++) {
+ child[i] = null;
+ }
+ }
+ }
+
+ class Trie {
+ TrieNode root;
+
+ public Trie() {
+ root = new TrieNode();
+ }
+
+ public void insert(String s) {
+ TrieNode p = root;
+ for (char c : s.toCharArray()) {
+ int i = c - 'a';
+ if (p.child[i] == null) p.child[i] = new TrieNode();
+ p = p.child[i];
+ }
+ p.isWord = true;
+ }
+
+ public boolean search(String key, boolean prefix) {
+ TrieNode p = root;
+ for (char c : key.toCharArray()) {
+ int i = c - 'a';
+ if (p.child[i] == null) return false;
+ p = p.child[i];
+ }
+ if (!prefix) return p.isWord;
+ return true;
+ }
+
+ public boolean startsWith(String prefix) {
+ return search(prefix, true);
+ }
+
+ public static void main(String[] args) {
+ Trie trie = new Trie();
+ trie.insert("apple");
+ System.out.println(trie.search("apple")); // returns true
+ System.out.println(trie.search("app")); // returns false
+ System.out.println(trie.startsWith("app")); // returns true
+ trie.insert("app");
+ System.out.println(trie.search("app")); // returns true
+ }
+ }
+ ```
+
+
+
+ ```python
+ class TrieNode:
+ def __init__(self):
+ self.child = [None] * 26
+ self.isWord = False
+
+ class Trie:
+ def __init__(self):
+ self.root = TrieNode()
+
+ def insert(self, s: str) -> None:
+ p = self.root
+ for a in s:
+ i = ord(a) - ord('a')
+ if not p.child[i]:
+ p.child[i] = TrieNode()
+ p = p.child[i]
+ p.isWord = True
+
+ def search(self, key: str, prefix: bool = False) -> bool:
+ p = self.root
+ for a in key:
+ i = ord(a) - ord('a')
+ if not p.child[i]:
+ return False
+ p = p.child[i]
+ if not prefix:
+ return p.isWord
+ return True
+
+ def startsWith(self, prefix: str) -> bool:
+ return self.search(prefix, True)
+
+ # Driver code
+ if __name__ == "__main__":
+ trie = Trie()
+ trie.insert("apple")
+ print(trie.search("apple")) # returns True
+ print(trie.search("app")) # returns False
+ print(trie.startsWith("app")) # returns True
+ trie.insert("app")
+ print(trie.search("app")) # returns True
+ ```
+
+
+
+ ```c
+ #include
+ #include
+ #include
+
+ // Definition for TrieNode
+ typedef struct TrieNode {
+ struct TrieNode* child[26];
+ bool isWord;
+ } TrieNode;
+
+ // Function to create a new TrieNode
+ TrieNode* createTrieNode() {
+ TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
+ node->isWord = false;
+ for (int i = 0; i < 26; i++) {
+ node->child[i] = NULL;
+ }
+ return node;
+ }
+
+ typedef struct Trie {
+ TrieNode* root;
+ } Trie;
+
+ // Function to create a new Trie
+ Trie* createTrie() {
+ Trie* trie = (Trie*)malloc(sizeof(Trie));
+ trie->root = createTrieNode();
+ return trie;
+ }
+
+ // Function to insert a word into the Trie
+ void insert(Trie* trie, char* s) {
+ TrieNode* p = trie->root;
+ while (*s) {
+ int i = *s - 'a';
+ if (!p->child[i]) p->child[i] = createTrieNode();
+ p = p->child[i];
+ s++;
+ }
+ p->isWord = true;
+ }
+
+ // Function to search for a word or prefix in the Trie
+ bool search(Trie* trie, char* key, bool prefix) {
+ TrieNode* p = trie->root;
+ while (*key) {
+ int i = *key - 'a';
+ if (!p->child[i]) return false;
+ p = p->child[i];
+ key++;
+ }
+ if (!prefix) return p->isWord;
+ return true;
+ }
+
+ // Function to check if a prefix exists in the Trie
+ bool startsWith(Trie* trie, char* prefix) {
+ return search(trie, prefix, true);
+ }
+
+ // Driver code
+ int main() {
+ Trie* trie = createTrie();
+ insert(trie, "apple");
+ printf("%d\n", search(trie, "apple", false)); // returns 1 (true)
+ printf("%d\n", search(trie, "app", false)); // returns 0 (false)
+ printf("%d\n", startsWith(trie, "app")); // returns 1 (true)
+ insert(trie, "app");
+ printf("%d\n", search(trie, "app", false)); // returns 1 (true)
+ return 0;
+ }
+ ```
+
+
+
+
+## Video Lecture:
+
+
diff --git a/dsa-solutions/lc-solutions/0200-0299/image-1.png b/dsa-solutions/lc-solutions/0200-0299/image-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b3e7af253117bfa039b43264b61b1866eb721296
GIT binary patch
literal 15009
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�kj5WFB+nphp&jBBO6b
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
Date: Fri, 14 Jun 2024 09:40:22 +0530
Subject: [PATCH 2/2] corrected
---
.../lc-solutions/0200-0299/0206-Reverse-Linkedlist.md | 7 ++++++-
.../lc-solutions/0200-0299/0208-Implement-Trie.md | 9 ++++++---
2 files changed, 12 insertions(+), 4 deletions(-)
diff --git a/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md b/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md
index 162d1d8e0..b13d40e13 100644
--- a/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md
+++ b/dsa-solutions/lc-solutions/0200-0299/0206-Reverse-Linkedlist.md
@@ -296,4 +296,9 @@ The problem is asking to reverse a singly-linked list. One common approach to re
## Video lecture
-
+
diff --git a/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md b/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md
index b63c4a2e5..e30abfd5d 100644
--- a/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md
+++ b/dsa-solutions/lc-solutions/0200-0299/0208-Implement-Trie.md
@@ -11,8 +11,6 @@ tags:
description: "This document provides a solution to the Implementation of Trie."
---
-# 0208- Implement Trie (Prefix Tree)
-
## Problem Statement
A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.
@@ -300,4 +298,9 @@ Explanation
## Video Lecture:
-
+