Dijkstra's Algorithm for Minimum Cost Path

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gfWSucCh 💡 My thought process: This solution calculates the minimum cost to change a `source` string into a `target` string using allowed substring transformation rules that have specific costs. The transformations form a weighted directed graph, where each substring is a node, and each transformation is an edge with a cost. To manage indirect transformations effectively, Dijkstra’s algorithm finds the shortest path between two substrings. Since the same substring conversions can be requested multiple times, the algorithm saves the shortest-path results to avoid repeating graph searches. The overall solution employs top-down dynamic programming, with each state showing the minimum cost to transform the string starting from a given index. If the characters at the current position match, the algorithm moves forward at no cost. If they do not match, it examines all valid substring lengths and adds the transformation cost to the result of the remaining suffix. This mix of dynamic programming, shortest-path computation, and saved results ensures both accuracy and efficiency. 👉 My Solution: https://lnkd.in/gCv3cXCf 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 1011 — Capacity To Ship Packages Within D Days Worked on determining the minimum ship capacity required to transport all packages within a fixed number of days while preserving the given order. Approach — Binary Search on Capacity + Feasibility Check - Observed that ship capacity must lie between: - Maximum single package weight (lower bound) - Sum of all weights (upper bound) - Applied binary search within this capacity range - For each candidate capacity: - Simulated the shipping process day by day - Counted how many days were required without exceeding capacity - If shipping finished within the allowed days → tried a smaller capacity - Otherwise → increased the capacity This reduced the problem to O(n log(sum of weights)), a classic example of binary search on the answer space rather than the array itself. A strong reminder that many optimization problems are really about searching the minimum feasible value, not brute-forcing combinations. #leetcode #binarysearch #dsa #algorithms #codingjourney #problemsolving #javaprogramming #learninpublic #techskills #placements #codingpractice

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gwdQDKx4 💡 My thought process: The code calculates the sum of all root-to-leaf paths in a binary tree where each node contains either 0 or 1. Each path from root to leaf represents a binary number. The goal is to convert these binary numbers to decimal and return their total sum. The helper function solve performs a depth-first search. It builds a binary string along the current path by adding the node’s value. When a leaf node is reached, the binary string is saved in a vector. The recursion continues for the left and right children until all root-to-leaf paths are explored. In sumRootToLeaf, after collecting all binary path strings, each string is converted to its decimal equivalent using bit shifting. For each character, its value is multiplied by the corresponding power of 2 and added to a running total. The final result is the sum of all converted values. The time complexity is linear based on the number of nodes, and additional space is needed for recursion and storing path strings. 👉 My Solution: https://lnkd.in/gwAHXfX6 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 (27th Jan 2026) Educational Insight - The "Minimum Cost Path with Edge Reversals" problem demonstrates how to reduce a constrained graph problem to a standard shortest‑path by augmenting edges with reversal costs. By treating reverse traversals as separate weighted edges and then applying Dijkstra / 0‑1 BFS, we avoid ad‑hoc state modeling and keep the solution clean and scalable. Key Implementation Details For each directed edge u → v with weight w, keep forward cost w and introduce a reverse edge v → u with its own cost (e.g., reversal penalty). Build an adjacency list on this expanded graph representation. Run Dijkstra from the source to compute minimum cost path to the destination. Time complexity O((n + m) log n) with a binary‑heap priority queue. Full platform dropping soon. Stay tuned. Join the waitlist: https://lnkd.in/ge3vvHFu #DSA #LeetCode #Coding #VisuallyInclined

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g6C9kJb4 💡 My thought process: For a specific value of k, there are exactly 2^k possible binary strings of that length. For example, if k = 2, the possible binary codes are 00, 01, 10, and 11, making a total of 4 combinations. The solution uses a sliding window approach with size k. It goes through the string using index j and keeps adding characters to a temporary string called window. When the size of the window equals k, the substring is added to an unordered set to ensure it is unique. After adding, the window shifts forward by removing its first character using substr(1), and the process continues. At the end, the function checks if the number of unique substrings stored in the set equals 1 shifted left by k, which represents 2^k. If the sizes match, it means every possible binary substring of length k is in the string, and the function returns true. If not, it returns false. The time complexity is O(n × k) because each substring operation can take up to O(k) time. The space complexity is O(2^k) in the worst case for storing all possible substrings. 👉 My Solution: https://lnkd.in/gBrK8uHB 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

𝗗𝗮𝘆 32 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 3013. Divide an Array Into Subarrays With Minimum You are given a 0-indexed array of integers nums of length n, and two positive integers k and dist. The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3. You need to divide nums into k disjoint contiguous subarrays, such that the difference between the starting index of the second subarray and the starting index of the kth subarray should be less than or equal to dist. In other words, if you divide nums into the subarrays nums[0..(i1 - 1)], nums[i1..(i2 - 1)], ..., nums[ik-1..(n - 1)], then ik-1 - i1 <= dist. Return the minimum possible sum of the cost of these subarrays. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/gZAdyJcZ 𝗛𝗶𝗻𝘁:- For each index i, calculate a new circular index by shifting i by nums[i] steps, using modulo arithmetic to handle both positive and negative offsets. Populate the result array by fetching the value at each calculated index, ensuring the logic wraps around the array boundaries correctly. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/giSfinNu #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

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

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gChbc9pi 💡 My thought process: Use an Array to store the values of the tree. The inorder function performs an inorder traversal of the original BST, collecting all node values into a list. Since the inorder traversal of a BST visits nodes in ascending order, the values list is sorted automatically. The buildTree function recursively constructs a balanced BST from a range [left, right] of the sorted values list. The base case returns null when left is greater than right, indicating that the range is empty. For each range, we find the middle index and create a node with values[mid]. This middle element becomes the root of the current subtree. We then recursively build the left subtree using elements from left to mid-1, and the right subtree using elements from mid+1 to right. This method maintains balance because at each level, we split the remaining elements into roughly equal parts. The time complexity is O(n) for the inorder traversal and O(n) for building the tree, resulting in O(n) overall. The space complexity is O(n) for storing values and O(log n) for the recursion stack depth of a balanced tree. 👉 My Solution: https://lnkd.in/gxBj8v6b 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

𝗗𝗮𝘆 38 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 3721. Longest Balanced Subarray II You are given an integer array nums. A subarray is called balanced if the number of distinct even numbers in the subarray is equal to the number of distinct odd numbers. Return the length of the longest balanced subarray. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/djmqAqhd 𝗛𝗶𝗻𝘁:- 1.Think in terms of a sliding left boundary and maintain a prefix “balance” of distinct odd vs distinct even values; when the left boundary moves past the first occurrence of a value, adjust the balance only until its next occurrence. 2. Use a segment tree with lazy propagation over prefix balances so you can range-update efficiently and query the rightmost index where the balance becomes zero (i.e., a balanced subarray). 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/d-kxnEU4 #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

The starting point often matters more than the algorithm. I spent 4 hours on the "Surrounded Regions" graph problem today. The logic wasn't the issue—the direction was. The Initial Mistake I started my search from the middle of the grid, checking if every "O" eventually connected to a boundary. While this worked, it was redundant and inefficient. The "Aha!" Moment I flipped the logic. Instead of searching from the inside out, I started exactly where the "safety" lies: the edges. By marking "O"s connected to the boundary first, the remaining trapped regions became easy to identify. Time complexity dropped from O(n²× m) to O(n × m). Lesson: Sometimes the starting point matters more than the algorithm. Have you ever solved a technical hurdle just by reversing your perspective? #DSA #BuildInPublic #SoftwareEngineering #LeetCode #ProblemSolving #Coding