LeetCode, GeeksForGeeks Problem of the day solution

class Solution { public: vector<int> fullBloomFlowers(vector<vector<int>>& flowers, vector<int>& people) { vector<int>ans(people.size(),0); sort(flowers.begin(),flowers.end()); vector<pair<int,int>>p; for(int i=0;i<people.size();i++){ p.push_back({people[i],i}); } sort(p.begin(),p.end()); int j=0; int cnt=0; priority_queue<int,vector<int>,greater<int>>q; for(auto i:p){ int ele=i.first; while(j<flowers.size() && flowers[j][0]<=ele){ q.push(flowers[j][1]); j++; } while(!q.empty() && q.top()<ele){ q.pop(); } ans[i.second]=q.size(); } return ans; } };

class Solution{ public: //Function to check whether a binary tree is balanced or not. pair isBalancedFast(Node* root){ if(root==NULL){ pair p = make_pair(true,0); return p; } pair left = isBalancedFast(root->left); pair right = isBalancedFast(root->right); bool op1 = left.first; bool op2 = right.first; bool op3 = abs(left.second - right.second) <= 1; pair ans; if(op1 && op2 && op3){ ans.first = true; } else{ ans.first = false; } ans.second = max(left.second , right.second) + 1; return ans; } bool isBalanced(Node *root) { return isBalancedFast(root).first; } };

class Solution { public: int minOperations(vector& nums) { if(nums.size()==1) return 0; sort(nums.begin(),nums.end()); int actual=nums.size(); nums.erase(unique(begin(nums),end(nums)),end(nums)); int mini=INT_MAX; for(int i=0;i

class Solution { private: public: void atLevelK(Node* root, int k, vector &ans){ if(root){ if(k==0) ans.push_back(root->data); atLevelK(root->left,k-1,ans); atLevelK(root->right,k-1,ans); } } int helper(Node* root, int k, vector &ans, int target, bool &t){ if(root==NULL) return -1; if(!t and root->data==target){ atLevelK(root,k,ans); t = true; return 1; } int l = helper(root->left,k,ans,target,t); int r = helper(root->right,k,ans,target,t); if(l==-1 and r==-1) return -1; else if(r==-1){ if(k-l==0){ ans.push_back(root->data); return -1; } else atLevelK(root->right,k-l-1,ans); return l+1; } else{ if(k-r==0){ ans.push_back(root->data); return -1; } else atLevelK(root->left,k-r-1,ans); return r+1; } } public: vector KDistanceNodes(Node* root, int target , int k){ vector ans; bool t = false; helper(root,k, ans,target,t); sort(ans.begin(),ans.end()); return ans; } };

class Solution { public: vector<int> searchRange(vector<int>& nums, int target) { int num1 = -1; int num2 = -1; int s=0; int e=nums.size()-1; while(s<=e){ int mid = s+(e-s)/2; if(nums[mid]==target){ num1 = mid; e--; } else if(nums[mid]>target){ e = mid-1; } else{ s = mid+1; } } s=0; e=nums.size()-1; while(s<=e){ int mid = s+(e-s)/2; if(nums[mid]==target){ num2 = mid; s++; } else if(nums[mid]>target){ e = mid-1; } else{ s = mid+1; } } return {num1, num2}; } };

class Solution{ public: //Function to find the height of a binary tree. int height(struct Node* node){ if(node==NULL){ return 0; } return 1+max(height(node->left), height(node->right)); } };

class Solution { public: int maxDotProduct(vector& nums1, vector& nums2) { vector>> v(2, vector> (nums1.size(), vector(nums2.size(), INT_MAX))); return dfs(nums1, nums2, 0, 0, v, false); } int dfs(vector& nums1, vector& nums2, int i, int y, vector>>& v, bool isGood){ if (i == nums1.size() || y == nums2.size()) return isGood ? 0 : INT_MIN; if (v[isGood][i][y] != INT_MAX) return v[isGood][i][y]; v[isGood][i][y] = nums1[i] * nums2[y] + dfs(nums1, nums2, i + 1, y + 1, v, true); int s = dfs(nums1, nums2, i + 1, y, v, isGood); int t = dfs(nums1, nums2, i, y + 1, v, isGood); return v[isGood][i][y] = max(v[isGood][i][y], max(s, t)); } };

class Solution{ public: // Should return head of the modified linked list Node *sortedInsert(struct Node* head, int data) { Node * newnode= new Node(data); newnode->next = head; Node* temp = newnode; if(head->data >= data){ head = newnode; } else{ while(temp!=NULL and temp->next!=NULL and temp->next->data <= data){ temp = temp->next; } newnode->next=temp->next; temp->next = newnode; } return head; } };

class Solution { public: int dp[51][101][51]; int solve(int index , int biggest , int cost ,int n ,int k ,int m) { if(index == n) return cost == k; if( cost > k or k-cost > m - biggest or k-cost > n -index) return 0; if(dp[index][biggest][cost] != -1) return dp[index][biggest][cost]; int res= 0; for(int i= 1 ; i<= m ; i++) res = (res + solve(index+1 , max(biggest , i) , i>biggest? cost + 1 : cost,n,k,m))%1000000007; return dp[index][biggest][cost] = res; } int numOfArrays(int n, int m, int k) { memset(dp , -1 , sizeof(dp)); return solve(0, 0 , 0 ,n ,k ,m); } };

class Solution { public: Node* pairWiseSwap(struct Node* head) { Node*prev=NULL; Node*curr=head; Node*forward=NULL; int cnt=0; while(curr!=NULL && cnt<2){ forward=curr->next; curr->next=prev; prev=curr; curr=forward; cnt++; } if(forward!=NULL){ head->next=pairWiseSwap(forward); } return prev; } };