LeetCode, GeeksForGeeks Problem of the day solution

class Solution { public: bool leafSimilar(TreeNode* root1, TreeNode* root2) { vector arr, brr; helper(root1, arr); helper(root2, brr); return (arr == brr); } void helper(TreeNode* node, vector& vec) { if(node == NULL) return; if(node -> left == NULL && node -> right == NULL) vec.push_back(node -> val); helper(node -> left, vec); helper(node -> right, vec); } };

class Solution { public: vector search(string pat, string txt) { vector ans; int index = txt.find(pat, 0); while (index != string::npos) { ans.push_back(index + 1); index = txt.find(pat, index + 1); } return ans; } };

class Solution { public: int sum = 0; void inorder(TreeNode* root, int L, int R){ if(root->left)inorder(root->left, L, R); if(root->val>=L && root->val<=R)sum+=root->val; if(root->right)inorder(root->right, L, R); } int rangeSumBST(TreeNode* root, int L, int R) { inorder(root, L, R); return sum; } };

class Solution { public: struct Node* reverse(Node *head) { Node *temp = NULL; Node *prev = NULL; Node *current = head; while(current != NULL) { temp = current->next; current->next = prev; prev = current; current = temp; } return prev; } struct Node * mergeResult(Node *node1,Node *node2) { if(node2==NULL) { return reverse(node1); } if(node1==NULL) { return reverse(node2); } if(node2->data>node1->data) { return mergeResult(node2,node1); } Node * curr1=node1; Node * prev1=node1; Node * curr2=node2->next; Node * prev2=node2; while(curr1!=NULL && curr2!=NULL) { if(curr1->data<=curr2->data) { curr1=curr1->next; prev2->next=prev1; prev1->next=curr2; prev2=prev1; prev1=curr1; } else if(curr1->data>curr2->data) { curr2=curr2->next; prev2=prev2->next; } } if(curr1!=NULL) { prev2->next=curr1; } return reverse(node2); } };

class Solution { public: int numberOfArithmeticSlices(vector& nums) { long long ans = 0, n = nums.size(); vector> dp(n); for (int i = 0; i < n; ++i) { for (int j = 0; j < i; ++j) { long long diff = (long long)nums[i] - (long long)nums[j]; dp[i][diff]++; if (dp[j].count(diff)) { dp[i][diff] += dp[j][diff]; ans += dp[j][diff]; } } } return ans; } };

class Solution { public: bool check(int arr[],int n,int k,int t){ int sum = 0; for(int i = 0;i<n;i++){ sum+=arr[i]; if(k == 0) return false; if(sum == t){ sum = 0; k--; } else if(sum >t){ sum = arr[i]; if(arr[i]>t) return false; k--; } } if(sum!=0 and k == 0) return false; return true; } int splitArray(int arr[] ,int N, int K) { int l = 1; int r = accumulate(arr,arr+N,0ll); int ans; while(l<=r){ int mid = l+(r-l)/2; if(check(arr,N,K,mid)){ ans = mid; r = mid-1; } else{ l = mid+1; } } return ans; } };

class Solution { public: int jobScheduling(vector& startTime, vector& endTime, vector& profit) { auto comp = [&endTime](const int i1, const int i2) { return endTime[i1] < endTime[i2]; }; int n = endTime.size(); vector index(n); iota(index.begin(), index.end(), 0); sort(index.begin(), index.end(), comp); vector endSorted(endTime.begin(), endTime.end()); sort(endSorted.begin(), endSorted.end()); vector dp(n + 1); for (int i = 1; i <= n; i++) { int j = upper_bound(endSorted.begin(), endSorted.end(), startTime[index[i-1]]) - endSorted.begin(); dp[i] = max(dp[i-1], profit[index[i-1]] + dp[j]); } return dp[n]; } };

class Solution { public: int sumOfPowers(int a, int b) { int mod = 1e9 + 7; std::vector primes(b + 1, 0); for (int i = 2; i <= b; i++) { if (primes[i] == 0) { for (int j = i; j <= b; j += i) { int count = 0; int temp = j; while (temp % i == 0) { temp /= i; count++; } primes[j] += count; } } } int result = 0; for (int i = a; i <= b; i++) { result = (result + primes[i]) % mod; } return result; } };

class Solution { public: int lengthOfLIS(vector& nums) { vector temp; temp.push_back(nums[0]); for(int i=1;i

class Solution{ int mod = 1e9 + 7; public: int TotalWays(int N) { long long prev1 = 1, prev2 = 1; for(int i = 1; i <= N; i++) { long long curr = (prev1 + prev2) % mod; prev2 = prev1; prev1 = curr; } return (prev1 * prev1) % mod; } };