Solved Minimum Cost to Connect Ropes with Greedy Algorithm

🔥 Day 222 - Daily DSA Challenge! 🔥 Problem: 🌳 Flatten Binary Tree to Linked List Given the root of a binary tree, flatten it into a linked list in-place, following the preorder traversal order (root → left → right). 💡 Key Insights: 🔹 The goal is to modify the tree without using extra space. 🔹 For each node, if a left subtree exists: 1️⃣ Find the rightmost node of the left subtree. 2️⃣ Connect that node’s right pointer to the current node’s right subtree. 3️⃣ Move the left subtree to the right and set left = null. 🔹 Repeat this process while traversing through the tree. ⚡ Optimized Plan: ✅ Traverse using a pointer (curr). ✅ If curr.left exists, attach it in place of curr.right and re-link the subtrees. ✅ Continue the process until the end of the tree. ✅ Time Complexity: O(n) — each node visited once. ✅ Space Complexity: O(1) — in-place transformation. 💬 Challenge for you: 1️⃣ Can you flatten the tree using recursion instead of iteration? 2️⃣ How would you modify this to produce a postorder or inorder flattened list? #DSA #BinaryTree #LinkedList #LeetCode #ProblemSolving #CodingChallenge #KeepCoding #100DaysOfCode

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 2654. 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐌𝐚𝐤𝐞 𝐀𝐥𝐥 𝐀𝐫𝐫𝐚𝐲 𝐄𝐥𝐞𝐦𝐞𝐧𝐭𝐬 𝐄𝐪𝐮𝐚𝐥 𝐭𝐨 1. This problem was an excellent application of mathematical reasoning through the Euclidean Algorithm (GCD). It helped me appreciate how fundamental math concepts can simplify complex algorithmic logic and lead to optimized solutions. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given an array of positive integers. In one operation, we can select an index i and replace either nums[i] or nums[i+1] with their GCD value. The task is to find the minimum number of operations required to make all elements equal to 1, or return -1 if it is impossible. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Checked if the array already contains any element equal to 1. If yes, the minimum operations equal the number of elements that are not 1. If not, used a nested loop to find the shortest subarray whose GCD becomes 1 using the Euclidean Algorithm. Once such a subarray is found, it can be made 1 in (subarray length - 1) operations. The total number of operations is calculated as (subarray length - 1) + (n - 1), representing the steps to convert the rest of the array to 1. Added an early break once GCD reaches 1 for better performance. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n² * log(max(nums))) Space Complexity: O(1) 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Reinforced the use of the Euclidean Algorithm and recursion for GCD calculations. Understood the role of early exits in improving nested loop efficiency. Observed how mathematical insight directly enhances algorithmic problem-solving. This marks my first post in my LeetCode Daily Challenge journey. I plan to continue sharing my learnings and reasoning from each daily challenge to stay consistent and deepen my problem-solving approach. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningEveryday #Consistency #Algorithms #100DaysOfCode

🌟 Day 93 of My LeetCode Journey — Problem 686: Repeated String Match 💡 Problem Insight: Today’s problem explored how many times string A must be repeated so that string B becomes a substring of it. It’s a fun mix of string repetition and pattern matching — testing both logic and edge-case awareness. 🧠 Concept Highlight: The core idea is to keep repeating A until it’s at least as long as B, then check if B exists within it (or one more repetition). This problem reinforces concepts of string concatenation, searching, and boundary conditions in text processing. 💪 Key Takeaway: Sometimes, solutions aren’t about complexity but about knowing when to stop repeating — in both coding and persistence! ✨ Daily Reflection: Simple problems like these highlight the beauty of algorithmic reasoning — transforming trial-and-error into structured logic. #Day93 #LeetCode #100DaysOfCode #StringMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Persistence

🔥 Day 113 of My DSA Challenge – Word Search 🔷 Problem : 79. Word Search 🔷 Goal : Check if a given word exists in a 2D grid by connecting sequentially adjacent letters (horizontally or vertically). Same cell cannot be used more than once. 🔷 Key Insight : This is a DFS + backtracking problem. Start from every cell matching the first character. Explore all 4 directions recursively. Track visited cells to avoid reusing letters. Backtrack when a path fails. This teaches how to explore grids efficiently using recursion and state tracking. 🔷 Approach : 1️⃣ Iterate over all cells to find starting points 2️⃣ DFS recursively for adjacent letters 3️⃣ Use a visited matrix to avoid reusing cells 4️⃣ Backtrack if the path does not lead to the word Time Complexity: O(m × n × 4^k) where k = length of word Space Complexity: O(m × n) for visited + recursion stack Word Search reinforces grid DFS + backtracking patterns. Explore all possibilities, track state carefully, backtrack on failure. This pattern is useful for : ✅ Maze solving ✅ Island counting problems ✅ Pathfinding & puzzle problems Every day, a new pattern becomes familiar. Step by step, the mind gets sharper. 🚀 #Day113 #DSA #100DaysOfCode #DFS #Backtracking #LeetCode #ProblemSolving #Java #CodingChallenge #Algorithms #DataStructures #DeveloperJourney

