🧮 Java Solution: Generate String from T/F Constraints (LeetCode 3474)

Problem: Build smallest string where substrings must equal (T) or not equal (F) to str2.

🧠 Explanation:
Initialize all with 'a' (smallest letter)
T constraints: fix exact characters from str2, detect conflicts
F constraints: if substring already equals str2, modify rightmost unfixed position to 'b'
This ensures lexicographically smallest result

📊 Example: s="TFTF", t="ab"
T at 0: ans[0]='a', ans[1]='b'
T at 2: ans[2]='a', ans[3]='b'
F at 1: substring "ba" ≠ "ab" ✓
F at 3: substring "b?" → change ans[4] from 'a' to 'b'? Wait, must be ≠ "ab" → 'a' works? Actually "ba" ≠ "ab" already. Code uses rightmost unfixed position. Returns "ababa" ✅

⏱️ Complexity: O(n×m) time, O(n+m) space

🎯 Key Learning Points:
- Two-Phase Algorithm - Process T constraints first (mandatory), then F constraints.
- Conflict Detection - Check fixed positions against required characters.

#LeetCode #Hard

🧮 Java Solution: Robot Collision Simulation (LeetCode 2751)

Problem: Robots on a line move R or L. When two meet, higher health survives (health-1), equal health both die. Return surviving healths in original order.

🧠 Explanation:
Sort by position. Stack holds right-moving robots. When left-moving robot appears, collide with stack top: higher health survives (health-1), lower dies, equal both die.

📊 Example: positions=[3,5,2,6], healths=[10,10,15,12], dir="RLRL"
Sort by position: [2(R),3(R),5(L),6(L)]
2(R) push, 3(R) push
5(L) collides with 3(R): 10 vs 10 → both die, pop
6(L) collides with 2(R): 15 vs 10 → 2 dies, 6 health=14
Survivor: [14] ✅

⏱️ Complexity: O(n log n) time (sorting), O(n) space

🎯 Key Learning Points:
- Sort by Position - Process collisions in spatial order for correct simulation.
- Stack for Right-Moving Robots - Track potential collision targets for left-moving robots.

#LeetCode #Hard

🧮 Java Solution: Maximum Coins with Neutralizations (LeetCode 3418)

Problem: Robot moves right/down from (0,0) to (m-1,n-1). Negative cells are robbers (steal |value|). Can neutralize at most 2 robbers. Maximize total coins.

🧠 Explanation:
DFS with memoization: state = (i, j, k) where k = neutralizations left (0-2)
At each cell: either take value (negative reduces sum) or neutralize (skip negative if k>0)
Base case: last cell can be neutralized if k>0 (take 0 instead of negative)

📊 Example: coins=[[0,1,-1],[1,-2,3],[2,-3,4]]
Path: (0,0)=0, (0,1)=1, (1,1) neutralize -2 (k=1), (1,2)=3, (2,2)=4 → total 8 ✅

⏱️ Complexity: O(m×n×3) time & space

🎯 Key Learning Points:
- Top-Down DP - Use recursion with memoization for clean state management.
- State Definition - (i,j,k) where k tracks remaining neutralizations.
- Decision Branching - Try both taking and neutralizing negative cells.

#LeetCode #Medium

🧮 Java Solution: Maximum Walls Destroyed by Robots (LeetCode 3661)

Problem: Each robot fires one bullet left or right up to max distance. Bullets stop at robots. Maximize unique walls destroyed.

🧠 Explanation:
Sort robots by position, sort walls. DP state: (robot index, canShootRight flag)
For each robot: try shooting left (covers [pos-dist, pos]) or right (covers [pos+1, pos+dist])
Left shots blocked by previous robot's position+1; right shots blocked by next robot's shot range
Use binary search to count walls in range

📊 Example: robots=[10,2], dist=[5,1], walls=[5,2,7]
Sorted robots: [2(R1),10(R2)]
R1 shoots left: covers [1,2] → destroys wall 2
R2 shoots left: covers [5,10] → destroys walls 5,7
Total=3 ✅

