Merge branch 'main' into 23

Author: SjxSubham

124. Binary Tree Maximum Path Sum.cpp

@@ -0,0 +1,31 @@
+
+
+class Solution {
+public:
+    long long minCost(vector<int>& basket1, vector<int>& basket2) {
+        unordered_map<int,int> freq;
+        for (int x : basket1) freq[x]++;
+        for (int x : basket2) freq[x]--;
+
+        vector<int> extra1, extra2;
+        int minFruit = INT_MAX;
+
+        // Collect unbalanced fruits
+        for (auto [fruit, diff] : freq) {
+            minFruit = min(minFruit, fruit);
+            if (diff % 2 != 0) return -1; // impossible to balance
+            int count = abs(diff) / 2;
+            if (diff > 0) while (count--) extra1.push_back(fruit);
+            else while (count--) extra2.push_back(fruit);
+        }
+
+        sort(extra1.begin(), extra1.end());
+        sort(extra2.rbegin(), extra2.rend());
+
+        long long cost = 0;
+        for (int i = 0; i < extra1.size(); ++i) {
+            cost += min((long long)min(extra1[i], extra2[i]), 2LL * minFruit);
+        }
+        return cost;
+    }
+};

2561. Rearranging Fruits.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int j = 0;
+        for(int i = 0; i < nums.size(); i++) {
+            if(nums[i] != 0) nums[j++] = nums[i];
+        }
+        while(j < nums.size()) nums[j++] = 0;
+    }
+};

283. Move Zeroes.cpp

@@ -0,0 +1,12 @@
+// Includes Soln to 292. Nim Game Problem
+// Using trial and error it can be found that you can win the game for any n less than 4 or if n is not divisible by 4
+// This code uses the simple observation to solve the problem
+
+
+class Solution {
+public:
+    bool canWinNim(int n) {
+        if (n<=3 || n%4!=0) return true;
+        return false;
+    }
+};

292.NimGame.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    bool hasSameDigits(string s) {
+        while(s.length() > 2){
+            string temp = "";
+            for(int i = 0; i < s.length()-1; i++){
+                int a = s[i] - '0';
+                int b = s[i + 1] - '0';
+                temp.push_back(((a + b) % 10) + '0');
+            }
+            s = temp;
+        }
+        return s.length() && s[0] == s[1];
+    }
+};

3461. Check If Digits Are Equal in String After Operations I.cpp

@@ -0,0 +1,44 @@
+/* Approach
+
+We use exponentiation by squaring to efficiently compute x^n:
+
+Handle base cases:
+
+If n == 0, return 1.
+If x == 0, return 0 (unless n is 0).
+Handle negative powers:
+
+If n < 0, compute x^{-n} by inverting x (x = 1/x) and making n positive.
+For positive powers:
+
+If n is even: x^n = (x^(n/2)) * (x^(n/2))
+If n is odd: x^n = x * (x^(n-1))
+Implement iteratively to avoid recursion stack overflow for large n:
+
+While n > 0:
+If n is odd, multiply result by x.
+Square x and divide n by 2.
+Return the accumulated result. */
+
+    class Solution {
+public:
+    double myPow(double x, int n) {
+        long long N = n;      // Convert to long long to handle INT_MIN
+        if (N < 0) {          // Handle negative powers
+            x = 1 / x;
+            N = -N;
+        }
+
+        double result = 1.0;
+        while (N > 0) {
+            if (N % 2 == 1) {   // If the current power is odd
+                result *= x;
+            }
+            x *= x;             // Square x
+            N /= 2;        
+        }
+
+        return result;
+    }
+};
+    

50.Pow(x,n).cpp

@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+    void solve(int col, int n, vector<string> &board, 
+               vector<vector<string>> &ans, 
+               vector<int> &leftrow, vector<int> &upperdiag, vector<int> &lowerdiag) {
+        
+        if (col == n) {
+            ans.push_back(board);
+            return;
+        }
+
+        for (int row = 0; row < n; row++) {
+            if (leftrow[row] == 0 && lowerdiag[row + col] == 0 && upperdiag[(n - 1) + (col - row)] == 0) {
+                
+                board[row][col] = 'Q';
+                leftrow[row] = 1;
+                lowerdiag[row + col] = 1;
+                upperdiag[(n - 1) + (col - row)] = 1;
+
+                solve(col + 1, n, board, ans, leftrow, upperdiag, lowerdiag);
+
+                board[row][col] = '.';  // backtrack
+                leftrow[row] = 0;
+                lowerdiag[row + col] = 0;
+                upperdiag[(n - 1) + (col - row)] = 0;
+            }
+        }
+    }
+
+    vector<vector<string>> solveNQueens(int n) {
+        vector<vector<string>> ans;
+        vector<string> board(n, string(n, '.'));
+
+        vector<int> leftrow(n, 0);
+        vector<int> lowerdiag(2 * n - 1, 0);
+        vector<int> upperdiag(2 * n - 1, 0);
+
+        solve(0, n, board, ans, leftrow, upperdiag, lowerdiag);
+        return ans;
+    }
+};