🚀 DSA Challenge – Day 92 Problem: N-Queens Puzzle ♟️👑 This classic problem beautifully combines recursion, backtracking, and constraint satisfaction — a true test of algorithmic thinking and precision. 🧠 Problem Summary: You are given an integer n, representing an n × n chessboard. The goal is to place n queens such that no two queens attack each other — meaning no two share the same row, column, or diagonal. We must return all distinct board configurations that satisfy this condition. ⚙️ My Approach: 1️⃣ Use backtracking to try placing one queen per row. 2️⃣ Maintain three sets to track attacks: col → columns already occupied. positiveDiag (r + c) → major diagonals. negativeDiag (r - c) → minor diagonals. 3️⃣ For each row, place a queen only if it’s not under attack, then recurse for the next row. 4️⃣ Once all queens are placed, record the configuration as a valid solution. 📈 Complexity: Time: O(n!) → Since we explore all valid placements row by row. Space: O(n²) → For the board representation and recursion stack. ✨ Key Takeaway: The N-Queens problem teaches the art of constraint-driven backtracking — building solutions step by step while eliminating invalid paths early. It’s a perfect showcase of logical pruning in action. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Backtracking #Recursion #NQueens #Algorithms #Python #Optimization #Chessboard #InterviewPrep #EfficientCode #TechCommunity #LearningByBuilding #CodeEveryday

🚀 DSA Progress – Day 96 ✅ Problem #1404: Number of Steps to Reduce a Number in Binary Representation to One 🧠 Difficulty: Medium | Topics: String, Bit Manipulation, Simulation 🔍 Approach: Implemented a bitwise simulation approach to reduce a binary string to "1" without converting it to an integer. Step 1 (Right-to-Left Traversal): Start from the least significant bit (rightmost) and move leftwards until the most significant bit. Step 2 (Check Bit + Carry): At each step, evaluate (bit + carry) — If the result is odd (1) → perform two operations: add 1 (causing carry) and divide by 2. If the result is even (0) → perform one operation: divide by 2. Step 3 (Carry Handling): Maintain a carry variable to track the overflow when a +1 operation is applied. After the loop, if a carry still exists, add it to the total count. This method effectively simulates binary addition and division using string traversal, avoiding large integer conversions. 🕒 Time Complexity: O(n) — Single traversal of the binary string. 💾 Space Complexity: O(1) — Constant extra space for carry and counter variables. 📁 File: https://lnkd.in/emqeMm9h 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem deepened my understanding of binary arithmetic and carry propagation. Instead of direct numeric operations, I learned how to simulate binary behavior efficiently using strings — a crucial skill for handling large number representations. It also strengthened my logic for simulation problems, where each step mimics low-level arithmetic rules. ✅ Day 96 complete — reduced a long binary trail down to one shining bit! 💡⚙️🧠 #LeetCode #DSA #Python #Binary #BitManipulation #Simulation #Strings #CodingChallenge #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney

⚡ Day 85 of #100DaysOfDSA – Reverse Bits 💡 📌 Problem. no 190: Given a 32-bit unsigned integer, reverse its bits and return the result. Solved using bit manipulation by shifting and combining bits efficiently through iterative processing. ⚡ Runtime: 15 ms – Beats 74.65% of submissions 💾 Memory: 12.49 MB – Beats 49.36% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 600 test cases passed successfully! This problem strengthened my understanding of low-level bit operations, binary manipulation, and efficient use of shifting operators. It’s a great reminder that small operations can have big effects on data representation. 🔑 Key Learnings: ✔️ Learned how to manipulate bits effectively using bitwise operators ✔️ Understood the significance of shifting and masking in binary form ✔️ Improved my grasp of algorithmic efficiency at the bit level 🎯 Day 85 — A smart bitwise challenge that sharpened my binary logic and precision-based problem-solving! ⚙️💻🔥 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills

🚀 Day 61 of My LeetCode Journer 🚀 🚀 Problem: Transpose Matrix 🧠 Concept: Matrix Manipulation 🔹 Approach: We are given a 2D matrix and need to return its transpose — where rows become columns. It’s a straightforward problem that strengthens our understanding of nested loops and 2D array traversal. 💡 Key Takeaways: Practice of nested loops and array indices Useful concept in image processing, data transformations, and linear algebra #Day61 #LeetCode #Java #DSA #Matrix #CodingChallenge #100DaysOfCode #ProblemSolving #TechJourney

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🚀 DSA Progress – Day 120 ✅ Problem #3228: Maximum Number of Operations to Move Ones to the End 🧠 Difficulty: Medium | Topics: String, Greedy, Counting 🔍 Approach: Solved this problem using a greedy + counting strategy, focusing on how many times a '1' can cross a '0'. Step 1 (Scan the String): Traverse the string from left to right, counting how many '1's have appeared so far (count1seen). Step 2 (When You See a '0'): Every '0' contributes operations equal to the number of '1's that came before it. So whenever a '0' is found: result += count1seen Step 3 (Skip Zero Blocks): Move through continuous blocks of zeros to avoid redundant checks. Step 4 (Greedy Insight): We don’t actually move anything. We simply count how many (1 before 0) pairs exist → each pair = 1 valid operation. This makes the solution linear and optimal. 🕒 Time Complexity: O(n) — single pass through the string. 💾 Space Complexity: O(1) — only counters used. 📁 File: https://lnkd.in/gcPJcX4J 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem taught me that many “movement” problems can be solved by counting contributions instead of simulating actions. The key insight is recognizing that each '1' before a '0' guarantees an operation. By converting the process into a counting problem, the solution becomes elegant, readable, and highly efficient. ✅ Day 120 complete — counted binary traffic like a pro and moved those ones to the end! 🚦1️⃣➡️0️⃣🚀 #LeetCode #DSA #Python #Strings #Greedy #Counting #Binary #DailyCoding #InterviewPrep #GitHubJourney