Merge branch 'CodeHarborHub:main' into URLShortner

Author: kartikmehta18

docs/Machine Learning/Hierarchical Clustering.md

@@ -0,0 +1,173 @@
+---
+id: Hierarchical Clustering
+title: Hierarchical Clustering
+sidebar_label: Introduction of Hierarchical Clustering
+sidebar_position: 1
+tags: [hierarchical clustering, clustering algorithm, machine learning, data analysis, data science, dendrogram, agglomerative clustering, divisive clustering, unsupervised learning, data visualization, career opportunities, personal growth, clustering techniques, data segmentation, exploratory data analysis, machine learning algorithms]
+description: In this tutorial, you will learn about Hierarchical Clustering, its importance, what Hierarchical Clustering is, why learn Hierarchical Clustering, how to use Hierarchical Clustering, steps to start using Hierarchical Clustering, and more.
+---
+
+### Introduction to Hierarchical Clustering
+Hierarchical clustering is a powerful unsupervised learning algorithm used for clustering tasks. Unlike partitioning methods such as K-Means, hierarchical clustering builds a tree-like structure (dendrogram) that captures the nested grouping relationships among data points. This algorithm is intuitive, effective, and widely used for understanding the hierarchical relationships within datasets.
+
+### What is Hierarchical Clustering?
+Hierarchical clustering can be divided into two main types:
+
+- **Agglomerative (Bottom-Up) Clustering**: Starts with each data point as an individual cluster and iteratively merges the closest pairs of clusters until a single cluster remains.
+- **Divisive (Top-Down) Clustering**: Starts with all data points in a single cluster and recursively splits them into smaller clusters.
+
+:::info
+**Leaves**: Represent individual data points.
+
+**Nodes**: Represent clusters formed at different stages of the algorithm.
+
+**Height**: Represents the distance or dissimilarity at which clusters are merged or split.
+:::
+
+### Example:
+Consider hierarchical clustering for customer segmentation in a retail company. Initially, each customer is a separate cluster. The algorithm merges customers based on purchase behavior and demographics, forming larger clusters. The dendrogram provides a visual representation of how clusters are nested, helping the company understand customer segments at different levels of granularity.
+
+### Advantages of Hierarchical Clustering
+Hierarchical clustering offers several advantages:
+
+- **Interpretability**: The dendrogram provides a clear and interpretable visual representation of the nested clustering structure.
+- **No Need to Specify Number of Clusters**: Unlike K-Means, hierarchical clustering does not require a predefined number of clusters, allowing for flexible exploration of the data.
+- **Deterministic**: The algorithm is deterministic, meaning it produces the same result with each run, given the same data and parameters.
+
+### Example:
+In a healthcare setting, hierarchical clustering can group patients based on a mix of symptoms, medical history, and demographics, providing interpretable insights into patient subgroups and their relationships.
+
+### Disadvantages of Hierarchical Clustering
+Despite its advantages, hierarchical clustering has limitations:
+
+- **Computational Complexity**: The algorithm can be computationally expensive, especially with large datasets, as it requires computing and updating a distance matrix.
+- **Sensitivity to Noise and Outliers**: Hierarchical clustering can be sensitive to noise and outliers, which may lead to the formation of less meaningful clusters.
+- **Difficulty in Scaling**: The time complexity of hierarchical clustering makes it challenging to scale to very large datasets.
+
+### Example:
+In financial markets, hierarchical clustering of assets based on historical price movements may be impacted by noise and outliers, leading to less stable clustering results.
+
+### Practical Tips for Using Hierarchical Clustering
+To maximize the effectiveness of hierarchical clustering:
+
+- **Distance Metrics**: Choose an appropriate distance metric (e.g., Euclidean, Manhattan, or cosine) based on the nature of your data.
+- **Linkage Criteria**: Select a suitable linkage criterion (e.g., single, complete, or average linkage) to define how the distance between clusters is computed.
+- **Data Preprocessing**: Standardize or normalize your data to ensure that all features contribute equally to the distance calculations.
+
+### Example:
+In e-commerce, hierarchical clustering can be used to segment products based on attributes like price, category, and customer ratings. Preprocessing the data to standardize these attributes ensures that the clustering results are meaningful and interpretable.
+
+### Real-World Examples
+
+#### Customer Segmentation
+Hierarchical clustering is extensively used in retail for customer segmentation. By analyzing customer demographics, purchase history, and behavior, retailers can understand the hierarchical relationships among customer groups and tailor their marketing strategies accordingly.
+
+#### Gene Expression Analysis
+In bioinformatics, hierarchical clustering helps analyze gene expression data by grouping genes with similar expression patterns. This aids in identifying gene functions and understanding the underlying biological processes.
+
+### Difference Between Agglomerative and Divisive Clustering
+
+| Feature                         | Agglomerative Clustering (Bottom-Up)   | Divisive Clustering (Top-Down)  |
+|---------------------------------|-----------------------------------------|---------------------------------|
+| Starting Point                  | Each data point starts as its own cluster. | All data points start in a single cluster. |
+| Process                         | Iteratively merges the closest pairs of clusters. | Recursively splits the largest clusters. |
+| Dendrogram Construction         | Built from the leaves (individual points) up to the root (single cluster). | Built from the root (single cluster) down to the leaves (individual points). |
+| Complexity                      | Generally more computationally efficient and widely used. | Typically more computationally intensive and less commonly used. |
+| Use Cases                       | More suitable for large datasets where fine-grained merging is needed. | Can be useful when the top-down approach aligns better with the problem domain. |
+
+### Implementation
+To implement and train a hierarchical clustering model, you can use a machine learning library such as scikit-learn. Below are the steps to install the necessary library and train a hierarchical clustering model.
+
+#### Libraries to Download
+- `scikit-learn`: This is the primary library for machine learning in Python, including hierarchical clustering implementation.
+- `pandas`: Useful for data manipulation and analysis.
+- `numpy`: Useful for numerical operations.
+
+You can install these libraries using pip:
+
+```bash
+pip install scikit-learn pandas numpy
+```
+
+#### Training a Hierarchical Clustering Model
+Here’s a step-by-step guide to training a hierarchical clustering model:
+
+**Import Libraries:**
+
+```python
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import AgglomerativeClustering
+import matplotlib.pyplot as plt
+import scipy.cluster.hierarchy as sch
+```
+
+**Load and Prepare Data:**
+Assuming you have a dataset in a CSV file:
+
+```python
+# Load the dataset
+data = pd.read_csv('your_dataset.csv')
+
+# Prepare features (X)
+X = data.drop('target_column', axis=1)  # replace 'target_column' with the name of your target column if applicable
+```
+
+**Feature Scaling:**
+
+```python
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+```
+
+**Determine Optimal Number of Clusters:**
+Using the dendrogram to visualize the cluster formation:
+
+```python
+# Plot Dendrogram
+plt.figure(figsize=(10, 7))
+dendrogram = sch.dendrogram(sch.linkage(X_scaled, method='ward'))
+plt.title('Dendrogram')
+plt.xlabel('Samples')
+plt.ylabel('Euclidean distances')
+plt.show()
+```
+
+**Initialize and Train the Hierarchical Clustering Model:**
+
+```python
+# Initialize the Hierarchical Clustering model
+hc = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')  # Choose the appropriate number of clusters
+
+# Train the model
+hc.fit(X_scaled)
+```
+
+**Evaluate the Model:**
+
+```python
+# Predict cluster labels
+cluster_labels = hc.labels_
+
+# Optionally, visualize the clusters
+plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=cluster_labels, cmap='rainbow')
+plt.title('Clusters')
+plt.xlabel('Feature 1')
+plt.ylabel('Feature 2')
+plt.show()
+```
+
+This example demonstrates how to load data, prepare features, scale the features, determine the optimal number of clusters, train a hierarchical clustering model, and visualize the clustering results. You can adjust parameters and the dataset as needed for your specific use case.
+
+### Performance Considerations
+
+#### Scalability and Computational Efficiency
+- **Large Datasets**: Hierarchical clustering can be slow with large datasets due to the need to compute and update the distance matrix.
+- **Algorithmic Complexity**: Using techniques like approximate hierarchical clustering or limiting the dendrogram depth can improve scalability and efficiency.
+
+### Example:
+In geospatial analysis, hierarchical clustering is used to identify patterns in geographical data. Optimizing the algorithm for large-scale geospatial data ensures efficient and accurate clustering, aiding in urban planning and resource allocation.
+
+### Conclusion
+Hierarchical clustering is a versatile and powerful unsupervised learning algorithm suitable for a variety of applications. Understanding its strengths, limitations, and proper usage is crucial for effectively applying it to different datasets. By carefully selecting parameters, scaling features, and considering computational efficiency, hierarchical clustering can provide valuable insights and groupings for numerous real-world problems.

