Merge branch 'main' into leetcodeque-409

Author: ajay-dhangar

dsa-solutions/gfg-solutions/Easy problems/Plus-One.md

@@ -0,0 +1,175 @@
+---
+id: plus-one
+title: Plus One
+sidebar_label: Plus-One
+tags:
+  - Arrays
+  - STL
+description: "This tutorial covers the solution to the Plus One problem from the GeeksforGeeks."
+---
+## Problem Description
+Given a non-negative number represented as a list of digits, add `1` to the number (increment the number represented by the digits). The digits are stored such that the most significant digit is first element of array.
+
+
+
+## Examples
+
+**Example 1:**
+
+```
+Input: 
+N = 3
+arr[] = {1, 2, 4}
+Output: 
+1 2 5
+Explanation:
+124+1 = 125, and so the Output
+```
+
+**Example 2:**
+
+```
+Input: 
+N = 3
+arr[] = {9,9,9}
+Output: 
+1 0 0 0
+Explanation:
+999+1 = 1000, and so the output
+```
+
+## Your Task
+
+You don't need to read input or print anything. You only need to complete the function `increment()` that takes an integer N, and an array arr of size N as input and returns a list of integers denoting the new number which we get after adding one to the number denoted by the array arr.
+
+Expected Time Complexity: $O(n)$
+
+Expected Auxiliary Space: $O(1)$ for iterative approach.
+
+## Constraints
+
+* `1 ≤ n ≤ 10^5`
+
+## Problem Explanation
+
+Given a non-negative number represented as a list of digits, add `1` to the number (increment the number represented by the digits). The digits are stored such that the most significant digit is first element of array.
+
+## Code Implementation
+
+<Tabs>
+  <TabItem value="Python" label="Python" default>
+  <SolutionAuthor name="@arunimad6yuq"/>
+
+  ```py
+ def increment(digits):
+    for i in range(len(digits) - 1, -1, -1):
+        if digits[i] == 9:
+            digits[i] = 0
+        else:
+            digits[i] += 1
+            return digits
+    digits.insert(0, 1)
+    return digits
+
+  ```
+
+  </TabItem>
+  <TabItem value="C++" label="C++">
+  <SolutionAuthor name="@YourUsername"/>
+
+  ```cpp
+vector<int> increment(vector<int>& digits) {
+    for (int i = digits.size() - 1; i >= 0; --i) {
+        if (digits[i] == 9) {
+            digits[i] = 0;
+        } else {
+            digits[i]++;
+            return digits;
+        }
+    }
+    digits.insert(digits.begin(), 1);
+    return digits;
+}
+
+  ```
+
+  </TabItem>
+
+  <TabItem value="Javascript" label="Javascript" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```javascript
+function increment(digits) {
+    for (let i = digits.length - 1; i >= 0; --i) {
+        if (digits[i] === 9) {
+            digits[i] = 0;
+        } else {
+            digits[i]++;
+            return digits;
+        }
+    }
+    digits.unshift(1);
+    return digits;
+}
+
+
+
+  ```
+
+  </TabItem>
+
+  <TabItem value="Typescript" label="Typescript" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```typescript
+function increment(digits) {
+    for (let i = digits.length - 1; i >= 0; --i) {
+        if (digits[i] === 9) {
+            digits[i] = 0;
+        } else {
+            digits[i]++;
+            return digits;
+        }
+    }
+    digits.unshift(1);
+    return digits;
+}
+
+
+
+  ```
+
+  </TabItem>
+
+  <TabItem value="Java" label="Java" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```java
+public List<Integer> increment(List<Integer> digits) {
+    for (int i = digits.size() - 1; i >= 0; --i) {
+        if (digits.get(i) == 9) {
+            digits.set(i, 0);
+        } else {
+            digits.set(i, digits.get(i) + 1);
+            return digits;
+        }
+    }
+    digits.add(0, 1);
+    return digits;
+}
+
+
+
+  ```
+
+  </TabItem>
+</Tabs>
+
+
+## Time Complexity
+
+* The iterative approach has a time complexity of $O(n)$.
+
+## Space Complexity
+
+* The space complexity is $O(1)$ since we are using only a fixed amount of extra space.

