LeetCode Daily Challenge: Minimum Swaps to Make Grid Upper Triangular

🚀 Day 58 of #100DaysOfCode Today, I solved LeetCode 2840 – Check if Strings Can be Made Equal With Operations II, a problem that builds upon string manipulation and constraint-based transformations. 💡 Problem Overview: Given two strings, the objective is to determine whether they can be made equal using a defined set of swap operations. The challenge lies in understanding which positions can influence each other. 🧠 Approach: To efficiently solve this problem, I focused on: ✔️ Identifying independent index groups based on allowed operations ✔️ Separating characters into even and odd indexed groups ✔️ Comparing sorted/grouped characters from both strings This ensures correctness while maintaining optimal performance. ⚡ Key Takeaways: Identifying independent groups simplifies complex transformations Sorting/grouping techniques are effective for comparison problems Understanding constraints leads directly to optimal solutions 📊 Complexity Analysis: Time Complexity: O(n log n) Space Complexity: O(n) Small improvements every day lead to significant growth over time 🚀 #LeetCode #100DaysOfCode #DSA #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g-twtNFT 💡 My thought process: In the first pass (reverse order: bottom-right to top-left), we keep a running suffix product that shows the product of all elements after the current cell in row-major order. We store this value in the result matrix p[i][j] before updating the suffix with the current grid value. In the second pass (forward order: top-left to bottom-right), we maintain a running prefix product that represents the product of all elements before the current cell. For each cell, we compute the final result by multiplying the prefix (product before) with the already stored suffix (product after), and then we update the prefix with the current grid value. This method makes sure that for every cell, we calculate the product of all other elements in O(n × m) time with O(1) extra space aside from the output matrix. It also correctly handles large values using modular arithmetic. 👉 My Solution: https://lnkd.in/g2Q_GgpZ If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gbtaBXYW 💡 My thought process: The algorithm first calculates a normalized shift value using k % n. Shifting a row by its total length, n, returns the original configuration. Therefore, any shift k is the same as k modulo n. Instead of rotating memory physically or creating a temporary matrix, the code uses a virtual mapping strategy. It goes through each cell (i, j) and finds the index of the element that would be in that position after the shift. For even rows (left shift), to find the original value that moves into position j after a left shift, the code looks at the index (j - shift). It manages negative results by wrapping around with an addition of n. For odd rows (right shift), it checks the index (j + shift) % n. The function has a fail-fast mechanism; it returns false right away if it finds the first difference between a cell and its shifted counterpart. 👉 My Solution: https://lnkd.in/g5myRYRj If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gK993p-S 💡 My thought process: The main function, minAbsDiff, goes through all possible top-left positions of the k × k submatrices. For each position (i, j), it calls the helper function solve to find the result for that submatrix and stores it in the answer matrix, which has a size of (m − k + 1) × (n − k + 1). The solve function collects all elements from the k × k submatrix starting at (i, j) and puts them into a set. This automatically sorts the elements and removes duplicates. If the set has only one unique element, the function returns 0 because all values are the same. If there are multiple unique elements, the function goes through the sorted set and calculates the absolute difference between each pair of consecutive elements. Since the set is sorted, the minimum absolute difference will be between adjacent elements. The smallest difference is tracked and returned. The overall time complexity is O((m − k + 1) × (n − k + 1) × k² log(k²)) because each submatrix requires inserting k² elements into a set and iterating through it. The space complexity is O(k²) for storing elements of each submatrix. 👉 My Solution: https://lnkd.in/gj6juuUU If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gVAhMkFs 💡 My thought process: The approach involves turning the matrix into heights of consecutive 1s for each column. For each cell, if the value is non-zero and not in the first row, it adds the number of consecutive 1s above it by taking the value from the previous row. This changes each row into a histogram that shows the heights of consecutive 1s ending at that row. For each row, these heights are copied into a separate array and sorted in descending order. Sorting rearranges the heights, putting the taller ones first. This helps maximize the width-height combination for creating a submatrix. After sorting, the algorithm goes through the heights array. For each position j, it looks at forming a submatrix using the first j+1 columns, where the height is limited by the current value. The area is calculated as height × width, where height is ones[j] and width is j+1. The algorithm keeps track of the maximum area found across all rows. If it encounters a zero in the sorted heights, the loop stops. No larger area can be formed beyond that point. Finally, the maximum area calculated is returned as the result. 👉 My Solution: https://lnkd.in/gCKTTfAA If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gx6PQVMB 💡 My thought process: The brute force method checks all possible rotations of the binary string by moving the first character to the end repeatedly. For each rotated string, it counts the number of mismatches needed to create an alternating pattern that starts with 1. The opposite alternating pattern, which starts with 0, would require different changes. The method takes the minimum of the two counts for each rotation and returns the lowest value overall. The optimized method does not generate all rotations. Instead, it doubles the string and uses a sliding window of size n to represent every possible rotation. It keeps track of the mismatch count for forming an alternating pattern that starts with 1. As the window slides, it updates this count by subtracting the contribution of the character that leaves the window and adding the incoming character. At each step, it compares both alternating patterns to find the minimum number of flips needed. 👉 My Solution: https://lnkd.in/gP2FWVYP If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 Day 24/50 – LeetCode Challenge 🧩 Problem #11 – Container With Most Water Today’s problem focused on maximizing the amount of water that can be stored between two lines — a great example of the Two Pointer technique. 📌 Problem Summary: Given an array of heights, find two lines such that together with the x-axis they form a container that holds the maximum amount of water. 🔍 Approach Used ✔ Used two pointers — one at the beginning and one at the end ✔ Calculated area using: height = min(left, right) width = distance between pointers ✔ Moved the pointer with the smaller height to try for a better area ✔ Continued until both pointers met ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💡 Key Learning ✔ Understanding the two pointer optimization technique ✔ Why moving the smaller height gives better chances of improvement ✔ Efficiently reducing time complexity from O(n²) to O(n) This problem shows how a simple idea can lead to an optimal solution with the right approach. Consistency builds strong problem-solving skills 🚀 🔗 Problem Link: https://lnkd.in/gpNGfaxa #50DaysOfLeetCode #LeetCode #DSA #TwoPointers #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g5TWhSTr 💡 My thought process: The idea is to build the binary array recursively while tracking the remaining number of `0`s and `1`s, the last placed element, and the current streak of that element. A state `dp[zero][one][last][cons]` shows how many valid ways there are to form the remaining array when `zero` zeros and `one` ones are left, the previous element was `last`, and it has appeared `cons` times in a row. From each state, the recursion tries to add either `0` or `1`. A `0` can be added if there are remaining zeros and either the last element was different or the consecutive count has not gone over the set `limit`. The same applies when adding `1`. If both counts reach zero, a valid stable array is formed. Memoization saves the result of each state in the `dp` table to prevent recomputing overlapping subproblems. The final result is found by starting the recursion with either `0` or `1` as the first element (if available) and adding up the valid configurations. All computations are done modulo (10^9 + 7) to manage large counts effectively. 👉 My Solution: https://lnkd.in/g8Tr9MEc If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

LeetCode POTD | Day 15 Check if Strings Can Be Made Equal With Operations This one felt overwhelming at first. My first instinct? Try to calculate possibilities for every index. Yeah… that got messy pretty fast. Then came the realization: You don’t need to check every possible swap. You just need to observe the pattern. What worked: • Split characters based on even and odd indices • Count frequency separately • Compare if both strings can match through rearrangement What I learned today: Brute forcing every possibility feels safe… but stepping back and spotting the pattern is what actually simplifies the problem. That moment when things “click” >> everything else. Pattern Log #6: When swaps are allowed under constraints → Think in terms of grouping + frequency Day 15 of solving LeetCode POTD consistently. Some days are confusing at the start… but those are the ones that end up teaching the most. If you solved this, did you also go brute force first or spot the pattern early? (For me, I needed the second hint to get there 😄) #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #POTD

Day 52 on LeetCode — Minimum Recolors to Get K Consecutive Black Blocks 🧩✅ Today’s problem was another clean application of the Sliding Window technique with optimization. 🔹 Approach Used in My Solution The goal was to find the minimum number of recolors (W → B) needed to get k consecutive black blocks. Key idea in the solution: • Treat it as finding a window of size k with minimum 'W' (white blocks) • Count the number of 'W' in the first window of size k • Slide the window across the string:   – Remove the left character (if it was 'W')   – Add the new right character (if it is 'W') • Keep track of the minimum changes required This avoids recomputation and ensures an efficient linear solution. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Strengthened understanding of fixed-size sliding window problems • Learned how to convert problems into min/max count in a window • Reinforced optimizing from brute force to O(n) solutions #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Strings #TwoPointers #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney