Minimum Operations to Make a Uni-Value Grid with Java

Day 111: DSU, Graphs, and Hamming Distances 🧠⚡ Problem 1722: Minimize Hamming Distance After Swap Operations Today was a massive step up. I moved beyond simple pointers and dove into Disjoint Set Union (DSU) to solve a complex graph-based problem. The Strategy: • The Swap Logic: Since allowedSwaps can be chained, any indices in the same connected component can be rearranged freely. • Disjoint Set Union: I used DSU to group these indices. If index A can swap with B, and B with C, then {A, B, C} form a component where any value can move to any position. • Frequency Tracking: For each connected component, I used a nested HashMap to track the available numbers from the source. • Calculating the Distance: For each position, I checked if the target value existed in its component's pool. If not, the Hamming distance increased. The Java vs. C++ Choice: I actually tried implementing this in C++ first, but the time complexity turned out to be higher than expected for this specific logic. To ensure the most efficient O(N⋅α(N)) performance and clear the tight test cases, I stuck with Java for today’s solve. Day 111 in the books. Sometimes choosing the right tool for the specific problem is the most important engineering decision you can make. 🚀 #LeetCode #Java #DSU #Graphs #Algorithms #ProblemSolving #DailyCode

💡 Day 64 of LeetCode Problem Solved! 🔧 🌟 2033. Minimum Operations to Make a Uni-Value Grid 🌟 🔗 Solution Code: https://lnkd.in/gts2KBqr 🧠 Approach: • Flattened the 2D grid into a sorted 1D list. • Chose the median as the target value — it minimises total absolute deviation mathematically. • Early-exit with -1 if any element has a different remainder mod x than the median. • Summed |element - median| / x for all elements to get the answer. ⚡ Key Learning: • The median is the optimal target for minimising sum of absolute differences — a powerful mathematical insight that replaces brute-force enumeration entirely. • A simple remainder check handles all impossible cases upfront. ⏱️ Complexity: • Time: O(m·n·log(m·n)) • Space: O(m·n) #LeetCode #Java #DSA #ProblemSolving #Consistency #CodingJourney #Algorithms #Grid

🚀 Day 63/100 Solved a problem on making a string "good" by removing adjacent characters with same letters but different cases (like aA or Bb). 💡 Key Learning: Used a stack-based approach to efficiently remove invalid pairs in one pass. This problem improved my understanding of: ✔️ Stack data structure ✔️ String manipulation ✔️ Greedy + pattern recognition. 💡 What I Learned: How to use a stack to simulate real-time deletion Importance of checking only adjacent elements (top of stack) Learned the ASCII trick (difference = 32) for case comparison Understood how greedy approach works with stack Improved ability to recognize patterns like "remove adjacent pairs" Writing clean and optimized string manipulation code Handling edge cases like empty string result Consistency is the key 🔥 #Day63 #DSA #Java #CodingJourney #LeetCode #ProblemSolving #100DaysOfCode

𝐃𝐚𝐲 𝟖𝟑 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on calculating the H-Index based on citations. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • H-Index 🔗 https://lnkd.in/dwrJWQaR 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 – 𝐁𝐮𝐜𝐤𝐞𝐭 𝐂𝐨𝐮𝐧𝐭𝐢𝐧𝐠 • Created a bucket array of size n + 1 • Counted how many papers have each citation count Handling: • If citations ≥ n → stored in last bucket • Else → stored in respective bucket • Traversed from highest to lowest • Accumulated count of papers • First index where count ≥ index → answer 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • Counting techniques can replace sorting • Constraints help optimize solutions • Bucket approach reduces time complexity • Understanding problem definition is key 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(n) • Space: O(n) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Optimization is about using the right data structure, not just writing faster code. 83 days consistent 🚀 On to Day 84. #DSA #Arrays #BucketSort #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

🧠 Day 215 — Mean of Range in Array 📊⚡ Today solved a clean problem using Prefix Sum, a must-know technique for range queries. 📌 Problem Goal Given an array and multiple queries: ✔️ Each query asks for the mean (average) of a subarray ✔️ Return the floor value of that mean 🔹 Core Idea Instead of calculating sum for every query (which is slow): 👉 Precompute prefix sum array ✔️ prefix[i] = sum of elements from 0 → i 🔹 Query Optimization For any range [l, r]: ✔️ Sum = prefix[r] − prefix[l−1] ✔️ Mean = sum / length This makes each query O(1) 🔹 Key Observation ✔️ Preprocessing once → fast multiple queries ✔️ Handles large constraints efficiently ✔️ Avoids repeated summation 🧠 Key Learning ✔️ Prefix Sum is essential for range query problems ✔️ Time complexity improves from O(n * q) → O(n + q) ✔️ Always think preprocessing when queries are multiple 💡 Big Realization Whenever you see: 👉 “Range sum / average queries” 👉 “Multiple queries on same array” Think: ➡️ Prefix Sum 🚀 Momentum Status: Strong grip on array optimization techniques. On to Day 216. #DSA #PrefixSum #Arrays #Optimization #LeetCode #Java #CodingJourney #ConsistencyWins

