Merge branch 'main' of https://github.com/CodeHarborHub/codeharborhub.github.io into ml

Author: Hemav009

docs/NextJs/image.png

@@ -0,0 +1,170 @@
+---
+id: find-first-and-last-position-of-element-in-sorted-array
+title: Find First and Last Position of Element in Sorted Array(LeetCode)
+sidebar_label: 0034-Find First and Last Position of Element in Sorted Array
+tags:
+  - Array
+  - Binary Search
+description: Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value.
+sidebar_position: 34
+---
+
+## Problem Statement
+
+Given an array of integers `nums` sorted in non-decreasing order, find the starting and ending position of a given `target` value.
+
+If `target` is not found in the array, return [-1, -1].
+
+You must write an algorithm with O(log n) runtime complexity.
+
+### Examples
+
+**Example 1:**
+
+```plaintext
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+```
+
+**Example 2:**
+
+```plaintext
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+```
+
+**Example 3:**
+
+```plaintext
+Input: nums = [], target = 0
+Output: [-1,-1]
+```
+
+### Constraints
+
+- `0 <= nums.length <= 105`
+- `109 <= nums[i] <= 109`
+- `nums` is a non-decreasing array.
+- `109 <= target <= 109`
+
+## Solution
+
+When solving the problem of finding the starting and ending position of a target value in a sorted array, we can use 
+two main approaches: Linear Search (Brute Force) and Binary Search (Optimized). Below, both approaches are explained along with their time and space complexities.
+
+### Approach 1: Linear Search (Brute Force)
+
+#### Explanation:
+
+1. Traverse the array from the beginning to find the first occurrence of the target.
+2. Traverse the array from the end to find the last occurrence of the target.
+3. Return the indices of the first and last occurrences.
+
+#### Algorithm
+
+1. Initialize `startingPosition` and `endingPosition` to -1.
+2. Loop through the array from the beginning to find the first occurrence of the target and set `startingPosition`.
+3. Loop through the array from the end to find the last occurrence of the target and set `endingPosition`.
+4. Return `{startingPosition, endingPosition}`.
+
+#### Implementation
+
+```C++
+class Solution {
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        int startingPosition = -1, endingPosition = -1;
+        int n = nums.size();
+        for(int i = 0; i < n; i++) {
+            if(nums[i] == target) {
+                startingPosition = i;
+                break;
+            }
+        }
+        for(int i = n - 1; i >= 0; i--) {
+            if(nums[i] == target) {
+                endingPosition = i;
+                break;
+            }
+        }
+        return {startingPosition, endingPosition};
+    }
+};
+```
+
+### Complexity Analysis
+
+- **Time complexity**: O(N), where N is the size of the array. In the worst case, we might traverse all elements of the array.
+- **Space complexity**: O(1), as we are using a constant amount of extra space.
+
+### Approach 2: Binary Search (Optimized)
+
+#### Explanation:
+
+1. Use binary search to find the lower bound (first occurrence) of the target.
+2. Use binary search to find the upper bound (last occurrence) of the target by searching for the target + 1 and subtracting 1 from the result.
+3. Check if the target exists in the array and return the indices of the first and last occurrences.
+
+#### Algorithm
+
+1. Define a helper function `lower_bound` to find the first position where the target can be inserted.
+2. Use `lower_bound` to find the starting position of the target.
+3. Use `lower_bound` to find the position where `target + 1` can be inserted, then subtract 1 to get the ending position.
+4. Check if `startingPosition` is within bounds and equals the target.
+5. Return `{startingPosition, endingPosition}` if the target is found, otherwise return `{-1, -1}`.
+
+#### Implementation (First Version)
+
+```C++
+class Solution {
+private:
+    int lower_bound(vector<int>& nums, int low, int high, int target) {
+        while(low <= high) {
+            int mid = (low + high) >> 1;
+            if(nums[mid] < target) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return low;
+    }
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        int low = 0, high = nums.size() - 1;
+        int startingPosition = lower_bound(nums, low, high, target);
+        int endingPosition = lower_bound(nums, low, high, target + 1) - 1;
+        if(startingPosition < nums.size() && nums[startingPosition] == target) {
+            return {startingPosition, endingPosition};
+        }
+        return {-1, -1};
+    }
+};
+```
+#### Implementation (Second Version)
+
+```C++
+class Solution {
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        int startingPosition = lower_bound(nums.begin(), nums.end(), target) - nums.begin();
+        int endingPosition = lower_bound(nums.begin(), nums.end(), target + 1) - nums.begin() - 1;
+        if(startingPosition < nums.size() && nums[startingPosition] == target) {
+            return {startingPosition, endingPosition};
+        }
+        return {-1, -1};
+    }
+};
+```
+
+### Complexity Analysis
+
+- **Time complexity**: O(log N), where N is the size of the array. We perform binary search, which has a logarithmic time complexity.
+- **Space complexity**: O(1), as we are using a constant amount of extra space.
+
+### Conclusion
+
+1. Linear Search is straightforward but less efficient with a time complexity of O(N).
+2. Binary Search is more efficient with a time complexity of O(log N), making it suitable for large datasets.
+Both approaches provide a clear way to find the starting and ending positions of a target value in a sorted array, with the Binary Search approach being the
+optimized solution.

