Counting Permutations with Inversions using Dynamic Programming

Day 69/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Reverse Nodes in k-Group A challenging linked list problem focused on reversing nodes in fixed-size groups. Problem idea: Reverse nodes of a linked list in groups of size k, while keeping remaining nodes as it is. Key idea: Linked list manipulation + iterative reversal in segments. Why? • We need to reverse nodes in chunks, not the whole list • Careful pointer handling is required • Must preserve connections between groups How it works: • Use a dummy node for easier handling of head • Identify the k-th node from current position • Reverse nodes between current and k-th node • Connect reversed group back to the list • Move to next group and repeat • Stop if remaining nodes are less than k Time Complexity: O(n) Space Complexity: O(1) Big takeaway: Mastering pointer manipulation in linked lists is key to solving advanced problems efficiently. This problem is a great example of combining reversal logic with structural control. 🔥 Day 69 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #LinkedList #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Late-night problem solving hits different 🌙💻🔥 Wrapped up today by solving Maximum Sum BST in Binary Tree 🌳🚀 Accepted with 60/60 test cases passed ✅💯 This was one of those problems where the real challenge wasn’t traversal—it was designing the right information flow between recursive calls 🧠⚡ 🔍 Problem Insight: Given a binary tree, find the maximum sum of all keys of any subtree that forms a valid Binary Search Tree (BST) 🌳 So the task wasn’t just to traverse the tree… It was to identify whether each subtree is a BST and compute its sum at the same time 🎯 🧠 My Approach: Used postorder traversal (Left → Right → Root) because each node depends on information from both subtrees 🔁 For every node, I returned a custom set of information from recursion: 👉 minimum value in subtree 👉 maximum value in subtree 👉 sum of subtree 👉 whether the subtree is a valid BST This allowed each recursive call to decide: ✔ Is the current subtree a BST? ✔ If yes, what is its total sum? ✔ Should this update the global maximum? ✨ Core Idea: A subtree is a valid BST only if: 👉 left subtree is BST 👉 right subtree is BST 👉 left.max < root.val < right.min If valid, update the answer with the subtree sum 💯 If not, simply propagate enough information upward for parent checks 🔄 ✨ Why this approach works well: ✔ Single traversal solution 🚀 ✔ Combines validation + sum calculation together 🧠 ✔ Perfect use of postorder dependency 🔁 ✔ Elegant recursive state design 🌳 📊 Complexity: ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(h) recursion stack 💡 Key Takeaway: Some tree problems are less about traversal and more about what information each recursive call should return 🎯 Once the return state is designed well, the solution becomes much cleaner and more powerful ⚡🌳 Ending the day with one more concept learned and one more problem solved 💻🌙🔥 #BinaryTree #BST #Trees #Recursion #PostorderTraversal #Java #DataStructures #DSA #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #Programming 🌳💻🚀

💡 LeetCode 191 — Number of 1 Bits (Hamming Weight) Recently solved an interesting bit manipulation problem that highlights the power of low-level optimization 🚀 🔍 Problem Statement: Given an unsigned integer, count the number of set bits (1s) in its binary representation. 🧠 Key Insight: Instead of checking every bit individually, we can use a clever trick: 👉 n & (n - 1) removes the rightmost set bit in each operation. This allows us to count only the set bits, making the solution more efficient. ⚙️ Approach Used (Brian Kernighan’s Algorithm): Initialize a counter Repeatedly apply n = n & (n - 1) Increment count until n becomes 0 📈 Time Complexity: O(k), where k = number of set bits (faster than checking all 32 bits) 📦 Space Complexity: O(1) ✨ Why this problem is important: Strengthens understanding of bit manipulation Frequently asked in interviews Useful in low-level optimization and system design 💬 Takeaway: Sometimes the best solutions come from understanding how data is represented at the binary level. Small tricks can lead to big optimizations! #LeetCode #DSA #CodingInterview #Java #BitManipulation #ProblemSolving #TechJourney

🔄 Solved “Spiral Matrix”, a classic matrix traversal problem using boundary-based approach. ✦ What This Problem Taught Me: • How to traverse a 2D matrix layer by layer using boundaries • Effective use of four pointers (top, bottom, left, right) • Managing direction-based traversal (→ ↓ ← ↑) • Importance of shrinking boundaries after each iteration • Avoiding duplicate traversals using proper conditions • Strengthened understanding of 2D arrays and indexing 🚀 Problems like this show how controlling boundaries and direction can simplify complex matrix traversals into a clean O(m × n) solution. On to solving more matrix and pattern-based problems 💪🔥 #LeetCode #DSA #Matrix #TwoPointers #CodingJourney #ProblemSolving #Java #100DaysOfCode

