Updated Notes, Fix Links and pages

Author: VR-Rathod

pages/Activity Selection Problem.md

@@ -39,7 +39,6 @@ displayTitle: Activity Selection Problem
 		- **Stability**: Not applicable.
 		- **Greedy Choice Property**: Selecting the activity with the earliest finish time never eliminates a globally optimal set.
 		- **Optimal Substructure**: After selecting activity $k$, the remaining problem is the same — find max activities compatible with $k$ from the remaining set.
-
 - # How It Works
   collapsed:: true
 	- ## The Core Idea
@@ -59,7 +58,7 @@ displayTitle: Activity Selection Problem
 		      F --> D
 		      G --> D
 		      D --> H["✅ Selected set = maximum non-overlapping activities"]
-
+		  
 		      classDef default fill:#1f2937,stroke:#3b82f6,stroke-width:2px,color:#fff;
 		  ```
 	-
@@ -68,10 +67,10 @@ displayTitle: Activity Selection Problem
 		- ```
 		  Activities (start, finish):
 		  A1=(1,4), A2=(3,5), A3=(0,6), A4=(5,7), A5=(3,9), A6=(5,9), A7=(6,10), A8=(8,11), A9=(8,12), A10=(2,14)
-
+		  
 		  After sorting by finish time:
 		  A1=(1,4), A2=(3,5), A3=(0,6), A4=(5,7), A5=(3,9), A6=(5,9), A7=(6,10), A8=(8,11), A9=(8,12), A10=(2,14)
-
+		  
 		  Step 1: Select A1 (finish=4). last_finish=4
 		  Step 2: A2 start=3 < 4 → skip
 		  Step 3: A3 start=0 < 4 → skip
@@ -82,10 +81,9 @@ displayTitle: Activity Selection Problem
 		  Step 8: A8 start=8 >= 7 → SELECT A8. last_finish=11
 		  Step 9: A9 start=8 < 11 → skip
 		  Step 10: A10 start=2 < 11 → skip
-
+		  
 		  Selected: {A1, A4, A8} → 3 activities ✅
 		  ```
-
 - # Complexity Analysis
   collapsed:: true
 	- | Scenario | Time Complexity | Space Complexity | Notes |
@@ -98,12 +96,11 @@ displayTitle: Activity Selection Problem
 	  collapsed:: true
 		- Sorting takes $O(N \log N)$. The greedy sweep is a single linear pass $O(N)$. Total = $O(N \log N)$.
 		- If activities are already sorted by finish time, the entire algorithm runs in $O(N)$.
-
 - # Implementation
   collapsed:: true
 	- > [!note] Activity Selection — Greedy (Unweighted) + Weighted DP Variant
 	  > The standard greedy returns the count and selected activities. The weighted variant uses DP + binary search to maximize total profit.
-	  - Languages: [[Python]] · [[Cpp]] · [[Java Script]] · [[Java]]
+		- Languages: [[Python]] · [[Cpp]] · [[Java Script]] · [[Java]]
 	-
 	- :::code-tabs
 	  
@@ -118,17 +115,17 @@ displayTitle: Activity Selection Problem
 	      sorted_acts = sorted(activities, key=lambda x: x[1])
 	      selected = [sorted_acts[0]]
 	      last_finish = sorted_acts[0][1]
-
+	  
 	      for start, finish in sorted_acts[1:]:
 	          if start >= last_finish:
 	              selected.append((start, finish))
 	              last_finish = finish
-
+	  
 	      return selected
-
+	  
 	  # Weighted Job Scheduling — O(N log N) DP
 	  from bisect import bisect_right
-
+	  
 	  def weighted_job_scheduling(jobs: list[tuple[int, int, int]]) -> int:
 	      """
 	      jobs: list of (start, finish, profit).
@@ -138,22 +135,22 @@ displayTitle: Activity Selection Problem
 	      n = len(jobs)
 	      finish_times = [j[1] for j in jobs]
 	      dp = [0] * (n + 1)
-
+	  
 	      for i in range(1, n + 1):
 	          start, finish, profit = jobs[i - 1]
 	          # Find last job that doesn't conflict (finish <= start of current)
 	          j = bisect_right(finish_times, start, 0, i - 1)
 	          # Either include job i (profit + dp[j]) or exclude it (dp[i-1])
 	          dp[i] = max(dp[i - 1], profit + dp[j])
-
+	  
 	      return dp[n]
-
+	  
 	  # Examples
 	  activities = [(1,4),(3,5),(0,6),(5,7),(3,9),(5,9),(6,10),(8,11),(8,12),(2,14)]
 	  selected = activity_selection(activities)
 	  print(f"Selected: {selected}")       # [(1,4), (5,7), (8,11)]
 	  print(f"Count: {len(selected)}")     # 3
-
+	  
 	  jobs = [(1, 4, 20), (3, 5, 30), (0, 6, 15), (5, 7, 40)]
 	  print(f"Max Profit: {weighted_job_scheduling(jobs)}")  # 60 (job1 + job4)
 	  ```
@@ -162,16 +159,16 @@ displayTitle: Activity Selection Problem
 	  #include <iostream>
 	  #include <vector>
 	  #include <algorithm>
-
+	  
 	  using Activity = std::pair<int, int>; // (start, finish)
-
+	  
 	  std::vector<Activity> activitySelection(std::vector<Activity> activities) {
 	      std::sort(activities.begin(), activities.end(),
 	                [](const Activity& a, const Activity& b) { return a.second < b.second; });
-
+	  
 	      std::vector<Activity> selected = {activities[0]};
 	      int lastFinish = activities[0].second;
-
+	  
 	      for (size_t i = 1; i < activities.size(); ++i) {
 	          if (activities[i].first >= lastFinish) {
 	              selected.push_back(activities[i]);
@@ -180,7 +177,7 @@ displayTitle: Activity Selection Problem
 	      }
 	      return selected;
 	  }
-
+	  
 	  int main() {
 	      std::vector<Activity> acts = {{1,4},{3,5},{0,6},{5,7},{3,9},{5,9},{6,10},{8,11}};
 	      auto result = activitySelection(acts);
@@ -197,7 +194,7 @@ displayTitle: Activity Selection Problem
 	      activities.sort((a, b) => a.finish - b.finish);
 	      const selected = [activities[0]];
 	      let lastFinish = activities[0].finish;
-
+	  
 	      for (let i = 1; i < activities.length; i++) {
 	          if (activities[i].start >= lastFinish) {
 	              selected.push(activities[i]);
@@ -206,7 +203,7 @@ displayTitle: Activity Selection Problem
 	      }
 	      return selected;
 	  }
-
+	  
 	  const acts = [
 	      {start:1,finish:4},{start:3,finish:5},{start:0,finish:6},
 	      {start:5,finish:7},{start:8,finish:11}
@@ -218,15 +215,15 @@ displayTitle: Activity Selection Problem
 	  
 	  ```java
 	  import java.util.*;
-
+	  
 	  public class ActivitySelection {
 	      public static List<int[]> select(int[][] activities) {
 	          // activities[i] = {start, finish}
 	          Arrays.sort(activities, (a, b) -> a[1] - b[1]);
 	          List<int[]> selected = new ArrayList<>();
 	          selected.add(activities[0]);
 	          int lastFinish = activities[0][1];
-
+	  
 	          for (int i = 1; i < activities.length; i++) {
 	              if (activities[i][0] >= lastFinish) {
 	                  selected.add(activities[i]);
@@ -235,7 +232,7 @@ displayTitle: Activity Selection Problem
 	          }
 	          return selected;
 	      }
-
+	  
 	      public static void main(String[] args) {
 	          int[][] acts = {{1,4},{3,5},{0,6},{5,7},{3,9},{8,11}};
 	          List<int[]> result = select(acts);
@@ -247,7 +244,6 @@ displayTitle: Activity Selection Problem
 	  ```
 	  
 	  :::
-
 - # Alternative Variant (Interval Coloring — Minimum Machines)
   collapsed:: true
 	- > [!tip] Interval Coloring — Find Minimum Number of Machines Needed
@@ -257,7 +253,7 @@ displayTitle: Activity Selection Problem
 	  
 	  ```python
 	  import heapq
-
+	  
 	  def min_machines(activities: list[tuple[int, int]]) -> int:
 	      """
 	      Minimum machines to run all activities without conflicts.
@@ -267,22 +263,21 @@ displayTitle: Activity Selection Problem
 	          return 0
 	      activities.sort(key=lambda x: x[0])  # sort by start time
 	      heap = []  # min-heap of finish times (machines in use)
-
+	  
 	      for start, finish in activities:
 	          if heap and heap[0] <= start:
 	              heapq.heapreplace(heap, finish)  # reuse freed machine
 	          else:
 	              heapq.heappush(heap, finish)     # add new machine
-
+	  
 	      return len(heap)
-
+	  
 	  # Example
 	  activities = [(0,6),(1,4),(3,5),(5,7),(3,9),(5,9),(6,10),(8,11)]
 	  print(f"Min machines: {min_machines(activities)}")  # 3
 	  ```
 	  
 	  :::
-
 - # When to Use Activity Selection
   collapsed:: true
 	- ```mermaid
@@ -294,7 +289,7 @@ displayTitle: Activity Selection Problem
 	      S1 -- No --> S2{"Do activities have\ndifferent profits/weights?"}
 	      S2 -- Yes --> R3["✅ Weighted Job Scheduling\nDP + Binary Search, O(N log N)"]
 	      S2 -- No --> R4["✅ Greedy: earliest finish first"]
-
+	  
 	      classDef default fill:#1f2937,stroke:#3b82f6,stroke-width:2px,color:#fff;
 	  ```
 	-
@@ -307,7 +302,6 @@ displayTitle: Activity Selection Problem
 	- ## ❌ Avoid Simple Greedy When
 		- Activities have **different profits/weights** — switch to Weighted Job Scheduling DP.
 		- The constraint is not just non-overlap but involves **dependencies** between activities.
-
 - # Key Takeaways
   collapsed:: true
 	- **Earliest Finish First** — The greedy choice is always picking the activity with the earliest finish time, maximizing remaining time for future activities.
@@ -316,11 +310,10 @@ displayTitle: Activity Selection Problem
 	- **Weighted Variant Needs DP** — When activities have different profits, greedy fails. Use DP + binary search ([[Dynamic Programming Concepts]]) for the weighted version.
 	- **Interval Coloring Dual** — The minimum number of machines = the maximum overlap depth at any point (use min-heap of finish times).
 	- **LeetCode Applications** — "Non-overlapping Intervals" (#435), "Meeting Rooms II" (#253), "Minimum Number of Arrows to Burst Balloons" (#452).
-
 - # More Learn
   collapsed:: true
 	- ## GitHub & Webs
 		- [GeeksforGeeks → Activity Selection Problem](https://www.geeksforgeeks.org/activity-selection-problem-greedy-algo-1/)
 		- [CP Algorithms → Scheduling](https://cp-algorithms.com/greedy/job_scheduling.html)
 		- [LeetCode → Non-overlapping Intervals (Problem 435)](https://leetcode.com/problems/non-overlapping-intervals/)
-		- [LeetCode → Meeting Rooms II (Problem 253)](https://leetcode.com/problems/meeting-rooms-ii/)
+		- [LeetCode → Meeting Rooms II (Problem 253)](https://leetcode.com/problems/meeting-rooms-ii/)

pages/Boyer More Majority Vote.md

@@ -13,9 +13,9 @@ displayTitle: Boyer More Majority Vote
 	- ## Real-World Analogy
 	  collapsed:: true
 		- Imagine an election 🗳️ where voters shout their candidate. The rule is:
-		  - Every time two different candidates "clash", one vote from each is cancelled.
-		  - At the end, whoever is left standing is the **majority candidate**.
-		  - This works only if a true majority (> N/2 votes) exists — otherwise the survivor needs a second verification pass.
+			- Every time two different candidates "clash", one vote from each is cancelled.
+			- At the end, whoever is left standing is the **majority candidate**.
+			- This works only if a true majority (> N/2 votes) exists — otherwise the survivor needs a second verification pass.
 	-
 	- ## The Algorithm (2 passes)
 	  collapsed:: true
@@ -55,7 +55,6 @@ displayTitle: Boyer More Majority Vote
 		  |---|---|
 		  | **Time** | O(N) — two passes at most |
 		  | **Space** | O(1) — two variables: candidate + count |
-
 - # Implementation
   collapsed:: true
 	- > [!note] Standard majority (>N/2) + extended variant for elements appearing >N/3 times (returns up to 2 candidates).
@@ -277,15 +276,13 @@ displayTitle: Boyer More Majority Vote
 	  ```
 	  
 	  :::
-
 - # Key Takeaways
   collapsed:: true
 	- Two passes: **Pass 1** finds the candidate (cancel pairs of different elements). **Pass 2** verifies it appears > N/2 times.
 	- **O(1) space** — only 2 variables (candidate + count) vs O(N) for a hash map.
 	- Pass 2 is mandatory — without it, `[1, 2, 3]` would wrongly return 3.
 	- **N/3 variant** maintains 2 candidates and 2 counts for elements appearing > N/3 times (at most 2 such elements can exist).
 	- Related: [[Quick Select Algorithm]], [[Kadane's Algorithm]]
-
 - # More Learn
   collapsed:: true
 	- ## LeetCode Problems

pages/Constructor.md

@@ -30,7 +30,6 @@ displayTitle: Constructor
 		  ```
 		-
 		- > [!important] In Python, `__new__()` allocates memory and `__init__()` initializes it. You almost always only define `__init__`. In C++, the constructor does both.
-
 - # Types of Constructors
   collapsed:: true
 	- | Type | Description | Example |
@@ -49,10 +48,10 @@ displayTitle: Constructor
 	      CT --> COP["Copy\n(from existing object)"]
 	      CT --> DEL["Delegating / Chaining\n(calls another constructor)"]
 	  ```
-
 - # Constructor Chaining
   collapsed:: true
 	- One constructor can call another constructor of the same class to avoid code duplication:
+	- :::code-tabs
 	- ```python
 	  # Python — via __init__ default arguments
 	  class Connection:
@@ -87,7 +86,7 @@ displayTitle: Constructor
 	      }
 	  }
 	  ```
-
+	  :::
 - # Implementation
   collapsed:: true
 	- > [!note] A `DatabaseConnection` class demonstrating all constructor types, chaining, validation, and C++ initializer list.
@@ -368,15 +367,13 @@ displayTitle: Constructor
 	  ```
 	  
 	  :::
-
 - # Key Takeaways
   collapsed:: true
 	- A constructor **runs automatically** at object creation — you never call it explicitly.
 	- Always **validate inputs** in the constructor to guarantee a valid initial state.
 	- Use **constructor chaining** (`this(...)` in Java, `super(...)` in child classes, default args in Python) to avoid duplication.
 	- **C++ initializer lists** (`: field_(value)`) initialize members before the constructor body runs — more efficient than assignment inside the body.
 	- **Factory class methods** (`@classmethod` in Python, `static` in Java/C#) are alternative constructors with semantic names (`from_url()`, `local()`).
-
 - # More Learn
   collapsed:: true
 	- ## GitHub & Webs

pages/DSA Algo & System Design.md

@@ -171,7 +171,7 @@ keywords: "DSA, data structures, algorithms, system design, technical interview,
 		- 10) [[Topological Sort Algorithm]] - used to order the vertices of a **directed acyclic graph**
 		- 11) [[Flood Fill Algorithm]] - used to determine the area connected to a given node
 		- 12) [[Lee Algorithm]] - BFS based algorithm used to find the shortest path
-		- 13) [[Eukerian Path (Hierholzer's Algorithm)]] - path that visits every edge exactly once.
+		- 13) [[Eukerian Path Hierholzers Algorithm]] - path that visits every edge exactly once.
 	-
 	- ## Arrays & Two Pointers:
 	  collapsed:: true
@@ -201,7 +201,7 @@ keywords: "DSA, data structures, algorithms, system design, technical interview,
 			- **Time:** O((N + Q) × √N) · **Space:** O(√N) for block bookkeeping
 			- **Key Insight:** Sort queries by (block of L, then R for even blocks / R descending for odd blocks). This minimizes total pointer movement across all queries to O((N + Q)√N).
 			- **Use cases:** Range sum/product queries, count distinct elements in range, offline interval problems.
-		- 6) [[Distinct elements in subarray using Mo's Algorithm]]
+		- 6) [[Distinct elements in subarray using Mos Algorithm]]
 			- **Purpose:** Count **distinct elements** across many arbitrary subarrays efficiently using MO's ordering.
 			- **Time:** O((N + Q) × √N) · **Space:** O(N) for frequency map
 			- **Key Insight:** Extend/shrink the window by one element at a time, updating a frequency table. Increment the distinct count only when a new frequency goes from 0 → 1, decrement when it goes 1 → 0.

…ents in subarray using Mo's Algorithm.md …ments in subarray using Mos Algorithm.mdpages/Distinct elements in subarray using Mo's Algorithm.md renamed to pages/Distinct elements in subarray using Mos Algorithm.md pages/Distinct elements in subarray using Mo's Algorithm.md renamed to pages/Distinct elements in subarray using Mos Algorithm.md

@@ -3,6 +3,7 @@ seoTitle: Count Distinct Elements in Subarray – MO's Algorithm Variant | In-De
 description: "Complete guide to counting distinct elements in subarrays using MO's Algorithm. Covers frequency map add/remove, offline query processing, O((N+Q)√N) complexity, and implementations in Python, C++, Java, JavaScript, and C#."
 keywords: "distinct elements subarray, Mo's algorithm, count distinct, offline queries, frequency map, square root decomposition, range query, VR-Rathod, Code-Note, code note vr"
 displayTitle: Distinct elements in subarray using Mo's Algorithm
+title: Distinct elements in subarray using Mos Algorithm
 ---
 
 > [!info] What is this problem?
@@ -54,7 +55,6 @@ displayTitle: Distinct elements in subarray using Mo's Algorithm
 		  | **Time** | O((N + Q) × √N) |
 		  | **Space** | O(N) for frequency map + O(Q) for answers |
 		  | **Constraint** | Offline — all queries known upfront |
-
 - # Implementation
   collapsed:: true
 	- > [!note] Full MO's-based distinct count: frequency map, Mo ordering, pointer management, and result retrieval.
@@ -107,7 +107,7 @@ displayTitle: Distinct elements in subarray using Mo's Algorithm
 	          # Expand right
 	          while right < q.r: right += 1; add(right)
 	          # Expand left
-		      while left  > q.l: left  -= 1; add(left)
+	       while left  > q.l: left  -= 1; add(left)
 	          # Shrink right
 	          while right > q.r: remove(right); right -= 1
 	          # Shrink left
@@ -312,17 +312,15 @@ displayTitle: Distinct elements in subarray using Mo's Algorithm
 	  ```
 	  
 	  :::
-
 - # Key Takeaways
   collapsed:: true
 	- The core add/remove pattern: `freq[x]++; if freq[x]==1: distinct++` / `freq[x]--; if freq[x]==0: distinct--`.
 	- This O(1) add/remove makes MO's work for this problem — total cost = number of pointer moves = O((N+Q)√N).
 	- **Verification trick:** After computing, cross-check `len(set(arr[l:r+1]))` to verify answers.
 	- This is a direct application of [[MOs Algorithm (Query square root decomposition)]] specialised to the distinct-count aggregate.
 	- Related: [[MOs Algorithm (Query square root decomposition)]], [[Prefix Sum Array]], [[Sliding Window Technique]]
-
 - # More Learn
   collapsed:: true
 	- ## Resources
 		- [GeeksForGeeks — MO's Algorithm for Distinct Count](https://www.geeksforgeeks.org/mos-algorithm-query-square-root-decomposition-set-1-introduction/)
-		- [CP-Algorithms — MO's Algorithm](https://cp-algorithms.com/data_structures/sqrt_decomposition.html)
+		- [CP-Algorithms — MO's Algorithm](https://cp-algorithms.com/data_structures/sqrt_decomposition.html)