⏱️ Complexity: O(n log n) time, O(n) space

🎯 Key Learning Points:
- Sorting - Process robots left-to-right after sorting by position.
- State DP - Track robot index and whether right shot allowed (blocked by next robot).

#LeetCode #Hard

🧮 Java Solution: Decode Slanted Transposition Cipher (LeetCode 2075)

Problem: Given encoded string and number of rows, recover original string placed in matrix along diagonals (top-left to bottom-right), then read row-wise.

🧠 Explanation:
Matrix has rows and cols = encodedText.length() / rows
Original text was placed along diagonals (i=0,j=0 → i=1,j=1 → ...)
To decode: read all diagonals starting from first row, each column j as starting point
Collect characters in diagonal order, then trim trailing spaces

📊 Example: encodedText="ch ie pr", rows=3, cols=4
Traverse: (0,0)=c, (0,1)=h, (0,2)=' ', (0,3)=' ', (1,0)=i, (1,1)=e, (2,0)=p, (2,1)=r → collect: "ch i e p r" → trim trailing spaces → "cipher" ✅

⏱️ Complexity: O(rows × cols) = O(encodedText.length()) time, O(n) space

🎯 Key Learning Points:
- Matrix Dimensions - Compute cols from length/rows.
- Diagonal Traversal - Start each diagonal at (0, j) and move down-right (x++, y++).

#LeetCode #Medium

🧮 Java Solution: Robot Return to Origin (LeetCode 657)

Problem: Determine if robot returns to (0,0) after sequence of U/D/R/L moves.

🧠 Explanation:
Track x (horizontal) and y (vertical) coordinates
R increases x, L decreases x; U increases y, D decreases y
After processing all moves, robot is at origin if both coordinates are zero

📊 Example: "UD" → y:0→1→0, x:0→0→0 → true ✅
"LL" → x:0→-1→-2, y:0→0→0 → false ✅

⏱️ Complexity: O(n) time, O(1) space

🎯 Key Learning Points:
- Coordinate System - Track position using (x,y) pairs.
- Switch Statement - Efficient character handling for four directions.
- Pair Annihilation - U cancels D, R cancels L regardless of order.

#LeetCode #Easy

🧮 Java Solution: Robot Simulation with Obstacles (LeetCode 874)

Problem: Simulate robot moving north/east/south/west, avoiding obstacles. Return max squared distance from origin.

🧠 Explanation:
Track (x,y) and direction (0-3). Store obstacles in HashSet for O(1) checks.
Commands: -1 turn right, -2 turn left, 1-9 move step-by-step.
After each step, update max squared distance. Stop movement when obstacle encountered.

📊 Example: commands=[4,-1,3], obstacles=[]
North 4→(0,4), turn right, east 3→(3,4), maxDist=25 ✅

⏱️ Complexity: O(commands × 9) time, O(obstacles) space

🎯 Key Learning Points:
- Direction Encoding - Map 0=N,1=E,2=S,3=W for modulo rotation.
- HashSet Lookup - Store obstacles as strings for O(1) collision detection.
- Step-by-Step Movement - Process one unit at a time to detect mid-path obstacles.

#LeetCode #Medium

🧮 Java Solution: Robot Walking Grid Perimeter (LeetCode 2069)

Problem: Robot moves along grid boundary, turning counterclockwise when hitting edge. Return position and direction after many steps.

🧠 Explanation:
Robot only moves on perimeter. One full cycle = 2×(w+h-2) steps.
Instead of simulating each step, accumulate total steps.
Position and direction derived from (totalSteps % perimeter) using 4 edge segments.
Special case: after full cycle, robot at (0,0) facing South.

📊 Example: width=6,height=3, perimeter=14
steps=4 → (4,0) East ✅
steps=6 → (5,1) North ✅

⏱️ Complexity: O(1) per call, O(1) space

🎯 Key Learning Points:
- Cycle Detection - Robot repeats path every perimeter steps.
- Modulo Optimization - Reduce millions of steps to single cycle.
- Edge Segmentation - Break perimeter into 4 linear segments.

