NQueens Problem Solution with Optimized Backtracking

🔥 DSA Challenge – Day 120/360 🚀 📌 Topic: Math + Recursion 🧩 Problem: Count Good Numbers Problem Statement: Count total valid numbers of length n where even indices have 5 choices and odd indices have 4 choices. 🔍 Example: Input: n = 4 Output: 400 💡 Approach: Optimized (Binary Exponentiation) 1️⃣ Step 1 – Count even positions → use (n + 1) / 2 2️⃣ Step 2 – Count odd positions → use n / 2 3️⃣ Step 3 – Compute power using fast exponentiation and multiply ✔ Use formula: 5^(ceil(n/2)) × 4^(floor(n/2)) ✔ Apply modulo to handle large numbers ✔ Use recursion to reduce time complexity ⏱ Complexity: Time: O(log n) Space: O(log n) 📚 Key Learning: Binary Exponentiation helps reduce power calculation from O(n) to O(log n), which is very useful in large constraints problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode

🔥 DSA Challenge – Day 127/360 🚀 📌 Topic: Backtracking 🧩 Problem: Subsets II Problem Statement: Given an integer array that may contain duplicates, return all possible subsets such that the solution set does not contain duplicate subsets. 🔍 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] 💡 Approach: Backtracking + Sorting 1️⃣ Step 1 – Sort the array to group duplicate elements together 2️⃣ Step 2 – Use recursion to generate all subsets 3️⃣ Step 3 – Skip duplicate elements using condition (i != ind && nums[i] == nums[i-1]) ⏱ Complexity: Time: O(2^n) Space: O(n) (recursion stack + subset storage) 📚 Key Learning: Sorting + smart skipping of duplicates helps avoid repeated subsets in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking

🔥 DSA Challenge – Day 119/360 🚀 📌 Topic: Recursion / Math 🧩 Problem: Pow(x, n) Problem Statement: Find x raised to the power n (xⁿ) efficiently, even for large values of n. 🔍 Example: Input: x = 2, n = 5 Output: 32 💡 Approach: Optimized (Binary Exponentiation) 1️⃣ Step 1 – If n is negative, convert → x = 1/x and n = -n 2️⃣ Step 2 – Recursively calculate half = power(x, n/2) 3️⃣ Step 3 – • If n is even → return half × half • If n is odd → return half × half × x ⏱ Complexity: Time: O(log n) Space: O(log n) 📚 Key Learning: Breaking a problem into halves can drastically improve performance 🚀 #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #119DaysOfCode #LeetCode

🔥 DSA Challenge – Day 130/360 🚀 📌 Topic: Backtracking / DFS on Grid 🧩 Problem: Word Search Problem Statement: Given a 2D grid of characters and a word, check if the word exists by moving in 4 directions (no cell reuse). 🔍 Example: Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]] word = "ABCCED" Output: true 💡 Approach: Backtracking + DFS 1️⃣ Step 1 – Start from every cell matching the first character 2️⃣ Step 2 – Explore 4 directions (up, down, left, right) recursively 3️⃣ Step 3 – Mark visited cells and backtrack after exploring ✔️ Avoid revisiting the same cell ✔️ Stop early when characters don’t match ✔️ Return true as soon as full word is found ⏱ Complexity: Time: O(N * M * 4^L) Space: O(L) (recursion stack) 📚 Key Learning: Backtracking is powerful for exploring all possible paths while avoiding invalid ones using pruning. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #130DaysOfCode #LeetCode #Backtracking

🚀 Day 19/100 — #100DaysOfLeetCode Back to mastering one of the most powerful patterns in DSA — Sliding Window 💻🔥 ✅ Problem Solved: 🔹 LeetCode 1358 — Number of Substrings Containing All Three Characters 💡 Concept Used: Sliding Window + Frequency Tracking 🧠 Key Learning: The goal was to count all substrings containing 'a', 'b', and 'c'. Instead of checking every possible substring, I learned how: Expand the window until all required characters are present. Once valid, every further extension also forms valid substrings. Count substrings efficiently while shrinking the window. This converts a brute-force O(n²) approach into an optimized O(n) solution. ⚡ Big Insight: Sliding Window isn’t just about finding length — it can also be used for counting valid substrings efficiently. Consistency is slowly turning patterns into instincts 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