Day 106: The Pivot to Efficiency 📉 Problem 3488: Closest Equal Element Queries Today was a challenge. My first approach hit a wall with a TLE (Time Limit Exceeded), forcing me to step back, watch a tutorial, and refactor for a more optimal solution. The Strategy: • Grouping by Index: I used a HashMap to isolate all occurrences of the same number. • Circular Distance: For each index, I calculated the nearest "equal" neighbors as if the array were a loop. • O(1) Queries: By pre-calculating every result, the final queries became instant lookups. I’m not particularly proud of needing help today, but optimizing "almost-there" code is where the real learning happens. Day 106—we learn and we move. 🚀 #LeetCode #Java #ProblemSolving #DailyCode

Day 103: Simple & Clean 🎯 Problem 1848: Minimum Distance to the Target Element After some complex DP challenges, today was a straightforward exercise in linear search and distance calculation. The Strategy: • Linear Traversal: I iterated through the array to find every occurrence of the target element. • Absolute Minimization: For each match, I calculated the absolute difference between the current index and the start index, keeping track of the minimum value found. Sometimes a simple, O(N) solution is all you need. Day 103 down—maintaining the streak with clarity and consistency. 🚀 #LeetCode #Java #Algorithms #ProblemSolving #DailyCode

🧠 Day 206 — Minimum Distance to Target 🎯📍 Today solved a simple yet important problem and did some revision alongside. 📌 Problem Goal Given an array, a target value, and a starting index: ✔️ Find the minimum distance between the start index and any index where the target exists 🔹 Core Idea Traverse the array and: ✔️ Check if current element matches the target ✔️ Calculate distance from the start index ✔️ Keep updating the minimum distance 🔹 Key Observation ✔️ Only indices with the target matter ✔️ Distance = absolute difference between indices ✔️ Simple linear scan gives optimal solution 🧠 Key Learning ✔️ Even easy problems strengthen fundamentals ✔️ Brute-force with clarity > overthinking ✔️ Absolute difference patterns are very common in arrays 💡 Today’s Realization Not every day needs to be a hard problem. Consistency with simple + revision days builds stronger intuition. 🚀 Momentum Status: Staying consistent and sharpening basics. On to Day 207. #DSA #Arrays #ProblemSolving #LeetCode #Java #CodingJourney #ConsistencyWins

🚀 DAY 105/150 — NAVIGATING FILE SYSTEM LOGS! 📂🧭 Day 105 of my 150 Days DSA Challenge in Java and today I solved a problem based on stack simulation and directory navigation 💻🧠 📌 Problem Solved: Crawler Log Folder 📌 LeetCode: #1598 📌 Difficulty: Easy 🔹 Problem Insight The task is to determine the minimum number of operations needed to go back to the main folder after performing a series of folder operations. 👉 Operations include: • "../" → move to parent folder • "./" → stay in current folder • "x/" → move into a child folder 🔹 Approach Used I used a Stack-based simulation (or counter optimization): ✅ Stack Approach: • Push folder names when moving into a directory • Pop when encountering "../" • Ignore "./" ✅ Optimized Approach (Counter): • Maintain a variable depth • "x/" → depth++ • "../" → depth-- (only if > 0) • "./" → ignore ✔️ Final depth = minimum steps to return ⏱ Complexity Time Complexity: O(n) Space Complexity: • Stack → O(n) • Optimized → O(1) 🧠 What I Learned • Simulation problems can often be optimized using simple counters • Stack helps visualize hierarchy (like folders) • Edge case: cannot go above root directory 💡 Key Takeaway This problem taught me: How to simulate file system operations How to optimize stack-based solutions Importance of handling boundary conditions 🌱 Learning Insight Now I’m getting better at: 👉 Identifying when to use stack vs simple variables 👉 Writing clean and efficient logic 🚀 ✅ Day 105 completed 🚀 45 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/eadhHjNW 💡 Simplify the process, and the solution becomes obvious. #DSAChallenge #Java #LeetCode #Stack #Simulation #DataStructures #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

📘 DSA Journey — Day 35 Today’s focus: Binary Search with index patterns. Problem solved: • Single Element in a Sorted Array (LeetCode 540) Concepts used: • Binary Search • Index parity (even/odd pattern) • Search space reduction Key takeaway: The array is sorted and every element appears twice except one. A key observation: Before the single element, pairs start at even indices After the single element, this pattern breaks. Using binary search: • If mid is even and nums[mid] == nums[mid + 1], the single element lies on the right side • Else, it lies on the left side (including mid) By leveraging this pattern, we can find the answer in O(log n) time and O(1) space. Continuing to strengthen binary search intuition and consistency in problem solving. #DSA #Java #LeetCode #CodingJourney