#LeetCode #Medium

🧮 Java Solution: Array Multiplication with Step Queries (LeetCode 3653)

Problem: Apply queries [li, ri, ki, vi] to multiply nums[idx] by vi for idx = li, li+ki, li+2ki... ≤ ri. Return XOR of final array.

🧠 Explanation:
Loop through each query. For current query, iterate indices from li to ri with step ki.
Multiply each nums[idx] by vi modulo 1e9+7 using long to avoid overflow.
After all queries, XOR all elements for final answer.

📊 Example: nums=[2,3,1,5,4], queries=[[1,4,2,3],[0,2,1,2]]
Query1: idx=1→9, idx=3→15 → [2,9,1,15,4]
Query2: idx=0→4, idx=1→18, idx=2→2 → [4,18,2,15,4]
XOR: 4^18=22, 22^2=20, 20^15=27, 27^4=31 ✅

⏱️ Complexity: O(q × n) time worst case, O(1) space

🎯 Key Learning Points:
- Step Iteration - Traverse array with custom step ki instead of incrementing by 1.
- Modular Multiplication - Use modulo 1e9+7 with long casting to prevent overflow.
- Nested Loops - Process queries sequentially, updating array in place.

#LeetCode #Medium

🧮 C++ Solution: Range Multiplication Queries with Step k (LeetCode 3655)

Problem: Apply queries [li, ri, ki, vi] to multiply nums[idx] by vi for idx = li, li+ki, li+2ki... ≤ ri. Return XOR of final array.

🧠 Explanation: Split queries by k with threshold √n. Small k: difference array with modular inverses (store multiplier at l, inverse beyond r, propagate). Large k: process directly. Finally apply multipliers and XOR.

📊 Example: nums=[2,3,1,5,4], queries=[[1,4,2,3],[0,2,1,2]]
k=2 (small): diff[1]=3, diff[3]=inv(3) at r+? Actually r adjusted to last index in progression. Propagate to indices 1,3.
k=1 (small): diff[0]=2, diff[3]=inv(2), propagate to all indices.
Result: [4,18,2,15,4] XOR=31 ✅

⏱️ Complexity: O((n+q)·√n) time, O(n·√n) space

🎯 Key Learning Points:
- Square Root Decomposition - Balance between small and large step queries.
- Modular Inverse - Use Fermat's theorem when MOD is prime (1e9+7).

#LeetCode #Hard

🧮 Java Solution: Minimum Distance of Good Tuple (LeetCode 3740)

Problem: Find three equal numbers in array minimizing abs(i-j)+abs(j-k)+abs(k-i).

🧠 Explanation:
For i<j<k, distance = (j-i)+(k-j)+(k-i) = 2×(k-i). So only first and last index matter.
Group indices by value. For each value with ≥3 indices, check consecutive triples in sorted order. The smallest k-i gives minimal distance.

📊 Example: nums=[1,2,1,1,3]
Value 1 indices: [0,2,3]. Triple (0,2,3): 2×(3-0)=6 ✅

⏱️ Complexity: O(n) time, O(n) space

🎯 Key Learning Points:
- Distance Simplification - For three sorted points, sum of pairwise distances = 2×(last-first).
- Index Grouping - Use HashMap to collect positions of each value.
- Consecutive Triple Check - Only need to check consecutive indices (minimum spread).

#LeetCode #Easy

🧮 Java Solution: Minimum Distance of Good Tuple (LeetCode 3741)

Problem: Find three equal numbers in array minimizing abs(i-j)+abs(j-k)+abs(k-i).

🧠 Explanation:
For sorted indices i<j<k, distance = (j-i)+(k-j)+(k-i) = 2×(k-i). Only first and last index matter. Group indices by value. For each value with ≥3 indices, check consecutive triples (t, t+1, t+2). Their distance = 2×(indices[t+2] - indices[t]). This gives minimal spread with at least one index in between.

📊 Example: nums=[1,2,1,1,3]
Value 1 indices: [0,2,3]. Triple (0,2,3): 2×(3-0)=6 ✅

