Merge branch 'master' into feature/div

mrid88 · web-flow · commit f17c0224c855 · 2025-03-23T11:53:57.000+05:30
diff --git a/DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence - Explanation.md b/DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence - Explanation.md
@@ -0,0 +1,38 @@
+Shortest Common Supersequence Solution
+Overview
+The goal of this solution is to find the shortest common supersequence (SCS) of two given strings, str1 and str2. The shortest common supersequence is the shortest string that has both str1 and str2 as subsequences.
+
+Steps
+Create DP Table:
+
+We first create a dynamic programming (DP) table dp of size (m + 1) x (n + 1), where m is the length of str1 and n is the length of str2.
+
+Fill the DP Table:
+
+We fill the DP table based on the following conditions:
+
+If characters of str1 and str2 match, we take the diagonal value and add 1: dp[i][j] = dp[i - 1][j - 1] + 1.
+
+If characters do not match, we take the maximum value from the left or the top cell: dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]).
+
+Build the Shortest Common Supersequence:
+
+We use a StringBuilder to construct the SCS.
+
+Starting from the bottom-right corner of the DP table, we move based on the values in the DP table:
+
+If characters match, we add that character to the result and move diagonally up-left.
+
+If characters do not match, we move in the direction of the larger DP value (either up or left).
+
+Finally, we add any remaining characters from str1 or str2.
+
+Reverse the Result:
+
+The result is constructed in reverse order, so we reverse it before returning.
+
+Time Complexity
+The time complexity is O(m * n) because we traverse the DP table of size (m + 1) x (n + 1).
+
+Space Complexity
+The space complexity is O(m * n) because we use a DP table of size (m + 1) x (n + 1).
diff --git a/DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence.java b/DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence.java
@@ -0,0 +1,56 @@
+class Solution {
+    public String shortestCommonSupersequence(String str1, String str2) {
+        int m = str1.length();
+        int n = str2.length();
+
+        // Create DP table
+        int[][] dp = new int[m + 1][n + 1];
+
+        // Fill the DP table
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1; // If characters match
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // Take max from either previous row or column
+                }
+            }
+        }
+
+        // Build the shortest common supersequence
+        StringBuilder result = new StringBuilder();
+        int i = m, j = n;
+        while (i > 0 && j > 0) {
+            // If characters are the same, add to the result
+            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+                result.append(str1.charAt(i - 1));
+                i--;
+                j--;
+            } else if (dp[i - 1][j] > dp[i][j - 1]) { // Move in the direction of the larger dp value
+                result.append(str1.charAt(i - 1));
+                i--;
+            } else {
+                result.append(str2.charAt(j - 1));
+                j--;
+            }
+        }
+
+        // If there are any remaining characters in str1
+        while (i > 0) {
+            result.append(str1.charAt(i - 1));
+            i--;
+        }
+
+        // If there are any remaining characters in str2
+        while (j > 0) {
+            result.append(str2.charAt(j - 1));
+            j--;
+        }
+
+        // Reverse the result before returning
+        return result.reverse().toString();
+    }
+}
+
+//Time Complexity : O(m*n)
+//Space Complexity : O(m*n)
diff --git a/Daily Questions/#3208 - Alterating Groups II - Medium/Explanation.md b/Daily Questions/#3208 - Alterating Groups II - Medium/Explanation.md
@@ -0,0 +1,67 @@
+## Explanation of the `numberOfAlternatingGroups` Method
+
+The `numberOfAlternatingGroups` method in the `Solution` class takes an array of integers `colors` and an integer `k` as input, and returns the number of alternating groups of size `k` within the array.
+
+### Code Breakdown
+
+1. **Initialization**
+    ```java
+    int window = 1;
+    int res = 0;
+    int n = colors.length;
+    int i = 0;
+    int j = 1;
+    ```
+    - `window`: Keeps track of the current window size.
+    - `res`: Stores the count of alternating groups of size `k`.
+    - `n`: Stores the length of the `colors` array.
+    - `i`, `j`: Pointers to traverse the array.
+
+2. **While Loop to Traverse the Array**
+    ```java
+    while(i < colors.length) {
+        if(colors[(j-1) % n] != colors[j%n]) {
+            window++;
+            j++;
+        }else {
+            i = j;
+            j = i + 1;
+            window = 1;
+            continue;
+        }
+
+        if(window == k) {
+            res++;
+            if(colors[(j-1) % n] != colors[j%n]) {
+                i++;
+                window -= 1;
+            }else {
+                i = j;
+                j = i + 1;
+                window = 1;
+            }
+        }
+    }
+    ```
+    - The loop iterates through the array while `i` is less than the length of `colors`.
+    - It checks if the current and the next colors are different. If they are different, the window size is incremented, and `j` is incremented.
+    - If they are the same, it resets the window and continues the iteration.
+    - When the window size reaches `k`, it increments the `res` count and adjusts the window accordingly.
+
+3. **Return the Result**
+    ```java
+    return res;
+    ```
+    - Returns the total count of alternating groups of size `k`.
+
+### Example
+
+Given the `colors` array `[1, 2, 1, 2, 1]` and `k = 3`:
+- The method will return `2` since there are two alternating groups of size 3: `[1, 2, 1]` and `[2, 1, 2]`.
+
+### Time Complexity
+- The time complexity of this method is O(n), where `n` is the length of the `colors` array, as it traverses the array a constant number of times.
+
+### Space Complexity
+- The space complexity is O(n) as only a few variables are used, and no additional data structures are required.
+
diff --git a/Daily Questions/#3208 - Alterating Groups II - Medium/Solution.java b/Daily Questions/#3208 - Alterating Groups II - Medium/Solution.java
@@ -0,0 +1,34 @@
+class Solution {
+    public int numberOfAlternatingGroups(int[] colors, int k) {
+        int window = 1;
+        int res = 0;
+        int n = colors.length;
+        int i = 0;
+        int j = 1;
+        while(i < colors.length) {
+            if(colors[(j-1) % n] != colors[j%n]) {
+                window++;
+                j++;
+            }else {
+                i = j;
+                j = i + 1;
+                window = 1;
+                continue;
+            }
+            
+            if(window == k) {
+                res++;
+                if(colors[(j-1) % n] != colors[j%n]) {
+                    i++;
+                    window -= 1;
+                }else {
+                    i = j;
+                    j = i + 1;
+                    window = 1;
+                }   
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/Explanation-Template.md b/Explanation-Template.md
@@ -0,0 +1,95 @@
+# Problem Title
+
+**Difficulty:** *(Easy / Medium / Hard)*  
+**Category:** *(Arrays, Strings, Dynamic Programming, Graphs, etc.)*  
+**Leetcode Link:** [Problem Link](#)
+
+---
+
+## 📝 Introduction
+
+*A brief introduction to the problem. Mention the key aspects, constraints, and expected output.*
+
+---
+
+## 💡 Approach & Key Insights
+
+*Describe the main idea behind solving the problem. What observations lead to a solution? Mention brute force or naive approaches first, then discuss optimal solutions.*
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:** *Describe the brute force solution and why it works.*
+- **Time Complexity:** *O(?) - Explanation*
+- **Space Complexity:** *O(?) - Explanation*
+- **Example/Dry Run:**
+
+Example input: [Insert example] Step 1 → Step 2 → Step 3 → Output
+
+
+### 2️⃣ Optimized Approach
+
+- **Explanation:** *Describe an optimized approach with clear reasoning.*
+- **Time Complexity:** *O(?) - Explanation*
+- **Space Complexity:** *O(?) - Explanation*
+- **Example/Dry Run:**
+
+Example input: [Insert example] Step 1 → Step 2 → Step 3 → Output
+
+
+### 3️⃣ Best / Final Optimized Approach (if applicable)
+
+- **Explanation:** *Discuss the best possible solution.*
+- **Time Complexity:** *O(?) - Explanation*
+- **Space Complexity:** *O(?) - Explanation*
+- **Example/Dry Run:**
+
+Example input: [Insert example] Step 1 → Step 2 → Step 3 → Output
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(?)            | O(?)             |
+| Optimized     | O(?)            | O(?)             |
+| Best Approach | O(?)            | O(?)             |
+
+---
+
+## 📉 Optimization Ideas
+
+*Are there any ways to further improve the solution? Can we reduce memory usage or optimize certain operations?*
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+*Use visuals, ASCII diagrams, or step-by-step breakdowns for clarity.*
+
+```plaintext
+Example:
+Input: 1 -> 2 -> 3 -> 4
+Process:
+1 -> Swap 2 & 3
+2 -> Reverse half of list
+3 -> Merge both halves
+Output: 1 -> 3 -> 2 -> 4
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [Resource 1]()
+- [Resource 2]()
+- [Resource 3]()
+
+---
+
+Author: Your Name
+Date: DD/MM/YYYY
diff --git a/Problems/#70 - Climbing Stairs - Easy/Explanation.md b/Problems/#70 - Climbing Stairs - Easy/Explanation.md
@@ -0,0 +1,53 @@
+# Explanation of the `climbStairs` Code
+
+This Java class provides a solution to the classic "Climbing Stairs" problem using dynamic programming. The goal is to determine the number of distinct ways to climb a staircase with `n` steps, where you can take either 1 step or 2 steps at a time.
+
+---
+
+## Class: `Solution`
+
+### Method: `climbStairs(int n)`
+
+#### **Purpose**
+This method calculates the number of ways to climb a staircase with `n` steps.
+
+#### **Parameters**
+- `n`: An integer representing the total number of steps in the staircase.
+
+#### **Logic**
+1. **Base Cases**:
+   - If `n == 1`, return `1` since there is only one way to climb a single step.
+   - If `n == 2`, return `2` since there are two ways to climb two steps: either `1+1` or `2`.
+
+2. **Dynamic Programming Array**:
+   - Create an integer array `a` of size `n`.
+   - Initialize the first two elements:
+     - `a[0] = 1` (1 way to climb 1 step).
+     - `a[1] = 2` (2 ways to climb 2 steps).
+
+3. **Iterative Calculation**:
+   - Use a loop from `i = 2` to `n - 1`:
+     - For each step `i`, calculate the number of ways to reach it as the sum of the ways to reach the previous two steps:
+       
+
+\[
+       a[i] = a[i - 1] + a[i - 2]
+       \]
+
+
+   - This is based on the observation that to reach step `i`, you can either:
+     - Take one step from `i - 1` (contributing `a[i - 1]` ways).
+     - Take two steps from `i - 2` (contributing `a[i - 2]` ways).
+
+4. **Return Result**:
+   - Return `a[n - 1]`, which contains the total number of ways to climb `n` steps.
+
+---
+
+### Example Execution
+#### Input:
+```java
+int n = 5;
+
+Time Complexity: O(n)
+Space Complexity: O(n)
diff --git a/Problems/#70 - Climbing Stairs - Easy/Solution.java b/Problems/#70 - Climbing Stairs - Easy/Solution.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int climbStairs(int n) {
+        if(n==1) return 1;
+        
+        if(n==2) return 2;
+
+        int[] a =  new int[n];
+        a[0]=1;
+        a[1]=2;
+
+        for(int i=2;i<n;i++){
+            a[i]=a[i-1]+a[i-2];
+        }
+        return a[n-1];
+    }
+}
diff --git a/README.md b/README.md
@@ -30,6 +30,9 @@ Thank you for considering contributing to **LeetCode-Solutions**! This repositor
      ├── 2 Sum - Solution.py
      ├── 2 Sum - Explanation.md
      ```
+
+> Note: Make sure to use this [Explanation Template](https://github.com/Dijkstra-Edu/LeetCode-Solutions/blob/master/Explanation-Template.md) as reference while writing down your explanations!
+     
 5. **Commit your changes**: Use the following format for commit messages:
    ```sh
    git commit -m "Solution #num - Creator/Edited - Date - commit #num"
@@ -52,6 +55,8 @@ Thank you for considering contributing to **LeetCode-Solutions**! This repositor
 - **Discussions**: Use GitHub Issues for bug reports, feature requests, or discussions before implementing major changes.
 - **Documentation**: Ensure that the `Explanation.md` file is well-written and clearly explains the approach used in the solutions.
 
+> Note: Make sure to use this [Explanation Template](https://github.com/Dijkstra-Edu/LeetCode-Solutions/blob/master/Explanation-Template.md) as reference while writing down your explanations!
+
 ## 🚀 Issue Tracking
 
 - If you find an issue with an existing solution or have a suggestion, please [open an issue](https://github.com/Dijkstra-Edu/LeetCode-Solutions/issues).