dsa-solutions/lc-solutions/0000-0099/0034-Find-first-and-last-position-in-sorted-array.md

@@ -0,0 +1,194 @@
+---
+id: combination-sum
+title: Combination Sum(LeetCode)
+sidebar_label: 0039-Combination Sum
+tags:
+  - Array
+  - Backtracking
+description: Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target.
+sidebar_position: 39
+---
+
+## Problem Statement
+
+Given an array of distinct integers `candidates` and a target integer `target`, return a list of all unique combinations of `candidates` where the chosen numbers 
+sum to `target`. You may return the combinations in any order.
+
+The same number may be chosen from `candidates` an unlimited number of times. Two combinations are unique if the 
+frequency
+ of at least one of the chosen numbers is different.
+
+The test cases are generated such that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.
+
+### Examples
+
+**Example 1:**
+
+```plaintext
+Input: candidates = [2,3,6,7], target = 7
+Output: [[2,2,3],[7]]
+Explanation:
+2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
+7 is a candidate, and 7 = 7.
+These are the only two combinations.
+```
+
+**Example 2:**
+
+```plaintext
+Input: candidates = [2,3,5], target = 8
+Output: [[2,2,2,2],[2,3,3],[3,5]]
+```
+
+**Example 3:**
+
+```plaintext
+Input: candidates = [2], target = 1
+Output: []
+```
+
+### Constraints
+
+- `1 <= candidates.length <= 30`
+- `2 <= candidates[i] <= 40`
+- All elements of `candidates` are distinct.
+- `1 <= target <= 40`
+
+## Solution
+
+The Combination Sum problem involves finding all unique combinations in a list of candidates where the candidate numbers sum to a given target. Each number in the list may be used an 
+unlimited number of times. Below, we discuss three approaches to solve this problem: DFS (Backtracking), Dynamic Programming (Slow), and Dynamic Programming (Fast).
+
+### Approach 1: DFS (Backtracking)
+
+#### Explanation:
+
+1. Use a recursive function to explore all possible combinations.
+2. Track the current combination (`cur`) and its sum (`cur_sum`).
+3. If `cur_sum` exceeds the target, backtrack.
+4. If `cur_sum` equals the target, add the current combination to the result list.
+
+#### Algorithm
+
+1. Initialize an empty list `ans` to store the results.
+2. Define a recursive function `dfs(cur, cur_sum, idx)` to explore combinations.
+3. In `dfs`, if `cur_sum` exceeds the target, return.
+4. If `cur_sum` equals the target, add `cur` to `ans` and return.
+5. Loop through candidates starting from `idx`, and recursively call `dfs` with updated `cur` and `cur_sum`.
+6. Start the DFS with an empty combination, a sum of 0, and starting index 0.
+7. Return the list `ans`.
+
+#### Implementation
+
+```python
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        ans = []
+        n = len(candidates)
+        def dfs(cur, cur_sum, idx):
+            if cur_sum > target: return
+            if cur_sum == target: 
+                ans.append(cur)
+                return
+            for i in range(idx, n):
+                dfs(cur + [candidates[i]], cur_sum + candidates[i], i)
+        dfs([], 0, 0)
+        return ans
+```
+
+### Complexity Analysis
+
+- **Time complexity**: O(N^(M/min_cand + 1)), where N is the number of candidates, M is the target, and min_cand is the
+   smallest candidate.
+- **Space complexity**: O(M/min_cand), as the recursion depth can go up to the target divided by the smallest
+  candidate.
+
+### Approach 2: Dynamic Programming (Slow)
+
+#### Explanation:
+
+1. Use a list `dp` where `dp[i]` contains combinations that sum up to `i`.
+2. Build the `dp` list by iterating through all possible sums up to the target.
+3. For each sum, update the combinations by considering each candidate.
+
+#### Algorithm
+
+1. Create a dictionary `idx_d` to map each candidate to its index.
+2. Initialize a list `dp` with empty lists for all sums from 0 to the target.
+3. For each sum `i` from 1 to the target:
+* Iterate through all previous sums `j` from 0 to `i-1`.
+* For each combination in `dp[j]`, update combinations in `dp[i]`.
+* Add combinations directly from candidates if they equal `i`.
+4. Return the list `dp[-1]`.
+  
+#### Implementation
+
+```python
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        idx_d = {val: idx for idx, val in enumerate(candidates)}
+        n = len(candidates)
+        dp = [[] for _ in range(target + 1)]
+        for i in range(1, target + 1):
+            for j in range(i):
+                for comb in dp[j]:
+                    start_idx = idx_d[comb[-1]]
+                    for val in candidates[start_idx:]:
+                        if val + j == i:
+                            dp[i].append(comb + [val])
+            for candidate in candidates:
+                if candidate == i:
+                    dp[i].append([candidate])
+        return dp[-1]
+```
+
+### Complexity Analysis
+
+- **Time complexity**: O(MMM*N), where N is the number of candidates and M is the target.
+- **Space complexity**: O(M*M), due to the storage of combinations for each sum up to the target.
+  
+### Approach 3: Dynamic Programming (Fast)
+
+#### Explanation:
+
+1. Use a list `dp` where `dp[i]` contains combinations that sum up to `i`.
+2. For each candidate, update the combinations for all possible sums up to the target.
+
+#### Algorithm
+
+1. Initialize a list `dp` with empty lists for all sums from 0 to the target.
+2. For each candidate `c`:
+3. For each sum `i` from `c` to the target:
+* If `i` equals `c`, add `[c]` to `dp[i]`.
+* For each combination in `dp[i - c]`, add `comb + [c]` to `dp[i]`.
+4. Return the list `dp[-1]`.
+
+#### Implementation
+
+```python
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]
+        for c in candidates:
+            for i in range(c, target + 1):
+                if i == c:
+                    dp[i].append([c])
+                for comb in dp[i - c]:
+                    dp[i].append(comb + [c])
+        return dp[-1]
+```
+
+### Complexity Analysis
+
+- **Time complexity**: O(MMN), where N is the number of candidates and M is the target.
+- **Space complexity**: O(M*M), due to the storage of combinations for each sum up to the target.
+
+### Conclusion
+
+In solving the Combination Sum problem:
+
+1. DFS (Backtracking) is simple and intuitive but can be slow for large inputs due to its exponential time complexity.
+2. Dynamic Programming (Slow) uses a structured approach but has higher time complexity (O(MMM*N)) and memory usage.
+3. Dynamic Programming (Fast) is more efficient (O(MMN)), making it suitable for larger inputs, though it still uses significant memory.
+
+Choose DFS (Backtracking) for smaller datasets, DP (Slow) for a structured approach within manageable limits, and DP (Fast) for larger datasets where efficiency is critical.