Merge branch 'main' into feat/adjacent-increasing-subarrays

Author: SjxSubham

135. Candy.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int candy(vector<int>& ratings) {
+        int n = ratings.size();
+        vector<int> count(n, 1);  // Step 1: Initialize with 1
+
+        // Step 2: Left to Right
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {
+                count[i] = count[i - 1] + 1;
+            }
+        }
+
+        // Step 3: Right to Left
+        for (int i = n - 2; i >= 0; i--) {
+            if (ratings[i] > ratings[i + 1]) {
+                count[i] = max(count[i], count[i + 1] + 1);
+            }
+        }
+
+        // Step 4: Total candies
+        return accumulate(count.begin(), count.end(), 0);
+    }
+};

199. Binary Tree Right Side View.cpp

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> rightSideView(TreeNode* root) {
+        // unordered_map<int,int>map;
+        vector<int>ans;
+        int level=-1;
+        traverseRightSide(root,level,0,ans);
+        return ans;
+    }
+    void traverseRightSide(TreeNode* root,int &mainLevel,int level, vector<int>&ans){
+        if(root==NULL) return ;
+
+        if(mainLevel<level){
+            ans.push_back(root->val);
+            mainLevel=max(mainLevel,level);
+        }
+
+        traverseRightSide(root->right,mainLevel,level+1,ans);
+        traverseRightSide(root->left,mainLevel,level+1,ans);
+    }
+};

3446. Sort Matrix by Diagonals.cpp

@@ -0,0 +1,70 @@
+class Solution {
+public:
+    vector<vector<int>> sortMatrix(vector<vector<int>>& grid) {
+        vector<vector<int>> ans;
+        vector<int> t;
+        int cnt = 1;
+        int j=0;
+        for(int i=grid.size()-1;i>=0;i--){
+            int p=i;
+            while(j < grid.size() && p < grid.size()){
+                t.push_back(grid[p][j]);
+                p++;
+                j++;
+            }
+            sort(t.begin(), t.end());
+            reverse(t.begin(), t.end());
+            ans.push_back(t);
+            t.clear();
+            j=0;
+        }
+        vector<vector<int>> a1;
+        int r = 1;
+        for(int k=1;k<grid.size();k++){
+            int q = 0;
+            int d = r;
+            while(q < grid.size() && d < grid.size()){
+                t.push_back(grid[q][d]);
+                q++;
+                d++;
+            }
+            sort(t.begin(), t.end());
+            a1.push_back(t);
+            t.clear();
+            r++;
+        }
+        for(int i=0;i<a1.size();i++){
+            ans.push_back(a1[i]);
+        }
+        j = grid.size()-1;
+        int p = 0,q=0;
+        for(int i=grid.size()-1;i>=0;i--){
+            int r = i;
+            while(q < ans[p].size()){
+                grid[r][j] = ans[p][q];
+                q++;
+                r++;
+                j++;
+            } 
+            j=0;
+            q=0;
+            p++;
+        }
+        q=0;
+        j=1;
+        r=0;
+        for(int i=1;i<grid.size();i++){
+            while(q < ans[p].size()){
+                grid[r][j] = ans[p][q];
+                q++;
+                r++;
+                j++;
+            }
+            j=i+1;
+            r=0;
+            q=0;
+            p++;
+        }
+        return grid;
+    }
+};

57. Insert Interval.cpp

@@ -0,0 +1,24 @@
+// Leetcode insert interval solution
+
+class Solution {
+public:
+    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+        intervals.emplace_back(newInterval);
+        return merge(intervals);
+    }
+
+    vector<vector<int>> merge(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end());
+        vector<vector<int>> ans;
+        ans.emplace_back(intervals[0]);
+
+        for (int i = 1; i < intervals.size(); ++i) {
+            if (ans.back()[1] < intervals[i][0]) {
+                ans.emplace_back(intervals[i]);
+            } else {
+                ans.back()[1] = max(ans.back()[1], intervals[i][1]);
+            }
+        }
+        return ans;
+    }
+};

96. Unique Binary Search Trees.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    int dp[20]{};
+    int numTrees(int n) {
+        if(n <= 1) return 1;
+        if(dp[n]) return dp[n];
+        for(int i = 1; i <= n; i++) 
+            dp[n] += numTrees(i-1) * numTrees(n-i);
+        return dp[n];
+    }
+};