LeetCode Day 27: Graph Algorithms & Shortest Path Optimization

🚀 LeetCode Day 28 | Advanced Graph Optimization & String Transformations Solved 2977. Minimum Cost to Convert String II, a challenging problem that requires moving beyond basic logic and focusing on scalability, preprocessing, and performance tuning. 🔍 What this problem really tested: Modeling character-to-character transformations as a weighted directed graph Applying all-pairs shortest path preprocessing to efficiently handle repeated conversions Understanding how constraints influence algorithm choice Eliminating redundant computation to avoid Time Limit Exceeded Writing clean, maintainable solutions that scale to real-world input sizes 💡 Key insight from Day 28: A correct solution isn’t always enough — the best solution balances correctness, efficiency, and clarity. 📌 Skills strengthened: Graph Algorithms (Shortest Paths) Dynamic Programming concepts Optimization under constraints Interview-oriented problem solving Analytical thinking & debugging Daily consistency builds long-term mastery. One problem at a time. One improvement every day. Onward to Day 29 🚀 #LeetCode #Day28 #Graphs #DynamicProgramming #ProblemSolving #SoftwareEngineer #CodingInterview #LearningByDoing

Day 59 – Flatten Binary Tree to Linked List 🌳➡️🔗 Today's challenge transformed a binary tree into a right skewed linked list following preorder sequence an exercise in pointer manipulation and structural reconfiguration without extra space. 🌳 Flatten Binary Tree to Linked List I approached this problem using a recursive postorder traversal that reshapes the tree from the bottom up. For each node, I first flattened its left and right subtrees recursively. I then took the flattened left subtree and inserted it between the current node and its right subtree moving the original right subtree to the end of this newly attached left chain. This in-place transformation achieved O(n) time with O(h) recursion stack space, where h is the tree height. #LeetCode #Coding #Algorithms #DataStructures #BinaryTree #TreeTraversal #Recursion #InPlace #ProblemSolving #SoftwareEngineering #Programming #100DaysOfCode

🚀 Day 5/60 — LeetCode Discipline Problem Solved: Range Sum Query – Immutable (Revision) Difficulty: Easy Today’s practice was centered around strengthening prefix sum intuition for efficient range queries. Instead of recalculating sums repeatedly, the focus was on preprocessing the array to enable constant-time query responses. 💡 Focus Areas: • Reinforced prefix sum technique • Practiced preprocessing for query optimization • Improved time–space trade-off understanding • Focused on writing clean and efficient logic ⚡ Performance Highlight: Achieved ~99% runtime efficiency on submission. Quiet, consistent refinement of core patterns continues. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #PrefixSum #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

🚀 100 Days LeetCode Challenge – Day 33 🚀 Solved LeetCode 1572: Matrix Diagonal Sum ✅ Today’s problem was simple in concept but a good reminder of index relationships in matrices. 💡 Core Idea: In a square matrix: Primary diagonal → i == j Secondary diagonal → i + j == n - 1 Traverse the matrix and: Add elements where i == j Add elements where j == n - i - 1 Make sure not to double count the center element (when n is odd) 🧠 Key Learnings: Understanding diagonal patterns is important for matrix problems Index math (i + j = n - 1) is extremely useful Avoid unnecessary nested loops — this can be optimized to O(n) 👉 Instead of O(n²), we can directly compute using: mat[i][i] mat[i][n-1-i] ⏱️ Complexity: Time: O(n²) Space: O(1) #100DaysOfCode #LeetCode #Matrix #Cpp #ProblemSolving #DSA

🚀 300+ LeetCode Problems Solved I’ve crossed 300+ problems on LeetCode, and this phase of preparation has been less about numbers and more about depth, patterns, and optimization. 🧠 Primary focus areas 🟣 Dynamic Programming State design and transitions ➜ Memoization ➜ Tabulation ➜ Space optimization. Worked on classic patterns like 0/1 Knapsack, LIS, and DP on grids & strings. 🔵 Graphs Built strong fundamentals using BFS and DFS, explored connected components, cycle detection, and topological sorting, and developed solid intuition for shortest path problems using Dijkstra and BFS-based approaches. 🟢 Strings Practiced sliding window and two-pointer techniques, hashing and frequency-based optimizations, and problems combining greedy logic with DP on strings. ⚙️ What improved during this journey 🔁 Brute-force ideas evolved into optimized solutions. 📈 Solutions now include clear time and space complexity analysis. 🧩 Shifted from solving problems individually to recognizing recurring patterns. 🛠️ Became more confident handling edge cases under tight constraints. 💡 Key takeaway 👉 Strong solutions come from understanding constraints, identifying patterns, and optimizing step by step before writing code. 🎯 Continuing to iterate and refine — Consistency + Curiosity = Growth 🚀 #LeetCode #DSA #Algorithms #DynamicProgramming #Graphs #Strings #ProblemSolving

