Split Array Largest Sum LeetCode 410 Solution

🚀 Day 7 of My LeetCode Journey Today’s problem: Search in Rotated Sorted Array At first glance, it looks like a normal search problem… but the rotation makes it interesting 🤯 💡 Key Insight: Used Binary Search by identifying which half of the array is sorted at each step. This helps decide where to continue the search efficiently. ⚡ Optimized Approach: Check which half is sorted Decide if target lies in that half Narrow down search space ⏱️ Time Complexity: O(log n) ⚡ Performance: 0 ms (Beats 100%) 🧠 What I Learned: Binary Search is all about pattern recognition Even “unsorted-looking” arrays can have structure Thinking logically > brute force #LeetCode #DSA #CodingJourney #BinarySearch #ProblemSolving

🚀 LeetCode 378 — Kth Smallest Element in a Sorted Matrix | Solved ✅ Solved this interesting problem using Binary Search on Answer — a powerful pattern! 🔍 Problem Insight: Matrix is sorted row-wise and column-wise, but not flattened. 💡 Approach: • Applied binary search on value range • For each mid, counted elements ≤ mid using matrix properties ⚡ Time Complexity: O(n × log(max - min)) ✨ Key Learning: Not all binary search problems are about indices — sometimes we search in the answer space. 📈 Result: Accepted ✔️ From searching positions → to searching values That’s where problem-solving evolves 🔥 Grateful to Pratyush Narain for the guidance and clear explanations. #LeetCode #DSA #BinarySearch #ProblemSolving #CodingJourney

Day 7 🚀 Solved: Balanced Binary Tree (LeetCode 110) This problem builds on recursion and tree depth. A tree is balanced if the height difference between left and right subtrees is at most 1 for every node. 💡 My approaches: 🔹 Approach 1 (Brute Force): For every node, calculate left and right subtree heights Check the difference and recurse further 🔹 Approach 2 (Optimal – Postorder DFS): Compute height and balance together in one traversal Avoid recomputing subtree heights 💡 Key learning: Instead of solving subproblems separately, combine them in a single DFS to optimize performance. ⏱️ Time Complexity: Brute Force → O(n²) Optimal → O(n) 🔗 GitHub: https://lnkd.in/gVdJeg2a #DSA #LeetCode #Coding

Day 39 | LeetCode Learning Journal 🚀 Today I solved Sqrt(x) using Binary Search. This problem helped me understand how searching techniques can be applied beyond arrays to mathematical problems! 🔑 Key Points: • Find the integer square root of a number. • Avoid using built-in sqrt functions. • Applied Binary Search to reduce time complexity. • Stored the last valid answer (floor value). 🌱 What I Learned: • How Binary Search can be used on answer space. • Importance of avoiding overflow using long long. • Efficient way to handle large inputs. • Strengthened problem-solving with math + logic. #LeetCode #100DaysOfCode #DSA #CodingJourney #Day39 🚀

Day 21 – LeetCode 💻 Solved: Isomorphic Strings (Easy) Approach: Hash Mapping (Two Arrays) Used two arrays to maintain mapping from s → t and t → s. For each character: Checked if both mappings are consistent If mismatch found → not isomorphic Otherwise updated mapping Ensures one-to-one mapping between characters. Time Complexity: O(n) Space Complexity: O(1) (fixed size arrays) 💡 Concepts Used: Hashing + String Mapping #LeetCode #Day21 #DSA #Coding #Consistency

LeetCode #51 — N-Queens | Backtracking at Its Best Just solved the classic N-Queens problem — one of the most interesting backtracking challenges that tests logic, recursion, and optimization. Problem Insight:Place n queens on an n × n chessboard so that no two queens attack each other. That means: No same row No same column No same diagonal Approach: Backtracking + Safe Position Checks Place one queen row by row Check if the current position is safe If valid, move to the next row If stuck, backtrack and try another position What I Learned: 1) Backtracking is about trying possibilities efficiently 2) Constraints help prune unnecessary paths 3) Visualizing the board makes recursion easier to understand This problem is a great reminder that patience + recursion can solve even the toughest puzzles. #LeetCode #NQueens #Backtracking #Algorithms #CodingJourney #ProblemSolving #DSA #TechLearning

🚀 Day 35 | 100 Days of Coding Challenge #DrGViswanathanChallenge 📘 Problem Solved: Next Greater Element I (LeetCode) 🔧 Approach Used (Brute Force): • For each element in nums1, found its index in nums2 • Traversed to the right to find the first greater element • If none found, returned -1 📌 Key Idea: For every element, scan right side to find the next greater value. ⏳ Complexity: Time: O(n × m) Space: O(1) (excluding output) 🧠 Key Learning: Brute force helps build intuition, but this problem can be optimized using a monotonic stack for O(n) performance. 💡 Optimization Insight: Use a stack + hashmap to precompute next greater elements efficiently. 📂 Topics Covered: Arrays, Brute Force, Monotonic Stack #100DaysOfCode #DSA #CPP #LeetCode #CodingJourney #CompetitiveProgramming

LeetCode Progress 39/50 — Binary Search Today I worked on a fundamental problem focused on searching and algorithmic efficiency 🧩 💡 The challenge was to locate a target element in a sorted array using an optimized approach. 🧠 Approach: Used binary search to repeatedly divide the search space in half, reducing comparisons and efficiently locating the target element. ⏱ Time Complexity: O(log n) 💡 What I learned: This problem reinforced how powerful divide-and-conquer techniques like binary search can be for improving performance. 📈 Strengthening understanding of fundamental algorithms and improving efficiency in problem-solving. #LeetCode #DSA #BinarySearch #ProblemSolving #Cpp #CodingJourney #Consistency 🚀

Today I worked on LeetCode problems #46 (Permutations) and #47 (Permutations II). Problem 46 helped reinforce the fundamentals of backtracking — generating all possible permutations by fixing elements one by one and exploring all possibilities. Problem 47 took it a step further by introducing duplicates. It was interesting to handle unique permutations efficiently by avoiding redundant work using techniques like sorting and using a set at each recursion level. Key takeaway: Backtracking is powerful, but handling duplicates correctly is where the real understanding kicks in. Consistent practice like this is helping me strengthen my problem-solving and recursion skills. #leetcode #backtracking #datastructures #algorithms #coding #softwareengineering

-- LeetCode 396 — Rotate Function This problem looks like a rotation problem… but it’s actually a math + observation problem. At first, the obvious approach is: 🔁 Rotate the array → recompute F(k) every time → O(n²) But that’s inefficient. -- The breakthrough moment: Instead of recomputing, track how the value changes after each rotation. We get: F(k) = F(k−1) + sum − n × nums[n−k] That’s it. One formula → transforms the solution to O(n) ⚡ 🧠 What clicked for me: Rotation problems often hide a pattern If you’re recalculating everything, you’re probably missing something Reusing previous computation is the real optimization #LeetCode #DSA #Algorithms #Coding #ProblemSolving #algorithm