⏱️ Complexity: O(n) time, O(n) space

🎯 Key Learning Points:
- Distance Formula - For three sorted points, sum of pairwise distances = 2×(last-first).
- Index Grouping - Use HashMap to collect positions for each distinct value.
- Consecutive Triple Check - Only need indices[t], indices[t+1], indices[t+2] for minimal spread.

#LeetCode #Medium

🧮 Java Solution: Minimum Distance to Type Word with Two Fingers (LeetCode 1320)

Problem: Type a string using two fingers on a keyboard grid. Minimize total Manhattan distance between consecutive finger positions. Initial positions are free.

🧠 Explanation:
DP state: after typing i characters, positions of both fingers. First char typed by either finger (cost 0). For each new char, either move the finger that typed previous char, or move the other finger (if it was free). Use Manhattan distance on 6x5 keyboard grid.

📊 Example: "CAKE" → C(2,0), A(0,0), K(2,3), E(0,3). Optimal: C→A (2), K→E (1) total=3 ✅

⏱️ Complexity: O(n × 26²) time, O(n × 26²) space

🎯 Key Learning Points:
- 3D Dynamic Programming - State includes position of both fingers.
- Keyboard Coordinate Mapping - Convert letter to (x,y) using row = (char)/6, col = (char)%6.
- Two-Finger Typing - One finger types previous char, either finger can type next.

#LeetCode #Hard

🧮 Java Solution: Find Closest Index to Target (LeetCode 1848)

Problem: Find index i where nums[i] == target that minimizes |i - start|. Return that minimum distance.

🧠 Explanation:
Scan array from left to right. Whenever target found, compute distance from start using absolute difference. Track minimum distance seen. Return final minimum.

📊 Example: nums=[1,2,3,4,5], target=5, start=3
Only index 4 has target: |4-3|=1 ✅

⏱️ Complexity: O(n) time, O(1) space

🎯 Key Learning Points:
- Linear Search - Iterate through array to find matching elements.
- Absolute Difference - Use Math.abs() to measure distance regardless of direction.
- Minimum Tracking - Initialize with MAX_VALUE, update using Math.min().

#LeetCode #Easy

🧮 Java Solution: Minimum Total Distance Traveled (LeetCode 2463)

Problem: Assign robots to factories with limits to minimize sum of distances.

🧠 Explanation:
Sort robots and factories by position. DP state: (robot index i, factory index j) = min distance to assign robots from i onward using factories from j onward. For current factory, either skip it or assign its limit of consecutive robots (optimal assignment keeps order).

📊 Example: robots=[0,4,6], factories=[[2,2],[6,2]]
Assign robots 0,4 to factory 2 (dist=2+2=4), robot 6 to factory 6 (dist=0) total=4 ✅

⏱️ Complexity: O(r × f × limit) time, O(r × f) space

🎯 Key Learning Points:
- Sorting - Sort robots and factories by position for optimal assignment.
- DP State Definition - (robot index, factory index) = minimum cost to assign remaining robots.
- Skip Factory Option - Leave current factory unused.

#LeetCode #Hard

🧮 Java Solution: Shortest Distance in Circular Array (LeetCode 2515)

Problem: Find minimum steps from startIndex to any occurrence of target in circular array.

🧠 Explanation:
Scan array to find all indices where word equals target. For each index, compute direct distance |i-start| and circular distance n - direct (going the other way around). Take minimum of both. Track global minimum across all matching indices. Return -1 if target not found.

📊 Example: words=["hello","i","am","leetcode","hello"], target="hello", start=1
Indices 0 and 4: dist(0)=min(1,4)=1, dist(4)=min(3,2)=2 → min=1 ✅

⏱️ Complexity: O(n) time, O(1) space

🎯 Key Learning Points:
- Circular Distance - For indices i and j in array length n, min distance = min(|i-j|, n-|i-j|).
- String Comparison - Use .equals() for content comparison, not ==.

#LeetCode #Easy

🧮 Java Solution: Circular Array Nearest Same Value (LeetCode 3488)