🔥 DSA Challenge – Day 125/360 🚀 📌 Topic: Recursion 🧩 Problem: Combination Sum Problem Statement: Given an array of distinct integers and a target, return all unique combinations where numbers sum up to the target. Same element can be used multiple times. 🔍 Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] 💡 Approach: Backtracking 1️⃣ Step 1 – Start from index 0 and try picking each element 2️⃣ Step 2 – If element ≤ target, include it and reduce target 3️⃣ Step 3 – Backtrack (remove element) and move to next index ✔ Use recursion to explore all possibilities ✔ Reuse same element (stay on same index) ✔ Stop when target becomes 0 (valid answer) ✔ Skip when index reaches end ⏱ Complexity: Time: O(2^n * k) (k = avg length of combination) Space: O(k * x) (x = number of combinations) 📚 Key Learning: Backtracking is all about making choices, exploring, and undoing them efficiently. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking 🚀

Day 37 #SDE backtracking and subset generation patterns. Solved: • Power Set in Lexicographic Order • Combination Sum Key Learning: • Generating a power set strengthens understanding of recursion trees and how to systematically explore all subsets in a structured (lexicographic) manner. • “Combination Sum” reinforces backtracking with choices and pruning, where we explore combinations while respecting constraints like target sum. #LeetCode #DSA #Backtracking #Recursion #Algorithms #Java #SoftwareEngineering

#CodeEveryday — My DSA Journey | Day 4 🧩 Problem Solved: Word Search (LeetCode #79) 💭 What I Learned: Used DFS + backtracking to search for a word in a 2D grid by exploring all possible paths. At each step: ✔️ Checked boundary conditions and character match ✔️ Explored all 4 directions (up, down, left, right) ✔️ Marked the current cell as visited to avoid revisiting ✔️ Backtracked by unmarking the cell after exploration Ensured correctness by stopping early when a mismatch occurs or when the full word is found. This strengthened my understanding of grid traversal with constraints and path tracking. ⏱ Time Complexity: O(m × n × 4^L) (L = length of word) 🧠 Space Complexity: O(L) (recursion stack) ⚡ Key Takeaways: ✔️ Backtracking is essential for path-based problems in grids ✔️ Marking visited cells prevents cycles ✔️ Early stopping improves performance significantly 💻 Language Used: Java ☕ 📘 Concepts: DFS · Backtracking · Matrix Traversal · Recursion #CodeEveryday #DSA #LeetCode #Java #Backtracking #DFS #ProblemSolving #Algorithms #CodingJourney #Consistency 🚀

🚀 Day 86 – DSA Journey | Path Sum in Binary Tree Continuing my daily DSA practice, today I worked on a problem that strengthened my understanding of recursion and root-to-leaf traversal. 📌 Problem Practiced: Path Sum (LeetCode 112) 🔍 Problem Idea: Determine if there exists a root-to-leaf path in a binary tree such that the sum of node values equals a given target. 💡 Key Insight: Instead of tracking the full path, we can reduce the problem by subtracting the current node’s value from the target as we traverse down the tree. 📌 Approach Used: • If the node is null → return false • Check if it is a leaf node – If yes, compare node value with remaining target • Subtract current node value from target • Recursively check left and right subtrees • If any path matches → return true 📌 Concepts Strengthened: • Tree traversal • Recursion • Root-to-leaf path logic • Problem reduction technique ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Breaking down a problem step by step (reducing the target at each node) makes recursion much more intuitive. On to Day 87! 🚀 #Day86 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🔥 DSA Challenge – Day 126/360 🚀 📌 Topic: Array + Backtracking (Recursion) 🧩 Problem: Combination Sum II Problem Statement: Find all unique combinations in an array where numbers sum up to a target. Each number can be used only once, and duplicate combinations are not allowed. 🔍 Example: Input: candidates = [10,1,2,7,6,1,5], target = 8 Output: [[1,1,6], [1,2,5], [1,7], [2,6]] 💡 Approach: Backtracking + Pruning 1️⃣ Step 1 – Sort the array to handle duplicates easily 2️⃣ Step 2 – Use recursion to pick elements and reduce target 3️⃣ Step 3 – Skip duplicates & backtrack after each recursive call 👉 Use condition to skip duplicates: if(i > ind && arr[i] == arr[i-1]) continue; 👉 Stop early if element exceeds target (pruning) ⏱ Complexity: Time: O(2^n) Space: O(k * x) (for storing combinations) 📚 Key Learning: Sorting + duplicate skipping is the key trick to avoid repeated combinations in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode