merge change

Author: JenilGajjar20

Diff for: .DS_Store

@@ -0,0 +1,27 @@
+# N-Queens
+
+## Problem Description
+The **N-Queens** puzzle requires placing `n` queens on an `n x n` chessboard such that no two queens threaten each other. A queen can attack any piece in the same row, column, or diagonal. 
+
+Given an integer `n`, the task is to find all distinct solutions to the N-Queens puzzle. Each solution should be represented as a distinct board configuration where `'Q'` denotes a queen, and `'.'` denotes an empty square.
+
+## Objective
+Return all possible configurations of the N-Queens puzzle in any order, where each configuration is a list of strings representing the chessboard.
+
+---
+
+### Constraints
+- `1 <= n <= 9`
+
+### Example
+**Input**
+```plaintext
+n = 4
+```
+
+
+**Output**
+```plaintext
+[[".Q..","...Q","Q...","..Q."],
+ ["..Q.","Q...","...Q",".Q.."]]
+```

Diff for: Cpp/.DS_Store

@@ -0,0 +1,51 @@
+class Solution {
+public:
+    // Recursive function to place queens row by row
+    void rec(int r, int n, vector<string>& ve, vector<pair<int, int>>& queens, vector<vector<string>>& out) {
+        // Base case: if we've placed queens in all rows, add current board configuration to output
+        if (r == n) {
+            out.push_back(ve);
+            return;
+        }
+        
+        // Try placing a queen in each column of the current row
+        for (int c = 0; c < n; c++) {
+            bool poss = true; 
+            
+            // Check against previously placed queens to see if (r, c) is a valid position
+            for (auto& p : queens) {
+                int xr = p.first;
+                int xc = p.second;
+                
+                // A queen can attack if in the same row, column, or diagonal
+                if (xr == r || xc == c || abs(xr - r) == abs(xc - c)) {
+                    poss = false; 
+                    break;
+                }
+            }
+            
+            // If (r, c) is not a valid position, skip to the next column
+            if (!poss) continue;
+            
+            // Place the queen at (r, c) and mark it on the board
+            queens.push_back({r, c});
+            ve[r][c] = 'Q';
+            
+            // Recurse to the next row to place the next queen
+            rec(r + 1, n, ve, queens, out);
+            
+            // Backtrack: remove the queen from (r, c) and unmark it on the board
+            ve[r][c] = '.';
+            queens.pop_back();
+        }
+    }
+
+    // Main function to initiate the N-Queens solution finding
+    vector<vector<string>> solveNQueens(int n) {
+        vector<vector<string>> out;   
+        vector<string> ve(n, string(n, '.'));
+        vector<pair<int, int>> queens;
+        rec(0, n, ve, queens, out);
+        return out;
+    }
+};

Diff for: Cpp/0051-N-Queen-I/problem.md

@@ -0,0 +1,40 @@
+# N-Queens II
+
+## Problem Description
+The **N-Queens puzzle** is the problem of placing `n` queens on an `n x n` chessboard so that no two queens can attack each other (no same row, column, or diagonal). This variation of the problem, N-Queens II, requires counting the number of distinct solutions rather than returning each configuration.
+
+Given an integer `n`, return the number of unique ways to arrange the queens on the chessboard.
+
+## Objective
+Return the count of all valid configurations for the N-Queens puzzle, where each configuration ensures that no two queens attack each other.
+
+---
+
+### Constraints
+- `1 <= n <= 9`
+
+### Examples
+
+**Example 1**
+
+**Input**
+```plaintext
+n = 4
+```
+
+**Output**
+```plaintext
+2
+```
+
+**Example 2**
+
+**Input**
+```plaintext
+n = 1
+```
+
+**Output**
+```plaintext
+1
+```

Diff for: Cpp/0051-N-Queen-I/solution.cpp

@@ -0,0 +1,47 @@
+class Solution {
+public:
+    // Recursive function to count valid queen placements row by row
+    int rec(int r, int n, vector<pair<int, int>>& queens) {
+        // Base case: if all queens are placed, count this configuration as valid
+        if (r == n) return 1;
+        
+        int ans = 0;
+
+        // Try placing a queen in each column of the current row
+        for (int c = 0; c < n; c++) {
+            bool poss = true;
+            
+            // Check against previously placed queens to see if (r, c) is a valid position
+            for (auto& p : queens) {
+                int xr = p.first;
+                int xc = p.second;
+                
+                // A queen can attack if in the same row, column, or diagonal
+                if (xr == r || xc == c || abs(xr - r) == abs(xc - c)) {
+                    poss = false;
+                    break;
+                }
+            }
+
+            // If (r, c) is not a valid position, skip to the next column
+            if (!poss) continue;
+
+            // Place the queen at (r, c) and mark it in the queens vector
+            queens.push_back({r, c});
+            
+            // Recurse to the next row to continue placing queens
+            ans += rec(r + 1, n, queens);
+            
+            // Backtrack: remove the queen from (r, c)
+            queens.pop_back();
+        }
+        
+        return ans; 
+    }
+
+    // Main function to initiate the N-Queens solution count
+    int totalNQueens(int n) {
+        vector<pair<int, int>> queens; 
+        return rec(0, n, queens); 
+    }
+};

Diff for: Cpp/0052-N-Queen-II/problem.md

@@ -0,0 +1,26 @@
+# [136. Single Number](https://leetcode.com/problems/single-number/)
+
+<div class="elfjS" data-track-load="description_content"><p>Given a <strong>non-empty</strong>&nbsp;array of integers <code>nums</code>, every element appears <em>twice</em> except for one. Find that single one.</p>
+
+<p>You must&nbsp;implement a solution with a linear runtime complexity and use&nbsp;only constant&nbsp;extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1]
+<strong>Output:</strong> 1
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [4,1,2,1,2]
+<strong>Output:</strong> 4
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
+	<li>Each element in the array appears twice except for one element which appears only once.</li>
+</ul>
+</div>