dsa-problems/leetcode-problems/0100-0199.md

@@ -518,31 +518,32 @@ export const problems = [
         "problemName": "184. Department Highest Salary",
         "difficulty": "Medium",
         "leetCodeLink": "https://leetcode.com/problems/department-highest-salary",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0100-0199/department-highest-salary"
     },
     {
         "problemName": "185. Department Top Three Salaries",
         "difficulty": "Hard",
         "leetCodeLink": "https://leetcode.com/problems/department-top-three-salaries",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0100-0199/department-top-three-salaries"
     },
     {
         "problemName": "186. Reverse Words in a String II",
         "difficulty": "Medium",
         "leetCodeLink": "https://leetcode.com/problems/reverse-words-in-a-string-ii",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0100-0199/reverse-words-in-string-II"
     },
     {
         "problemName": "187. Repeated DNA Sequences",
         "difficulty": "Medium",
         "leetCodeLink": "https://leetcode.com/problems/repeated-dna-sequences",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0100-0199/repeated-dna-sequence"
+
     },
     {
         "problemName": "188. Best Time to Buy and Sell Stock IV",
         "difficulty": "Hard",
         "leetCodeLink": "https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0100-0199/best-time-to-buy-sell-stock-IV"
     },
     {
         "problemName": "189. Rotate Array",

dsa-solutions/Searching-Algorithms/Backward-Search.md

@@ -0,0 +1,146 @@
+---
+id: Backward-Search-Algorithm
+title: Backward Search Algorithm
+sidebar_label: Backward Search Algorithm
+tags:
+  - Advanced
+  - Search Algorithms
+  - Text Processing
+  - CPP
+  - Python
+  - Java
+  - JavaScript
+  - DSA
+description: "This is a solution to the Backward Search Algorithm problem."
+---
+
+## What is the Backward Search Algorithm?
+
+The Backward Search Algorithm is a search method typically used in text processing and pattern matching. It works by searching for a pattern in a text from right to left, which can be more efficient in certain contexts compared to traditional left-to-right search algorithms.
+
+## Algorithm Steps
+
+1. **Preprocessing**:
+   - Construct a rightmost occurrence function that maps each character in the pattern to its rightmost position.
+
+2. **Searching**:
+   - Align the pattern with the beginning of the text.
+   - Compare characters from right to left.
+   - If a mismatch is found, use the rightmost occurrence function to determine the next alignment.
+   - If the entire pattern matches, record the position of the match.
+
+## Complexity Analysis
+
+- **Time Complexity**: The average-case time complexity is \(O(n/m)\) where \(n\) is the length of the text and \(m\) is the length of the pattern.
+- **Space Complexity**: The space complexity is \(O(k)\) where \(k\) is the size of the character set.
+
+## Example
+
+Given a pattern and a text:
+
+```
+pattern = "ABC"
+text = "AABCABCDABC"
+```
+
+
+Using the Backward Search Algorithm:
+
+- The algorithm will search the pattern "ABC" in the text "AABCABCDABC" from right to left.
+
+## Implementation
+
+<Tabs>
+  <TabItem value="Python" label="Python" default>
+
+```python
+def rightmost_occurrence_function(pattern):
+    rightmost = {}
+    for i in range(len(pattern)):
+        rightmost[pattern[i]] = i
+    return rightmost
+
+def backward_search(text, pattern):
+    rightmost = rightmost_occurrence_function(pattern)
+    m, n = len(pattern), len(text)
+    i = m - 1
+    j = m - 1
+    
+    while i < n:
+        if text[i] == pattern[j]:
+            if j == 0:
+                return i
+            else:
+                i -= 1
+                j -= 1
+        else:
+            lo = rightmost.get(text[i], -1)
+            i += m - min(j, 1 + lo)
+            j = m - 1
+    
+    return -1
+
+# Example usage:
+pattern = "ABC"
+text = "AABCABCDABC"
+result = backward_search(text, pattern)
+print(f"Pattern found at index: {result}")
+```
+
+  </TabItem>
+  <TabItem value="C++" label="C++">
+
+```cpp
+
+#include <iostream>
+#include <unordered_map>
+#include <string>
+
+std::unordered_map<char, int> rightmost_occurrence_function(const std::string &pattern) {
+    std::unordered_map<char, int> rightmost;
+    for (int i = 0; i < pattern.size(); ++i) {
+        rightmost[pattern[i]] = i;
+    }
+    return rightmost;
+}
+
+int backward_search(const std::string &text, const std::string &pattern) {
+    auto rightmost = rightmost_occurrence_function(pattern);
+    int m = pattern.size();
+    int n = text.size();
+    int i = m - 1;
+    int j = m - 1;
+    
+    while (i < n) {
+        if (text[i] == pattern[j]) {
+            if (j == 0) {
+                return i;
+            } else {
+                --i;
+                --j;
+            }
+        } else {
+            int lo = rightmost.find(text[i]) != rightmost.end() ? rightmost[text[i]] : -1;
+            i += m - std::min(j, 1 + lo);
+            j = m - 1;
+        }
+    }
+    
+    return -1;
+}
+
+int main() {
+    std::string pattern = "ABC";
+    std::string text = "AABCABCDABC";
+    int result = backward_search(text, pattern);
+    std::cout << "Pattern found at index: " << result << std::endl;
+    return 0;
+}
+
+```
+
+  </TabItem>
+</Tabs>
+
+# Conclusion
+The Backward Search Algorithm is a powerful method for pattern matching in text processing. By searching from right to left and leveraging the rightmost occurrence function, it provides efficient searching capabilities, especially useful in specific contexts where this directionality offers advantages over traditional approaches.