dsa-solutions/lc-solutions/1100-1199/1110-Delete Nodes And Return Forest.md

@@ -0,0 +1,113 @@
+---
+id: delete-nodes-and-return-forest
+title: Delete Nodes And Return Forest
+sidebar_label: Delete Nodes And Return Forest
+tags: [Binary Tree, Depth-First Search, C++, Python, Java]
+description: Solve the problem of deleting nodes from a binary tree and returning the forest of remaining trees using depth-first search.
+---
+
+## Problem Statement
+
+### Problem Description
+
+Given the root of a binary tree, each node in the tree has a distinct value.
+
+After deleting all nodes with a value in `to_delete`, we are left with a forest (a disjoint union of trees).
+
+Return the roots of the trees in the remaining forest. You may return the result in any order.
+
+### Example
+
+**Example 1:**
+```
+Input: root = [1, 2, 3, 4, 5, 6, 7], to_delete = [3, 5]
+Output: [[1, 2, null, 4], [6], [7]]
+```
+
+### Constraints
+
+- The number of nodes in the given tree is at most 1000.
+- Each node has a distinct value between 1 and 1000.
+- `to_delete` contains distinct values between 1 and 1000.
+
+## Solution
+
+### Intuition
+
+The problem can be solved using a depth-first search (DFS) approach. The idea is to traverse the tree and, whenever a node needs to be deleted (i.e., its value is in the `to_delete` list), we handle its children by potentially adding them to the forest if they are not to be deleted. We maintain a set of nodes to be deleted for quick lookup and use a helper function to perform the DFS and manage the forest creation.
+
+### Time Complexity and Space Complexity Analysis
+
+- **Time Complexity**:
+  - The solution involves a single traversal of the tree, making the time complexity $O(n)$, where `n` is the number of nodes in the tree.
+
+- **Space Complexity**:
+  - The space complexity is $O(n)$ due to the recursive call stack and storage for the result list.
+
+### Code
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {
+        unordered_set<int> to_delete_set(to_delete.begin(), to_delete.end());
+        vector<TreeNode*> forest;
+        if (!to_delete_set.count(root->val)) {
+            forest.push_back(root);
+        }
+        dfs(root, to_delete_set, forest);
+        return forest;
+    }
+    
+private:
+    TreeNode* dfs(TreeNode* node, unordered_set<int>& to_delete_set, vector<TreeNode*>& forest) {
+        if (!node) return nullptr;
+        node->left = dfs(node->left, to_delete_set, forest);
+        node->right = dfs(node->right, to_delete_set, forest);
+        if (to_delete_set.count(node->val)) {
+            if (node->left) forest.push_back(node->left);
+            if (node->right) forest.push_back(node->right);
+            return nullptr;
+        }
+        return node;
+    }
+};
+```
+#### Python
+```python
+class Solution:
+    def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
+        seats = [0] * (n + 1)
+        for booking in bookings:
+            first, last, seats_count = booking
+            seats[first - 1] += seats_count
+            if last < n:
+                seats[last] -= seats_count
+        for i in range(1, n):
+            seats[i] += seats[i - 1]
+        return seats[:-1]
+
+```
+#### Java
+```java
+class Solution {
+    public int[] corpFlightBookings(int[][] bookings, int n) {
+        int[] seats = new int[n + 1];
+        for (int[] booking : bookings) {
+            int first = booking[0];
+            int last = booking[1];
+            int seatsCount = booking[2];
+            seats[first - 1] += seatsCount;
+            if (last < n) {
+                seats[last] -= seatsCount;
+            }
+        }
+        for (int i = 1; i < n; i++) {
+            seats[i] += seats[i - 1];
+        }
+        return Arrays.copyOf(seats, n);
+    }
+}
+```