วีดีโอ

Amazing lecture Bhaiya

I have always learned everything by myself through documentation and solving questions, such as HTML, CSS, JavaScript, and Java basic. I never learned from TH-cam because the long, boring lectures didn’t match my vibe or understanding, and they lacked real-world examples for each topic. However, I heard from my peers on LinkedIn that this is a great channel for learning and it is... after saw his explaination on array video. I'm currently started C++ Journey from basic to advanced!

Radhe Radhe

❤

Last tk

This Single video is enough for stack

Chamak gaiya ❤

SOLUTION FOR MERGE TWO BST USING STACK: class Solution { public: // Function to return a list of integers denoting the node // values of both the BST in a sorted order. void fill(Node*root,stack<Node*>&s){ if(!root) return NULL; s.push(root); fill(root->left,s); } vector<int> merge(Node *root1, Node *root2) { stack<Node*>s1; stack<Node*>s2; vector<int>ans; fill(root1,s1); fill(root2,s2); while(!s1.empty() && !s2.empty()){ if(s1.top()->data<s2.top()->data){ ans.push_back(s1.top()->data); Node*temp=s1.top()->right; s1.pop(); fill(temp,s1); } else if(s1.top()->data>s2.top()->data){ ans.push_back(s2.top()->data); Node*temp=s2.top()->right; s2.pop(); fill(temp,s2); } else{ ans.push_back(s1.top()->data); ans.push_back(s2.top()->data); Node*temp1=s1.top()->right; Node*temp2=s2.top()->right; s1.pop(); s2.pop(); fill(temp1,s1); fill(temp2,s2); } } while(!s1.empty()){ ans.push_back(s1.top()->data); Node*temp=s1.top()->right; s1.pop(); fill(temp,s1); } while(!s2.empty()){ ans.push_back(s2.top()->data); Node*temp=s2.top()->right; s2.pop(); fill(temp,s2); } return ans; } };

❤❤

now the mathematical proof shines like sun.. 🌞

Day 29 completed [ 22/12/2024; 2250 IST].

Day 30 completed [ 23/12/2024; 1442 IST].

excellent

Bro thanks

Best video of dp

Common sense++

Thanks bro🙏🙏

alhamdulillah lec done awesome vaiya

whole video is best!!

Chamak gya❤

Chamak diya

Day 4

Common sense ++++

graph++😍😍

First Question can be done using 2 loops only for(int row=1;row<=n;row++) { for(int col=1;col<=n;col++) { if(col<=n-row) { cout << " "; }else { cout << "* "; } } cout << endl; }

Bhaiya pura code kiya kijiye hmm samajh nahi pate hai

Full stack web development kra do bhaiya.hum ap ky intezar ma bethy han 😢.

sir aap ke akhri alfazo ne sad kr diya

This lecture is Sooooooooooooooooooooooooooooooooooooooooooooooo good and really incredible.

Finally I understand dynamic and static memory allocation.Thank you sir .❤❤❤❤❤

Great sir❤❤❤❤

Day 3

SOLUTION FOR PROBLEM 3: class Solution{ public: void BST(Node*root,stack<int>&lower,stack<int>&upper,bool&check){ if(!root) return ; if(root->data>lower.top() && root->data<upper.top()){ upper.push(root->data); } if(!root->left && !root->right){ if(upper.top()-lower.top()==1){ lower.push(upper.top()); upper.pop(); if(upper.top()-lower.top()==1) check=true; upper.push(lower.top()); lower.pop(); } } BST(root->left,lower,upper,check); lower.push(upper.top()); upper.pop(); BST(root->right,lower,upper,check); } bool isDeadEnd(Node *root) { stack<int>lower; stack<int>upper; lower.push(0); upper.push(INT_MAX); bool check=false; BST(root,lower,upper,check); return check; } };

Love from Pakistan bro... Complete Pakistan watching educational videos of Indian youtubers

47:50 Rotated By 1(New Approach) => Time complexity of the rotation algorithm is O(n), and the space complexity is O(1). public class Main { public static void rev(int[] arr, int s, int e){ while(s < e){ int t = arr[s]; arr[s] = arr[e]; arr[e] = t; s++; e--; } } public static void printArr(int[] a){ for(int e : a){ System.out.print(e + " "); } } public static void main(String[] args) { int a[] = {2,7,4,11,5,8}; System.out.println("Without Rotation: "); printArr(a); int roteteBy = 1; rev(a, 0, a.length-roteteBy-1); rev(a, a.length-roteteBy, a.length-1); rev(a, 0, a.length-1); System.out.println(); System.out.println("After Rotation: "); printArr(a); } }

Ha bhai ye concept aashe se samajh me aagaya. It was really amazing. I am getting a lot from your these series+

22 dec'24

Radhe Radhe 🕉️🦚

Chamak gya ✨✨✨

SOLUTION FOR LCA: class Solution{ public: Node* LCA(Node *root, int n1, int n2) { Node*lowest; while(root->data!=n1 || root->data!=n2){ lowest=root; if(root->data<n1 && root->data<n2) root=root->right; else if(root->data>n1 && root->data>n2) root=root->left; else return lowest; } return root; } };

This is really great stack series. Thank you bhaiya❤

Thanks sir❤

solution of the lecture end H.W:- class Solution { public: // Function to sort a linked list of 0s, 1s and 2s. Node* segregate(Node* head) { Node *head0 = NULL,*tail0 = NULL; Node *head1 = NULL,*tail1 = NULL; Node *head2 = NULL,*tail2 = NULL; while(head) { if(head->data == 0) { if(head0 == NULL) { head0 = new Node(head->data); tail0 = head0; } else { Node *temp; temp = new Node(head->data); tail0->next = temp; tail0 = temp; } } else if(head->data == 1) { if(head1 == NULL) { head1 = new Node(head->data); tail1 = head1; } else { Node *temp; temp = new Node(head->data); tail1->next = temp; tail1 = temp; } } else { if(head2 == NULL) { head2 = new Node(head->data); tail2 = head2; } else { Node *temp; temp = new Node(head->data); tail2->next = temp; tail2 = temp; } } head = head->next; } if(head0) { if(head1) { tail0->next = head1; if(head2) { tail1->next = head2; } } else { tail0->next = head2; } return head0; } else if(head1) { tail1->next = head2; return head1; } return head2; } };

SOLUTION FOR QUESTION NO. 3 USING STACK: class Solution { public: int canRepresentBST(int arr[], int N) { stack<int>lower; stack<int>upper; lower.push(INT_MIN); upper.push(INT_MAX); int index=0; while(index<N && !lower.empty() && !upper.empty()){ if(arr[index]>lower.top() && arr[index]<upper.top()){ upper.push(arr[index++]); } else{ lower.push(upper.top()); upper.pop(); } } if(index==N) return 1; else return 0; } };

int count(int i,int n){ if(i==n) return 1; if(i>n) return 0; return count(i+1,n) + count(i+2,n) + count(i+3,n); } // Function to count the number of ways in which frog can reach the top. int countWays(int n) { // your code here return count(0,n); }

//Bruteforce Approach class Solution { public ArrayList<Integer> maxOfMin(int[] arr) { ArrayList<Integer> result = new ArrayList<>(); for (int windowSize = 1; windowSize <= arr.length; windowSize++) { result.add(maxOfMinInWindow(windowSize, arr)); } return result; } private int maxOfMinInWindow(int k, int[] arr) { int maxOfMin = Integer.MIN_VALUE; // Iterate over all possible windows of size k for (int i = 0; i <= arr.length - k; i++) { int currentMin = Integer.MAX_VALUE; // Find the minimum in the current window for (int j = i; j < i + k; j++) { currentMin = Math.min(currentMin, arr[j]); } // Update the maximum of the minimums maxOfMin = Math.max(maxOfMin, currentMin); } return maxOfMin; } } //Better Approach (Using monotonic increasing deque) class Solution { public ArrayList<Integer> maxOfMin(int[] arr) { ArrayList<Integer> result = new ArrayList<>(); for (int windowSize = 1; windowSize <= arr.length; windowSize++) { result.add(maxOfMinInWindow(windowSize, arr)); } return result; } private int maxOfMinInWindow(int k, int[] arr) { Deque<Integer> deque = new ArrayDeque<>(); int maxOfMin = Integer.MIN_VALUE; // Process the first window separately for (int i = 0; i < k; i++) { // Maintain a monotonic increasing deque where the smallest element is always at the front while (!deque.isEmpty() && arr[deque.peekLast()] >= arr[i]) { deque.pollLast(); } deque.offerLast(i); } // The front of the deque is the minimum of the 1st window maxOfMin = Math.max(maxOfMin, arr[deque.peekFirst()]); // Process the remaining windows for (int windowEndIndex = k; windowEndIndex < arr.length; windowEndIndex++) { // Maintain the deque for the current window while (!deque.isEmpty() && arr[deque.peekLast()] >= arr[windowEndIndex]) { deque.pollLast(); } deque.offerLast(windowEndIndex); // Remove element from the deque if the maximum no longer belongs to the current window, i.e., it belongs to the previous window. if (!deque.isEmpty() && deque.peekFirst() <= windowEndIndex - k) { deque.pollFirst(); } // The front of the deque is the minimum of the current window maxOfMin = Math.max(maxOfMin, arr[deque.peekFirst()]); } return maxOfMin; } } //Optimal Approach //Naive Implementation class Solution { private Deque<Integer> stack; public ArrayList<Integer> maxOfMin(int[] arr) { stack = new ArrayDeque<>(); ArrayList<Integer> maxOfMinForWindowSizes = new ArrayList<>(Collections.nCopies(arr.length, 0)); // Find previous and next smaller element indices int[] pseIndex = findNextSmallerOnLeft(arr); stack.clear(); int[] nseIndex = findNextSmallerOnRight(arr); for (int i = 0; i < arr.length; i++) { /* * The window span represents the range of window sizes where the current * element is a candidate for the minimum element. Specifically, it means this element * can be the minimum for windows of size 1 to `windowSpan`. */ int windowSpan = nseIndex[i] - pseIndex[i] - 1; maxOfMinForWindowSizes.set(windowSpan - 1, Math.max(maxOfMinForWindowSizes.get(windowSpan - 1), arr[i])); } /* * Instead of updating all candidate windows for each element, we only update the * answer array for the largest possible window size (`windowSpan`) in which * the current element can be the minimum. This avoids unnecessary O(n²) time complexity * by restricting updates to only the largest valid window size for each element. * * After processing all elements, we perform a second pass from the * second-largest window size down to propagate the maximum values. This ensures that the * answer for any smaller window size also takes into account the maximum value of the * corresponding larger window size: * - For a window of size `i`, the answer will be the maximum between the current * value for window size `i` and the value for window size `i+1`. * - This works because an element valid for a larger window (`i+1`) is also * valid for any smaller window (`i`). * * This optimization allows us to build the result in O(n) time after the * initial pass, efficiently utilizing the fact that larger window candidates also apply to smaller ones. */ /* * The reason we start updating from `n-2` (processing window sizes from the second-largest downwards) * is that for a window size of `n` (the entire array), there is only one possible window-the array itself. * * For this single window, the smallest element is guaranteed to be the overall * minimum of the entire array, and this value directly contributes to the result for the window size `n`, * so it is already correctly computed. * * Additionally, for a window of size `n`, there will always be exactly one candidate element * (possibly repeated) that will be the minimum for a window of size `n`. */ for (int i = arr.length - 2; i >= 0; i--) { maxOfMinForWindowSizes.set(i, Math.max(maxOfMinForWindowSizes.get(i), maxOfMinForWindowSizes.get(i + 1))); } return maxOfMinForWindowSizes; } private int[] findNextSmallerOnLeft(int[] arr) { int[] pseIndex = new int[arr.length]; for (int i = 0; i < arr.length; i++) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { stack.pop(); } pseIndex[i] = stack.isEmpty() ? -1 : stack.peek(); stack.push(i); } return pseIndex; } private int[] findNextSmallerOnRight(int[] arr) { int[] nseIndex = new int[arr.length]; for (int i = arr.length - 1; i >= 0; i--) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { stack.pop(); } nseIndex[i] = stack.isEmpty() ? arr.length : stack.peek(); stack.push(i); } return nseIndex; } } //Better Implementation class Solution { private Deque<Integer> stack; public ArrayList<Integer> maxOfMin(int[] arr) { stack = new ArrayDeque<>(); ArrayList<Integer> maxOfMinForWindowSizes = new ArrayList<>(Collections.nCopies(arr.length, 0)); int[] nseIndex = findNextSmallerOnRight(arr); stack.clear(); for (int i = 0; i < arr.length; i++) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { stack.pop(); } int pseIndex = stack.isEmpty() ? -1 : stack.peek(); int windowSpan = nseIndex[i] - pseIndex - 1; maxOfMinForWindowSizes.set(windowSpan - 1, Math.max(maxOfMinForWindowSizes.get(windowSpan - 1), arr[i])); stack.push(i); } for (int i = arr.length - 2; i >= 0; i--) { maxOfMinForWindowSizes.set(i, Math.max(maxOfMinForWindowSizes.get(i), maxOfMinForWindowSizes.get(i + 1))); } return maxOfMinForWindowSizes; } private int[] findNextSmallerOnRight(int[] arr) { int[] nseIndex = new int[arr.length]; for (int i = arr.length - 1; i >= 0; i--) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { stack.pop(); } nseIndex[i] = stack.isEmpty() ? arr.length : stack.peek(); stack.push(i); } return nseIndex; } } //Optimal Implementation class Solution { public ArrayList<Integer> maxOfMin(int[] arr) { Deque<Integer> stack = new ArrayDeque<>(); ArrayList<Integer> maxOfMinForWindowSizes = new ArrayList<>(Collections.nCopies(arr.length, 0)); for (int i = 0; i < arr.length; i++) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { int index = stack.pop(); int previousSmallerElementIndex = stack.isEmpty() ? -1 : stack.peek(); int nextSmallerElementIndex = i; int windowSpan = nextSmallerElementIndex - previousSmallerElementIndex - 1; maxOfMinForWindowSizes.set(windowSpan - 1, Math.max(maxOfMinForWindowSizes.get(windowSpan - 1), arr[index])); } stack.push(i); } while (!stack.isEmpty()) { int index = stack.pop(); int previousSmallerElementIndex = stack.isEmpty() ? -1 : stack.peek(); int nextSmallerElementIndex = arr.length; int windowSpan = nextSmallerElementIndex - previousSmallerElementIndex - 1; maxOfMinForWindowSizes.set(windowSpan - 1, Math.max(maxOfMinForWindowSizes.get(windowSpan - 1), arr[index])); } for (int i = arr.length - 2; i >= 0; i--) { maxOfMinForWindowSizes.set(i, Math.max(maxOfMinForWindowSizes.get(i), maxOfMinForWindowSizes.get(i + 1))); } return maxOfMinForWindowSizes; } }

❤❤

Chamak Gya Bhaiya... class Solution { public: // Function to remove a loop in the linked list. void removeLoop(Node* head) { // just remove the loop without losing any nodes // making a map and then iterating trough each node while taking the node of their addresses // if we encounter the same address again then there is a loop otherwise // we don't have to do any thing .. unordered_map<Node*,bool>visited; // we take two pointers front and prev and move front and previous point to just prev // node from the front pointer .. Node*front = head,*prev = NULL; while(front){ if(visited[front]==true){ prev->next = NULL; return; } else{ visited[front] =true; prev = front; } // move the front pointer to the next node.. front = front->next; } } };

hanjii ji cleear h

❤