Problem: For each query index, find minimum circular distance to another index with same value.

🧠 Explanation:
Group indices by value using HashMap. For each group with ≥2 indices, consider circular neighbors in the sorted list. For each index, compute circular distance to prev and next using min(|a-b|, n-|a-b|). Store minimum. Query answers are precomputed.

📊 Example: nums=[1,3,1,4,1,3,2], queries=[0,3,5]
Value 1 indices [0,2,4]: index0→min(dist to 2, dist to 4)=min(2,3)=2
Value 3 indices [1,5]: index5→dist to 1 = min(4,3)=3 → answer[0,3,5]=[2,-1,3] ✅

⏱️ Complexity: O(n) time, O(n) space

🎯 Key Learning Points:
- Index Grouping - Group indices by value for efficient processing.
- Circular Distance - Distance = min(|a-b|, n-|a-b|).
- Neighbor Check - Only need nearest neighbors in sorted circular list.

#LeetCode #Medium

🧮 Java Solution: Minimum Mirror Pair Distance (LeetCode 3761)

Problem: Find minimum distance between indices i<j where reverse(nums[i]) == nums[j].

🧠 Explanation:
Single pass with HashMap. For each index i, check if nums[i] was previously seen as a reversed value. If yes, update min distance. Then store current index mapped to reverse(nums[i]) for future matches. This finds pairs (j,i) where j < i and reverse(nums[j]) == nums[i].

📊 Example: nums=[12,21,45,33,54]
i=0: reverse(12)=21 → pos={21→0}
i=1: nums[1]=21 found in pos (key 21) → distance=1-0=1 ✅ ans=1, pos={21→0,12→1}
i=2: reverse(45)=54 → pos={...,54→2}
i=3: reverse(33)=33 → pos={...,33→3}
i=4: nums[4]=54 found in pos (key 54) → distance=4-2=2 → ans=1 ✅

⏱️ Complexity: O(n) time, O(n) space

🎯 Key Learning Points:
- Single Pass HashMap - Process array once, store needed values for future lookups.
- Reverse Digit Function - Handle leading zeros automatically with integer arithmetic.

#LeetCode #Medium

🧮 Java Solution: Mirror Distance of a Number (LeetCode 3783)

Problem: Calculate absolute difference between n and its digit-reversed version.

🧠 Explanation:
Extract digits from right to left using modulo and division. Build reversed number by multiplying current result by 10 and adding each digit. Leading zeros automatically disappear since integer conversion drops them. Return absolute difference.

📊 Example: n=25 → reverse=52 → |25-52|=27 ✅
n=10 → reverse=1 → |10-1|=9 ✅
n=7 → reverse=7 → |7-7|=0 ✅

⏱️ Complexity: O(log n) time, O(1) space

🎯 Key Learning Points:
- Digit Extraction - Use n%10 to get last digit, n/=10 to remove it.
- Number Reversal - Build new number by rev*10 + digit each iteration.
- Leading Zero Handling - Integers automatically ignore leading zeros (e.g., 10→1).

#LeetCode #Easy

🧮 Java Solution: Maximum Distance in Non-Increasing Arrays (LeetCode 1855)

Problem: Maximize j-i where i≤j and nums1[i] ≤ nums2[j] with both arrays non-increasing.

🧠 Explanation:
Binary search for each i to find rightmost j in nums2 where nums2[j] ≥ nums1[i]. Because nums2 is non-increasing, valid j form a suffix. Track maximum j-i. Time complexity O(n log m).

📊 Example: nums1=[55,30,5,4,2], nums2=[100,20,10,10,5]
i=2: nums1[2]=5, binary search finds j=4 (nums2[4]=5) → dist=2 ✅

⏱️ Complexity: O(n log m) time, O(1) space

🎯 Key Learning Points:
- Binary Search - Find rightmost index satisfying condition in monotonic array.
- Non-Increasing Property - Enables binary search for valid j suffix.
- Condition i≤j - Ensure left starts at i for valid indices.

#LeetCode #Medium