Diff for: Cpp/0052-N-Queen-II/solution.cpp

@@ -0,0 +1,20 @@
+class Solution
+{
+public:
+    int singleNumber(vector<int> &nums)
+    {
+        // Initialize a variable `xorr` to 0, which will be used to store the XOR result.
+        int xorr = 0;
+
+        // Iterate through each element in the array `nums`.
+        for (int i = 0; i < nums.size(); i++)
+        {
+            // Apply XOR operation between `xorr` and the current element `nums[i]`.
+            // This will cancel out all elements that appear twice and leave only the single element.
+            xorr = xorr ^ nums[i];
+        }
+
+        // Return the remaining element, which is the single element that does not have a duplicate.
+        return xorr;
+    }
+};

Diff for: Cpp/0136-Single-Number/Problem.md

@@ -0,0 +1,35 @@
+<h1><a href = "https://leetcode.com/problems/house-robber-ii/description/">213. House Robber II</h1>
+
+## Problem Statement
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have a security system connected, and it will automatically contact the police if two adjacent houses are broken into on the same night.
+
+Given an integer array `nums` representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre>
+<strong>Input: </strong> nums = [2,3,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), 
+because they are adjacent houses.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<pre>
+<strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3). 
+Total amount you can rob = 1 + 3 = 4.
+</pre>
+  
+<p><strong class="example">Example 3:</strong></p>
+<pre>
+<strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 3
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+- `1 <= nums.length <= 100`
+- `0 <= nums[i] <= 1000`

Diff for: Cpp/0136-Single-Number/Solution.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        int n = nums.size();
+        
+        // Handle edge cases
+        if (n == 0) return 0; // No houses
+        if (n == 1) return nums[0]; // Only one house
+
+        // Helper function to calculate max loot for a linear array
+        auto robLinear = [](const vector<int>& nums, int start, int end) {
+            int prev1 = 0, prev2 = 0; // Initialize previous two max values
+            for (int i = start; i < end; ++i) {
+                int pick = nums[i] + prev1; // Value if we pick current house
+                int notPick = prev2; // Value if we do not pick current house
+                int curr = max(pick, notPick); // Max of both options
+                prev1 = prev2; // Update previous for the next iteration
+                prev2 = curr;
+            }
+            return prev2; // Return the maximum value obtained
+        };
+
+        // Rob houses excluding the last house and then excluding the first house
+        int maxLoot1 = robLinear(nums, 0, n - 1); // From house 0 to house n-2
+        int maxLoot2 = robLinear(nums, 1, n); // From house 1 to house n-1
+
+        // Return the maximum of both scenarios
+        return max(maxLoot1, maxLoot2);
+    }
+};

Diff for: Cpp/0213-house-robber-II/problem.md

@@ -0,0 +1,32 @@
+# Merge k Sorted Lists
+
+## Problem Statement
+
+You are given an array of `k` linked-lists, each linked-list is sorted in ascending order.
+
+Merge all the linked-lists into one sorted linked-list and return it.
+
+## Example
+
+**Input:**
+```plaintext
+[
+  1 -> 4 -> 5,
+  1 -> 3 -> 4,
+  2 -> 6
+]
+```
+
+**Output:**
+```
+1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6
+```
+
+## Constraints
+
+- `k == lists.length`
+- `0 <= k <= 10^4`
+- `0 <= lists[i].length <= 500`
+- `-10^4 <= lists[i][j] <= 10^4`
+- `lists[i]` is sorted in ascending order.
+- The sum of `lists[i].length` will not exceed `10^4`.

Diff for: Cpp/0213-house-robber-II/solution.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+// Definition for singly-linked list.
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+struct Compare {
+    bool operator()(ListNode *a, ListNode *b) {
+        return a->val > b->val; // Min-heap based on the value
+    }
+};
+
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        priority_queue<ListNode*, vector<ListNode*>, Compare> minHeap;
+        
+        // Push the head of each list into the min heap
+        for (ListNode* list : lists) {
+            if (list) {
+                minHeap.push(list);
+            }
+        }
+        
+        ListNode dummy(0);
+        ListNode* tail = &dummy;
+
+        while (!minHeap.empty()) {
+            // Get the smallest node from the heap
+            ListNode* smallestNode = minHeap.top();
+            minHeap.pop();
+            tail->next = smallestNode;
+            tail = tail->next; // Move the tail
+
+            // If there's a next node, push it into the heap
+            if (smallestNode->next) {
+                minHeap.push(smallestNode->next);
+            }
+        }
+
+        return dummy.next; // Return the merged list
+    }
+};

Diff for: Cpp/023-Merge-k-Sorted-Lists/problem.md

@@ -0,0 +1,11 @@
+A boolean expression is an expression that evaluates to either true or false, and it can have the following forms:
+
+1. `'t'`: evaluates to true.
+2. `'f'`: evaluates to false.
+3. `'!(subExpr)'`: evaluates to the logical NOT of the inner expression `subExpr`.
+4. `'&(subExpr1, subExpr2, ..., subExprn)'`: evaluates to the logical AND of the inner expressions `subExpr1, subExpr2, ..., subExprn`, where `n >= 1`.
+5. `'|(subExpr1, subExpr2, ..., subExprn)'`: evaluates to the logical OR of the inner expressions `subExpr1, subExpr2, ..., subExprn`, where `n >= 1`.
+
+Given a string `expression` that represents a boolean expression, return its evaluation. It is guaranteed that the expression is valid and follows the rules described above.
+
+---