MinAbsDiff LeetCode Challenge Solution

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g9SGp2Qa 💡 My thought process: First, create a mapping from each value to a sorted list of its indices using a map<int, vector<int>>. This allows for easy lookup of all positions where a value occurs. For each query index idx, it retrieves the corresponding value num. If that value appears only once, the result is -1 because no valid pair exists. In case of multiple occurrences, we use binary search on the index list of num: * upper_bound finds the next occurrence that is strictly greater than idx. * lower_bound locates the current position and checks the previous occurrence. It calculates distances in both directions: * Forward distance: either direct (next - idx) or circular wrap (n - (idx - first)). * Backward distance: either direct (idx - prev) or circular wrap (n - (last - idx)). The minimum of these distances is stored as the answer. 👉 My Solution: https://lnkd.in/gjmKVa3y 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/gVK8xX3p 💡 My thought process: The solution uses a top-down dynamic programming approach with memoization. Each cell stores a pair of values: the maximum product and the minimum product achievable from that cell to the destination. The minimum value is necessary because multiplying two negative numbers can lead to a larger positive result later. The recursive function explores both possible moves—right and down—from the current cell and retrieves their stored results. For each direction, it considers both the maximum and minimum products returned and multiplies them by the current cell’s value. All combinations are evaluated, and the overall maximum and minimum are selected and stored in the DP table for that cell. Memoization ensures that each cell is computed only once, reducing the time complexity to O(m × n). The base case occurs at the bottom-right cell, where both maximum and minimum values equal the cell’s value. Invalid positions return sentinel values to indicate they should not be considered. Finally, the function checks the result from the starting cell. If the maximum product is negative, it returns -1. Otherwise, it returns the result modulo 1e9 + 7. 👉 My Solution: https://lnkd.in/gcKfTVNq 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/eC4nGYRx 💡 My thought process: The code checks if two strings can be made equal by swapping characters only between indices that have the same parity. This means characters at even indices can only move among even positions, while those at odd indices can only move among odd positions. To manage this, the code first goes through the first string and records the frequency of characters separately for even and odd indices using two unordered maps. This captures how many times each character appears in each parity group. Next, it goes through the second string. For each character, it checks if it exists in the corresponding parity map. If the current index is even, it checks the even map; if odd, it checks the odd map. When it finds a match, it decreases the frequency and removes the entry from the map if it reaches zero. If a character isn’t found in the required parity map, the function returns false right away. This approach is necessary because checking overall character frequency isn’t enough due to the swapping restrictions. Since characters can’t move between even and odd indices, both parity groups must have identical frequency distributions in both strings. Using separate maps ensures that this rule is enforced. If all characters from the second string match with the corresponding parity groups from the first string, the function returns true, confirming that the transformation is possible. 👉 My Solution: https://lnkd.in/erhV7_HJ 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/gSiw_GQq 💡 My thought process: It uses a two-pointer approach. One pointer starts at the top row of the submatrix, and the other starts at the bottom row. For each pair of rows, it goes through all columns within the submatrix range and swaps the elements column by column. This process continues until the top and bottom pointers meet or cross. This ensures the submatrix is reversed in place without using any extra space. The updated grid is then returned. 👉 My Solution: https://lnkd.in/g_cAfrtb 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/giAcdv2U 💡 My thought process: This solution uses 3D dynamic programming to find the maximum coins that can be collected from the top-left to the bottom-right of a grid, allowing up to 2 neutralizations for negative cells. The state dp[i][j][k] stores the maximum coins reachable at cell (i, j) using k neutralizations. For each cell, transitions are taken from the left and top cells. If the current cell is negative, two options are considered: either neutralize it (if k > 0) and carry forward the previous value without adding the negative, or do not neutralize and add the cell value. For non-negative cells, the value is simply added to the best of the previous states. The starting cell is initialized separately based on whether it is neutralized or not. The final answer is the maximum value among dp[m-1][n-1][0], dp[m-1][n-1][1], and dp[m-1][n-1][2]. 👉 My Solution: https://lnkd.in/gZWS3Kns 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/gfx2E6jb 💡 My thought process: The rotate90 function rotates the matrix 90 degrees clockwise in place. It starts by transposing the matrix, swapping elements across the diagonal. This changes rows into columns. After that, it reverses each row to achieve the final rotated version. The check function compares two matrices element by element. It goes through all the positions and returns false immediately if it finds any mismatch. If all elements match, it returns true, showing that both matrices are the same. The findRotation function tests all possible rotations of the matrix: 0, 90, 180, and 270 degrees. For each rotation, it checks if the current matrix matches the target matrix. If a match is found at any point, it returns true. If not, it rotates the matrix by 90 degrees and continues. If no rotation matches, it returns false. Overall, the method is efficient. Each rotation and comparison takes quadratic time based on the size of the matrix, and it only performs a constant number of rotations. 👉 My Solution: https://lnkd.in/gcj4S5iQ 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 27/50 – LeetCode Challenge 🧩 Problem: Count and Say Today’s problem focused on generating a sequence based on reading and describing the previous term, which is a great exercise in string manipulation and pattern building. 📌 Problem Summary: The “Count and Say” sequence is defined as: Start with "1" Each next term is formed by reading the previous term aloud Example: 1 → "one 1" → 11 11 → "two 1s" → 21 21 → "one 2, one 1" → 1211 1211 → "one 1, one 2, two 1s" → 111221 🔍 Approach Used ✔ Started from the base case "1" ✔ Iterated to build each next term ✔ Counted consecutive digits ✔ Formed the new string using: count + digit ✔ Repeated until reaching the required n ⏱ Time Complexity: O(n × m) 📦 Space Complexity: O(m) 💡 Key Learning ✔ Understanding pattern generation problems ✔ Working with string grouping and counting ✔ Building results step by step ✔ Improving attention to detail in iteration This problem shows how simple rules can create complex patterns. Consistency is the key to mastery 🚀 🔗 Problem Link: https://lnkd.in/g_cMVP5a #50DaysOfLeetCode #LeetCode #DSA #Strings #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gBvd5iWy 💡 My thought process: For this question, I am precalculating the total sum of the grid and row-wise and column-wise sums. Store the precalculated values in a vector and then simply do a cumulative sum over the vector. If the cumulative sum equals the total sum - cumulative sum, this means that a single cut is possible to split the array. The calculation part is done in another method, and I simply call the method twice for row-wise check and then column-wise. 👉 My Solution: https://lnkd.in/gNYsk6iz 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 4 of 100 Days LeetCode Challenge. Problem: Special Positions in a Binary Matrix Today’s problem focused on matrix traversal + counting logic—simple concept, but requires careful observation. 💡 Key Insight: A position (i, j) is special if: mat[i][j] == 1 All other elements in the same row and column are 0 🔍 Efficient Approach: Count number of 1’s in each row Count number of 1’s in each column A position is special only if: Row count = 1 Column count = 1 👉 This avoids unnecessary repeated checks and improves efficiency. 🔥 What I Learned Today: Preprocessing (row & column counts) simplifies problems Avoid brute force → think in terms of frequency/counting Clean logic > complex code 📈 Challenge Progress: Day 4/100 ✅ Staying consistent! LeetCode, Matrix Problem, Arrays, Counting Technique, DSA Practice, Coding Challenge, Problem Solving, Algorithm Thinking, Optimization #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep