Merge branch 'main' into 1857_Largest_Color_Value_in_a_Directed_Graph

SjxSubham · web-flow · commit b819ba0904e8 · 2025-10-29T09:31:37.000+05:30
diff --git a/1094.Car Pooling.cpp b/1094.Car Pooling.cpp
@@ -0,0 +1,30 @@
+class Solution {
+public:
+    bool carPooling(vector<vector<int>>& trips, int capacity) {
+        vector<pair<int,int>> pickups;
+        priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> drops;
+        pickups.reserve(trips.size());
+        for (auto &t : trips){
+            pickups.emplace_back(t[1], t[0]);
+            drops.push({t[2], t[0]});
+        }
+        sort(pickups.begin(), pickups.end());
+        int i = 0, curr = 0;
+        while (!drops.empty()){
+            int nextDrop = drops.top().first;
+            while (i < (int)pickups.size() && pickups[i].first < nextDrop){
+                curr += pickups[i].second;
+                if (curr > capacity) return false;
+                ++i;
+            }
+            curr -= drops.top().second;
+            drops.pop();
+        }
+        while (i < (int)pickups.size()){
+            curr += pickups[i].second;
+            if (curr > capacity) return false;
+            ++i;
+        }
+        return true;
+    }
+};
diff --git a/123. Best time to buy or sell stock iii .cpp b/123. Best time to buy or sell stock iii .cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& a) {
+        int n = a.size();
+        vector<vector<vector<int>>> dp(n+1, vector<vector<int>>(2, vector<int>(3, 0)));
+        for(int i=n-1;i>=0;i--)
+        {
+            for(int buy=1;buy>=0;buy--)
+            {
+                for(int cap=1;cap<=2;cap++)
+                {
+                    if (buy) {
+                        // Either buy now, or skip
+                        dp[i][buy][cap] = max(-a[i] + dp[i+1][0][cap],dp[i+1][1][cap]);
+                    } else {
+                        // Either sell now, or skip
+                        dp[i][buy][cap] = max(a[i] +dp[i+1][1][cap-1], dp[i+1][0][cap]);
+                    }
+                }
+            }
+        }
+        return dp[0][1][2];
+    }
+};
diff --git a/23. Merge k Sorted Lists.cpp b/23. Merge k Sorted Lists.cpp
@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        ListNode* res = new ListNode(0);
+        ListNode* temp = res;
+
+        priority_queue<int, vector<int>, greater<int>> minHeap;
+
+        for (auto l : lists) {
+            while (l != nullptr) {
+                minHeap.push(l->val);
+                l = l->next;
+            }
+        }
+
+        while (!minHeap.empty()) {
+            int num = minHeap.top();
+            minHeap.pop();
+
+            temp->next = new ListNode(num);
+            temp = temp->next;
+        }
+
+        return res->next;
+    }
+};
diff --git a/231. Power of Two.cpp b/231. Power of Two.cpp
@@ -0,0 +1,7 @@
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+        if (n <= 0) return false;
+        return (n & (n - 1)) == 0;
+    }
+};
diff --git a/242. Valid Anagram.cpp b/242. Valid Anagram.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        if(s.length() != t.length()) return false;
+        
+        int count[26] = {0};
+        
+        for(int i = 0; i < s.length(); i++) {
+            count[s[i]-'a']++;
+            count[t[i]-'a']--;
+        }
+        
+        for(int i = 0; i < 26; i++) {
+            if(count[i] != 0) return false;
+        }
+        
+        return true;
+    }
+};
diff --git a/2561. Rearranging Fruits.cpp b/2561. Rearranging Fruits.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;
+    }
+};
diff --git a/26. Remove Duplicates from Sorted Array.cpp b/26. Remove Duplicates from Sorted Array.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        if (nums.empty()) return 0;
+        int j = 0;
+        for (int i = 1; i < nums.size(); i++) {
+            if (nums[i] != nums[j]) {
+                j++;
+                nums[j] = nums[i];
+            }
+        }
+        return j + 1;
+    }
+};
diff --git a/283. Move Zeroes.cpp b/283. Move Zeroes.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;
+    }
+};
diff --git a/292.NimGame.cpp b/292.NimGame.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;
+    }
+};
diff --git a/3068. Find the Maximum Sum of Node Values.cpp b/3068. Find the Maximum Sum of Node Values.cpp
@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Definition for a binary tree node
+struct Node {
+    int data;
+    Node* left;
+    Node* right;
+    Node(int val) {
+        data = val;
+        left = right = nullptr;
+    }
+};
+
+class Solution {
+    int maxSum; // Global maximum sum
+    // Helper function to compute maximum gain from a node
+    int findMaxPath(Node* root) {
+        if (!root) return 0;
+
+        int leftGain = max(0, findMaxPath(root->left));  // Max path sum from left
+        int rightGain = max(0, findMaxPath(root->right)); // Max path sum from right
+
+        // Update global maximum including current node
+        maxSum = max(maxSum, leftGain + rightGain + root->data);
+
+        // Return max gain including current node for recursion
+        return root->data + max(leftGain, rightGain);
+    }
+
+public:
+    int maxPathSum(Node* root) {
+        maxSum = INT_MIN;
+        findMaxPath(root);
+        return maxSum;
+    }
+};
+
+// Example usage
+int main() {
+    /*
+         10
+        /  \
+       2   10
+      / \    \
+     20  1   -25
+              /  \
+             3    4
+    Expected Output: 42 (20 + 2 + 10 + 10)
+    */
+
+    Node* root = new Node(10);
+    root->left = new Node(2);
+    root->right = new Node(10);
+    root->left->left = new Node(20);
+    root->left->right = new Node(1);
+    root->right->right = new Node(-25);
+    root->right->right->left = new Node(3);
+    root->right->right->right = new Node(4);
+
+    Solution sol;
+    cout << "Maximum Path Sum: " << sol.maxPathSum(root) << endl;
+
+    return 0;
+}
diff --git a/3461. Check If Digits Are Equal in String After Operations I.cpp b/3461. Check If Digits Are Equal in String After Operations I.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];
+    }
+};
diff --git a/3720. Lexicographically Smallest Permutation Greater Than Target.cpp b/3720. Lexicographically Smallest Permutation Greater Than Target.cpp
@@ -0,0 +1,48 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Solution {
+public:
+    string lexGreaterPermutation(string s, string target) {
+        string ans ="";
+        int n = s.length();
+        map<char,int>mp;
+        for(auto&e:s)mp[e]++;
+        for(int i =0;i<n;i++)
+            {
+                map<char,int> m2=mp;
+                string res ="";
+                bool ip=1;
+                for(int j = 0;j<i;j++)
+                    {
+                        char e=target[j];
+                        if(!m2.count(e))
+                        {
+                            ip=0;
+                            break;
+                        }
+                        res+=e;
+                        m2[e]--;
+                        if(m2[e]==0)m2.erase(e);
+                    }
+                if(ip)
+                {
+                            char e = target[i];
+                            auto it = m2.upper_bound(e);
+                            if(it!=m2.end())
+                            {
+                                res+=it->first;
+                                it->second--;
+                                if(it->second==0)m2.erase(it);
+                            }
+                    else continue;
+                    for(auto&e:m2)
+                        {
+                            while(e.second--)res+=e.first;
+                        }
+                    if(ans =="")ans=res;
+                    else ans = min(ans,res);
+                }
+            }
+        return ans;
+    }
+};
diff --git a/50.Pow(x,n).cpp b/50.Pow(x,n).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;
+    }
+};
+    
diff --git a/51.N-Queens.cpp b/51.N-Queens.cpp
diff --git a/99.Maximize the Number of Target Nodes After Connecting Trees.cpp b/99.Maximize the Number of Target Nodes After Connecting Trees.cpp