Day 50 – List Partitioning and Deep Copy with Random Pointers 🔗🎯🧬 Reaching the halfway milestone with two intricate linked list challenges each demanding precise pointer manipulation and structural ingenuity to transform lists under complex constraints. 🎯 Partition List Segregated a linked list into two partitions nodes less than a target value x followed by nodes greater than or equal to x while preserving relative order. Used two dummy headed lists to collect nodes from each partition during traversal, then merged them in O(n) time with O(1) space. A clean exercise in conditional node redirection without restructuring values. 🧬 Copy List with Random Pointer Constructed a deep copy of a linked list where each node contains an additional random pointer to any node (or null). Created cloned nodes interleaved with originals Assigned random pointers using next relationships Separated the lists to extract the deep copy. Achieved O(n) time with O(1) extra space (excluding output) a masterclass in pointer manipulation and structural mirroring. #LeetCode #Coding #Algorithms #DataStructures #LinkedList #TwoPointers #DeepCopy #RandomPointer #ProblemSolving #SoftwareEngineering #Programming #100DaysOfCode

Day 36 of the LeetCode Daily Challenge ✅ Solved LeetCode 1653 – Minimum Deletions to Make String Balanced, a problem focused on string processing, greedy decision-making, and optimal state tracking. The goal was to ensure that all 'a' characters appear before any 'b' characters, while minimizing deletions. Rather than attempting brute-force deletions, I applied a greedy strategy with prefix/suffix reasoning, enabling an efficient single-pass solution. 🧠 Key Technical Insights: Used running counts to track the number of 'b' characters encountered so far Evaluated deletion trade-offs dynamically at each step Achieved an optimal O(n) time complexity with O(1) extra space Ensured correctness for large input sizes through constant-memory logic This problem reinforced the importance of simplifying constraints into maintainable states, a critical skill in real-world systems where efficiency and clarity matter. Continuing to build consistency through daily problem-solving, strengthening core fundamentals in algorithms, data structures, and clean logic design. #LeetCode #LeetCodeDaily #StringAlgorithms #Greedy #DataStructures #ProblemSolving #SoftwareEngineering #CodingPractice #ContinuousLearning #Python

DSA Practice – Day 11 | Difficulty-Balanced Set Solved on LeetCode and GFG, focusing on backtracking, recursion, combinatorics, and dynamic programming: Medium • LC 40 – Combination Sum II — Backtracking, Duplicate Handling • LC 46 – Permutations — Backtracking • LC 78 – Subsets — Backtracking, Bit Manipulation • LC 377 – Combination Sum IV — Dynamic Programming GFG • Rat Maze With Multiple Jumps — Backtracking, Matrix Traversal, Recursion Core topics covered: Backtracking, Recursion, Dynamic Programming, Combinatorics, Matrix Traversal #DSA #LeetCode #GeeksforGeeks #Algorithms #DataStructures #ProblemSolving

I recently attended an online webinar on “Getting Started with Rust: Pattern Matching” organized by the Rust & C++ Cardiff community. The session highlighted Rust’s pattern matching model as a core language feature, distinguishing it from traditional switch constructs in C++. Rust’s match expression is exhaustive by design, compelling developers to account for every possible variant at compile time, which enhances correctness and eliminates many runtime errors related to unhandled states. Key technical insights included: - Exhaustiveness checking ensures all enum variants are handled, reinforcing compile-time safety. - Destructuring patterns allow for concise data extraction from enums, structs, tuples, and references. - Algebraic data types (ADTs) in Rust integrate seamlessly with pattern matching, fostering expressive domain modeling. - The use of if let and while let simplifies handling specific variants without unnecessary boilerplate. - Match guards provide additional conditional refinement while maintaining clarity and structure. A particularly interesting comparison was made regarding how Rust’s pattern matching, when combined with ownership and borrowing rules, promotes explicit state modeling and reduces ambiguity in control flow. In contrast, similar implementations in C++ often necessitate more defensive programming and manual checks. This session reinforced how Rust’s language design aligns safety guarantees with expressive power, particularly for systems-level and performance-critical applications. For engineers working in large-scale or safety-critical systems, how has Rust’s approach to pattern matching influenced your architectural or domain modeling decisions compared to C++? #Rust #Cplusplus #SystemsProgramming #TypeSafety #SoftwareEngineering

LeetCode 70 — Climbing Stairs Worked on finding the number of distinct ways to reach the top when you can climb either 1 or 2 steps at a time. Initially, it looks like a simple counting problem. But structurally, it follows a clear recurrence pattern. Approach — Recurrence Relation - If n ≤ 1 → only one possible way - From step n, you can: - Take 1 step → reduce to (n - 1) - Take 2 steps → reduce to (n - 2) - Total ways = ways(n - 1) + ways(n - 2) This is essentially the Fibonacci pattern in a different form. While testing with small inputs, the recursive solution worked correctly. However, on submission it resulted in Time Limit Exceeded for larger inputs. That made one thing very clear :- The logic is correct, but overlapping subproblems make the pure recursive approach inefficient. Key learning :- Correct logic is not enough. Efficiency matters. Recognizing when recursion needs optimization (memoization / DP) is just as important as writing it. #leetcode #recursion #dynamicprogramming #dsa #algorithms #problemSolving #codingjourney