Day 68/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Add Two Numbers A fundamental linked list problem that mimics real-life addition. Problem idea: Add two numbers represented by linked lists (digits stored in reverse order). Key idea: Linked list traversal + carry handling. Why? • We process digits one by one (like manual addition) • Need to handle carry at each step • Lists can have different lengths How it works: • Use a dummy node to build the result • Traverse both lists simultaneously • Add values + carry • Create new node with (sum % 10) • Update carry = sum / 10 • Move pointers forward • Continue until both lists and carry are done Time Complexity: O(max(m, n)) Space Complexity: O(max(m, n)) Big takeaway: Using a dummy node simplifies linked list construction and avoids edge cases. This pattern is very common in linked list problems. 🔥 Day 68 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #LinkedList #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

𝐃𝐚𝐲 𝟖𝟓 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on moving all zeroes to the end while maintaining order. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Move Zeroes 🔗 https://lnkd.in/dTnpVvBg 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 – 𝐓𝐰𝐨 𝐏𝐨𝐢𝐧𝐭𝐞𝐫𝐬 • Used a pointer ind to track position for non-zero elements Steps: • Traverse array • If element ≠ 0 → swap with index ind • Increment ind • Ensures all non-zero elements move forward • Zeroes automatically shift to the end 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • In-place operations reduce space complexity • Two-pointer technique is very powerful • Maintaining relative order is important • Simple logic can still be optimal 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(n) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Efficiency is not always about complex logic — sometimes it’s about clean and smart implementation. 85 days consistent 🚀 On to Day 86. #DSA #Arrays #TwoPointers #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

🚀 𝗗𝗮𝘆 - 48/60 Problem: Rotate Array by One (Right Rotation) 🔍 Learned: To rotate the array by one position to the right, store the last element, shift all elements one step to the right, and place the stored element at the beginning. 😅 Struggles: Initially mixed up left and right rotation logic and tried shifting from left to right, which caused overwriting and wrong results. Also made indexing mistakes like accessing invalid positions. 🧠 Key Learning: Always decide direction first (left vs right) before coding. For right shift, traverse from end to start to avoid overwriting. Store the element that will be lost (last element here) before shifting. 📦 Concepts Used: #Arrays #Traversal #InPlace #LogicBuilding #DSA Direction clarity + correct traversal = clean solution. 🚀 #Java #CodingJourney #ProblemSolving #Consistency

**Day 114 of #365DaysOfLeetCode Challenge** Today’s problem: **Keyboard Row (LeetCode 500)** A fun and simple problem focused on **strings + simulation + clean logic**. We need to return words that can be typed using letters from **only one row** of the American keyboard. Rows: * Row 1 → `qwertyuiop` * Row 2 → `asdfghjkl` * Row 3 → `zxcvbnm` 💡 **Core Idea:** For each word: 1️⃣ Convert to lowercase 2️⃣ Identify keyboard row of first character 3️⃣ Check whether every remaining character belongs to same row 📌 **Approach:** * Use strings to represent rows * Use `indexOf()` for membership check * Preserve original word in output ⚡ **Time Complexity:** O(total characters in all words) ⚡ **Space Complexity:** O(result list) **What I learned today:** Even easy problems teach valuable habits: 👉 Clean iteration 👉 Case handling 👉 Efficient validation logic 💭 **Key Takeaway:** Not every challenge needs advanced algorithms. Sometimes simplicity + clean implementation = best solution. #LeetCode #DSA #Strings #Java #CodingChallenge #ProblemSolving #TechJourney #Consistency

Day 58/100 – LeetCode Challenge Problem: Longest Increasing Path in a Matrix Today I solved the “Longest Increasing Path in a Matrix” problem, which is a challenging combination of DFS and dynamic programming. The goal is to find the longest path in a matrix such that each step moves to a strictly increasing value. Brute force would be too slow here, so I used DFS along with memoization (DP) to optimize repeated computations. For each cell, I explored all four possible directions (up, down, left, right) and continued the path only if the next value was greater. To avoid recomputing paths from the same cell, I stored results in a DP matrix. If a cell was already computed, I reused that value directly. This combination of DFS + memoization ensures that each cell is processed efficiently while still exploring all valid paths. The solution runs in O(m × n) time with O(m × n) space complexity. This problem reinforced how powerful memoization is when combined with recursion. Without it, the solution would be exponential — with it, it becomes efficient and scalable. Fifty-eight days in. Now it’s less about solving and more about optimizing how I think. #100DaysOfLeetCode #Java #DSA #DFS #DynamicProgramming #Memoization #ProblemSolving #Consistency

Day 72/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Rotate List A clean linked list manipulation problem that tests pointer handling. Problem idea: Rotate the linked list to the right by k places. Key idea: Convert list into a cycle + break at the right position. Why? • Direct shifting is inefficient • Linked list doesn’t allow random access • Forming a cycle simplifies rotation logic How it works: • Traverse list to find length • Connect tail → head (make it circular) • Reduce k using modulo 👉 k = k % length • Find new tail at (length - k - 1) • Break the cycle to form new head Time Complexity: O(n) Space Complexity: O(1) Big takeaway: Many linked list problems become easier when you temporarily convert structure (like making a cycle) and then restore it. This trick is very powerful in pointer-based problems. 🔥 Day 72 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #LinkedList #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity