L28. Maximum Width of Binary Tree | C++ | Java

[@takeUforward]

Please likeeee, shareeee and subscribeeeeeeee :) Also follow me at Insta: Striver_79 The test cases have been updated, so the code might tle, use long 😅

[@Sumeet_100]

It is not giving TLE but giving Runtime error which gets solved by a Long long .. Thank You so much bhaiyya for this Amazing series !!!!

[@ujjwalsharmaiiitunacse3884]

@@Sumeet_100 u can use unsigned int in that everything goes fine with that

[@Gyan_ki_dukaan-sx6le]

ThankGod someone updated!! I have been hitting my head for last 2hours.. finally saw this comment.. thanks.

[@fanigo138]

This one was a thinker! I've solved 50+ trees problems now, but it took me more than an hour to solve this one on my own. Good one!

[@siddhantrawat1588]

bro, i am also solving arsh's dsa sheet. I solve tree problems regularly. But, still am not able to get the logic of the problems (medium level). I almost look the solution of every problem on yt. Can you tell me how I can solve this issue? Thankyou

[@fanigo138]

@@siddhantrawat1588 just keep practicing and revising bro.. literally no other way! Revise everyday to make sure you don't forget anything.

[@siddhantrawat1588]

@@fanigo138 ok bro, thanks a lot

[@preetkatiyar969]

@@siddhantrawat1588 try to solve first more easy then move to medium

[@siddhantrawat1588]

@@preetkatiyar969 ok, thank you

[@amanbhadani8840]

If you are getting runtime error while submiting the same code on leetcode,no need to worry,just do a minute change in the code,just typecast the value of index while pushing in the queue.You may ask since we applied a trick to tackle the integer overflow here,yes we did,but through this method we just ensure that the index we push everytime just comes under INT_MAX,and index difference is always under singed 32 bit ,i.e at max below 2^32 as stated in question itself. At everytime we are pushing (2*index+1) or (2*index+2),so its not exactly twice,its getting more than that ,thats why we need to typecast with long long.Hope its clear now. Below my accepted code - class Solution { public: int widthOfBinaryTree(TreeNode* root) { if(!root) return 0; queueq; q.push({root,0}); int ans=0; while(!q.empty()) { int size=q.size(); int mn=q.front().second; int first,last; for(int i=0;ileft) q.push({node->left,(long long)curr*2+1}); if(node->right) q.push({node->right,(long long)curr*2+2}); } ans=max(ans,last-first+1); } return ans; } };

[@namansharma7328]

Bro ...one doubt ...........we are typecasting the value while pushing in queue.......but the queue we made is to store node* and int datatype. So, would the queue store long long datatype. The code is working fine. Just wanted to know the logic. Thanks.

[@sachin.chaudhary]

max value of 2*curr+1 can never be more tha 6001 after subtracting the curr with the min value. bcoz at each level once you subtract the minimum value you have range something like [0 , 1, ..................size-1]. Since size lies in the range [1 , 3000] It should work fine.

[@parthsalat]

I realised that (somehow) not every variable in our code needs to be long long: //(Only) This needs to be long long because it'll be multiplied with 2 long long currIndex = nodesQueue.front().second - minIndex; By doing this my code ran in 6ms on Leetcode _(Faster than 95% people)_

[@parthsalat]

@@namansharma7328 Exactly, I had the same doubt...but magically it's working 😅

[@parthsalat]

@Ayush Negi Mindblowing explanation! Thanks 🙏

[@nikhilnagrale]

Idea of handling Overflow was amazing!!!!! I solved that using unsigned long long LOL 😂😂

[@shwetanknaveen]

I don't know when did you ran the code or when leetcode updated test cases....it still throws overflow error.....I have raised PR in his repo....let's see when does he accept

[@nikhilnagrale]

@@shwetanknaveen I checked it right now it worked

[@nikhilnagrale]

@@shwetanknaveen but bhaiya method is better try to understand that

[@shwetanknaveen]

@@nikhilnagrale are you trying his code on git on leetcode?

[@shwetanknaveen]

@@nikhilnagrale I created this comment....try this too Your idea to prevent the overflow was great but you did one mistake.....it shouldn't be the minIndex which needs to be subtracted rather it should be the maxIndex at each level. Moreover we need not calculate first and last with comparisons for each node at a level rather first is index of left most node at the level and last is index of rightmost node at that level........more refined code is as below class Solution { public: int widthOfBinaryTree(TreeNode* root) { int size; //Let's suppose all the nodes are stored in array like we did in heap sort in 1 based indexing int minIndex,maxIndex,maxi = 1; queue qu;// qu.push(make_pair(root,0)); pair temp; while(!qu.empty()) { size = qu.size(); minIndex = qu.front().second;//min index at this level will be index of leftmost node at this level maxIndex = qu.back().second;//max index at this level will be index of rightmost node at this level while(size--) { temp = qu.front(); qu.pop(); if(temp.first->left) qu.push(make_pair(temp.first->left,2*(temp.second-maxIndex)));//index of left child is 2x(parent's index) {1 based indexing} if(temp.first->right) qu.push(make_pair(temp.first->right,2*(temp.second-maxIndex)+1));//index of right child is 2x(parent's index) + 1 {1 based indexing} } maxi = max(maxi,maxIndex-minIndex+1);//number of nodes between minIndex and maxIndex including both } return maxi; } };

[@abhisekdas6328]

Hi Striver Love your work absolute hardwork and dedication. A small clarification. as curr_id is contant multiple for a single loop it will not create any issue if we substact with min or not or even we can substract any random number from q.front().first We can substract 1 just for our personal understanding and indexing nodes as 1,2,3... Ex: 1 / \ 2 3 / \ \ 4 5 6 case 1:substracting 1 stack = [ [1 ,1] ] first time -> left = 1 right = 1 m = max(0,right-left +1) = 1 stack = [ [ 2,1] , [3,2] ] 2nd time -> left = 1 right = 2 m = max(1,right-left +1) = 2 stack = [ [4,1] , [5,2] ,[6,4] ] 3r time- > left = 1 right = 4 m = max(2,right-left +1) = 4 case2:substracting 257 stack = [ [1 ,1] ] first time -> left = 1 right = 1 m = max(0,right-left +1) = 1 stack = [ [ 2,-511] , [3,-510] ] 2nd time -> left = -511 right = -510 m = max(1,right-left +1) = 2 stack = [ [4,-1535] , [5,-1534] ,[6,-1532] ] 3rd time -> left = -1535 right = -1532 m = max(2,right-left +1) = 4 NOTE: leftNode = (1-257)*2+1 = -511 rightNode = (1-257)*2+2 = -510 LeetCode : 662 class Solution: def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int: stack = [[root,1]] m = 0 while len(stack)>0: n = len(stack) temp = [] left = 0 right = 0 for i in range(n): top = stack[i] if i == 0: left = top[1] if i == n-1: right = top[1] if top[0].left != None: temp.append([top[0].left,(top[1]-256)*2+1]) if top[0].right != None: temp.append([top[0].right,(top[1]-256)*2+2]) stack = temp m = max(m,right-left+1) return m

[@letsrock7354]

That intro music though😍😍😍😍😍 i skip relevel part and start from there...kudos to the one who created it

[@gandohajo27]

Simplest Approach ⬇⬇⬇⬇⬇ int maxWidth(TreeNode *root) { int ans,i=-1,j=-1; TreeNode *node=root; while(node!=NULL) { i++; node=node->left; } node=root; while(node!=NULL) { j++; node=node->right; } ans=i

[@akashyadav3211]

Try this test case : [1,3,2,5,null,null,9,6,null,7] ...output should be 7

[@U2011-n7w]

awesome explanation! I earlier added this question to my doubt list but after watching this video my doubt is completely gone

[@zeeshanequbal6227]

They added 2 new test cases on Leetcode making the above code fail due to integer overflow. I had to use long long even after subtracting mmin

[@surajsingh-sm7qx]

Me also bro

[@anuragchakraborty7607]

Exactly

[@theanmolmalik]

Just make you integer unsigned, those also will pass.

[@SatyamKumar-bw4vi]

@@theanmolmalik Hare Krishna! Thanks

[@SatyamKumar-bw4vi]

@@rohitrautela6679 Greetings Karne ka Tarika h Prabhu Ji ex Hi, Hello, like that Hare Krishna! Rohit Ji.

[@abhishekgururani6993]

Loved it, such a beautiful question that explored the concept of serialization. In the latest it seems leetcode has added a few more testcases, so this particular solution won't pass the newly added test cases and may give an error. So make sure either you use an unsigned long long to store serials/ids. Or otherwise you can do another hack that is to, instead of subtracting the max Serial/id for a particular level you can simply subtract max Id, it'll serialize the number in -ve and -ve range has one extra space than the positive range, hence it'll work.

[@kabiraneja7635]

Thanks buddy !!!! both ideas worked

[@parthsalat]

I realised that (somehow) not every variable in our code needs to be long long: //(Only) This needs to be long long because it'll be multiplied with 2 long long currIndex = nodesQueue.front().second - minIndex; By doing this my code ran in 6ms on Leetcode _(Faster than 95% people)_

[@nizarfteiha890]

Thank you, I was stuck and changing to long long made everything work.

[@SatyamEdits]

In code studio they have excluded all the null nodes and then calculate the width....which we can get easily by level order traversal and storing the max size of queue....

[@jitinroy2246]

same in gfg also. class Solution { // Function to get the maximum width of a binary tree. int getMaxWidth(Node root) { // Your code here Queue qu=new LinkedList(); if(root==null){ return 0; } qu.add(root); int length=1; while(!qu.isEmpty()){ int size=qu.size(); // for storing 1d arraylist and after completion of 1d arraylist we append this in 2d arraylist List sublist=new ArrayList(); for(int i=0;i

[@devathanagapuneeth7269]

Hi striver. You are working very hard for us and you please take rest . Health is also important.

[@takeUforward]

yeah will go off once this tree series is done!

[@deepakojha8431]

@@takeUforward theek hote hi Dp shuru 🙏

[@sachinupreti7159]

@@deepakojha8431 😄😄😄😄😄

[@fffooccc9801]

@@takeUforward can we apply level concept here like vertical level we can store for every node and return the difference between the max and min level from map the same concept that we applied in bottom view of a tree q?

[@meetmandhane]

@@fffooccc9801 No, we can't use that concept because multiple nodes can overlap on a line in the same level Try to dry run your approach on this test case [1,3,2,5,3,null,9] Correct answer is 4 for this case

[@guru1609]

to prevent the overflow condition for this code you can use "long" in line 25 instead of int. :)

[@mahima1219]

hey could you please explain why didnt we need to change queue's datatype to long too? We are storing 2*curid in queue only so dont w need to make changes there?

[@jeevan999able]

@@mahima1219 by the time it gets stored in there it has already been reduced fit into 32 bit i.e., an int

[@mrarefinmalek2524]

It worked !

[@pritishpattnaik4674]

Thanks bro

[@herculean6748]

@@jeevan999able then why was it giving error while calculating, it is also 32 bit

[@sanskargour6673]

When you cast (curr) to long long during the computation ((long long) curr * 2 + 1), the arithmetic operation is done in long long, which avoids overflow at that specific moment. Even though the result is eventually cast back to int (when stored in the queue), the key difference is that performing the multiplication in long long prevents the overflow from happening during the intermediate calculation. The overflow issue arises during the calculation itself rather than just storing the result, which is why handling the intermediate calculations in long long makes a significant difference. class Solution { public: int widthOfBinaryTree(TreeNode* root) { if(!root) return 0; queueq; q.push({root,0}); int ans=0; while(!q.empty()) { int size=q.size(); int mn=q.front().second; int first,last; for(int i=0;ileft) q.push({node->left,(long long)curr*2+1}); if(node->right) q.push({node->right,(long long)curr*2+2}); } ans=max(ans,last-first+1); } return ans; } };

[@sriramkrishnamurthy4473]

Bro one suggestion , could u pls show a queue horizontally pls bro pls 🙏🙏👍👍 just helps in better visualization i think 😃

[@sunilgrover4178]

I can totally feel and understand you request.

[@uRamPlus]

it doesn't really matter

[@amanbhadani8840]

Assume queue to be a hollow pipe placed vertically.

[@nishantsah6981]

I agree... many times i got confused his queue with stack while dry run

[@sriramkrishnamurthy4473]

@@amanbhadani8840 yep that surely does help now that I think of it dude !

[@vashishthsharma4411]

bhai aap living legend ho humanity needs more people like you

[@K_EN_VisheshSaini]

Hats off to you Striver! The way youve explained such a complex approach with so ease just makes me wonder how good your Intuition is.

[@stith_pragya]

Thank You So Much for this wonderful video............🙏🏻🙏🏻🙏🏻🙏🏻🙏🏻🙏🏻

[@roushankumar7684]

Kya hi mehnat kiye hai bhaiya iss video par

[@AmanSingh-t2c6t]

Instead of taking values of the next nodes as (2*i+1) and (2*i+2), we can take (2*i) and (2*i+1), in this case, it is not required to subtract the minimum of nodes on the same level.

[@az-zm4ji]

in that case if you have a skew tree with only right nodes it will also cause int overflow

[@Manmohanshukla420]

In that case also it's required/helpful, logic is same

[@iamnottech8918]

Apart from what is explained there is much to self analyze in this question , its okay if u spent an evening on it. (and that runtime is an analysis and also why min is not always 1 u will get this one via dry run for runtime wala thing just analyze the failed testcase and use gpt yes it will take sometime u need to think what happens when levels are increased exponentially (2^n) hope I helped u a little..

[@roushankumar7684]

Aapke explanation ko salaam ❤

[@apmotivationakashparmar722]

Great Question Striver . Thank you so much !

[@666Imaginative]

code you might looking for, for overflow problem use long long int widthOfBinaryTree(TreeNode* root) { if(!root) return 0; queue q; q.push({root,0}); int ans = 1; while(!q.empty()){ int size = q.size(); ans = max(ans,q.back().second-q.front().second+1); for(int i=0; ileft) q.push({temp.first->left,index*2+1}); if(temp.first->right) q.push({temp.first->right,index*2+2}); } } return ans; }

[@tusharnain6652]

You are pushing a long long into an int type queue, doesn't that give runtime error

[@shwetanknaveen]

Your idea to prevent the overflow was great but you did one mistake.....it shouldn't be the minIndex which needs to be subtracted rather it should be the maxIndex at each level. Moreover we need not calculate first and last with comparisons for each node at a level rather first is index of left most node at the level and last is index of rightmost node at that level........more refined code is as below class Solution { public: int widthOfBinaryTree(TreeNode* root) { int size; //Let's suppose all the nodes are stored in array like we did in heap sort in 1 based indexing int minIndex,maxIndex,maxi = 1; queue qu;// qu.push(make_pair(root,0)); pair temp; while(!qu.empty()) { size = qu.size(); minIndex = qu.front().second;//min index at this level will be index of leftmost node at this level maxIndex = qu.back().second;//max index at this level will be index of rightmost node at this level while(size--) { temp = qu.front(); qu.pop(); if(temp.first->left) qu.push(make_pair(temp.first->left,2*(temp.second-maxIndex)));//index of left child is 2x(parent's index) {1 based indexing} if(temp.first->right) qu.push(make_pair(temp.first->right,2*(temp.second-maxIndex)+1));//index of right child is 2x(parent's index) + 1 {1 based indexing} } maxi = max(maxi,maxIndex-minIndex+1);//number of nodes between minIndex and maxIndex including both } return maxi; } };

[@sumedhvichare1388]

Thank you for the explanation!

[@shwetanknaveen]

@@sumedhvichare1388 glad it helped 👍

[@divyanshpant5318]

So there is nothing wrong with subtracting either max or min, the only reason why this solution worked is because negative integers have one extra number. I used unsigned int and subtracted min and it worked perfectly. In the hindsight, unsigned int will give me same positive range as a long long int's positive range.

[@shwetanknaveen]

@@divyanshpant5318 Just think intuitively....if you wish to protect against overflow by going on a relative scale....then what will be more protective-> Subtracting smallest value from all values or subtracting largest value from all?

[@divyanshpant5318]

@@shwetanknaveen Here when u subtract largest element, all the indices will be negative. I confirmed this by printing the values. So rather than going from say 1 to 8 index values, largest element subtraction will iterate from 0 to -8, which in itself can equally likely lead to the possibility of overflow

[@muthupandideivamsanmugam1774]

Bro instead of using 2*i+1,2*i+2 for 0 based index, we can use 2*i , 2*i +1 because this is same as taking minimal element in the level and subtracting.

[@pranayavnish8028]

Yeah it's really confusing nobody has explained it really but here is why it IS NOT the same - with 2*i , 2*i + 1 u might not always get your 1ST node at each level as 0 (Try it on a right skewed Tree) But with the explained method you will ALWAYS get your 1st node at each level as 0.

[@medhaagarwal2124]

I have a doubt at 21:08 where you explain why the minimal index will change. if we were to change the minimal, suppose mini_ind = 2. now if we subtract to get the cur_id = (2-2 = 0) and then when I try getting the child's index it would go back to either 1 or 2 instead of 3 and 4 as 1 and 2 practically should be assigned to NULL (the left node of index 1 did not exist thus null values!) please explain

[@zee_desai]

You do not need to actively check for the first and last indices at a particular level At a particular level the first index is at the top of the queue to be processed and the last index is at the end of the queue, curr points to the last index at the end of the traversal def widthOfBinaryTree(self, root): q=deque() curr=root width=0 q.append((curr,0)) while q: n=len(q) top,top_idx=q[0] for i in range(n): curr,curr_idx=q.popleft() if curr.left: q.append((curr.left,2*curr_idx)) if curr.right: q.append((curr.right,2*curr_idx+1)) width=max(width,curr_idx-top_idx+1) return width

[@yuvrajgarg193]

You have to use long long even after this trick of saving integer overflow, using int gives runtime error.

[@AyushMishra-b8w]

dropping a comment just to motivate you 😊😊😊 btw great series

[@priyanshusolanki7503]

your implementation ♥♥

[@satvrii]

Ye bandaaa kitna awesome hai yrrrrrr 🫀🫀🫀🫀🥲🫂🫂🫂🫂🫂🫂🫂🫂🫂

[@ganeshjaggineni4097]

NICE SUPER EXCELLENT MOTIVATED

[@_Kart1k__G]

I modified the formula to 2*node and 2*node+1 This works well on leetcode Besides none of those long long issues that are being pointed to in the comments class Solution { private class Pair{ int idx; TreeNode node; Pair(int idx, TreeNode node){ this.idx=idx; this.node=node; } } public int widthOfBinaryTree(TreeNode root) { Queue q=new LinkedList(); Pair temp; int width=0, begin, end, size; q.add(new Pair(0, root)); while(!q.isEmpty()){ size=q.size(); temp=q.poll(); begin=temp.idx; end=temp.idx; if(temp.node.left!=null){ q.add(new Pair(2*end, temp.node.left)); } if(temp.node.right!=null){ q.add(new Pair((2*end)+1, temp.node.right)); } for(int i=2;iwidth){ width=end-begin+1; } } return width; } }

[@dep2460]

No need to use long long or unsigned just make min=q.back().front , it will solve using long long kills the logic of using new indexing for each level

[@tusharvlogs6333]

@Ayush Negi hey like but we never go to 2^3000 . i mean we always subtract the minimal from the indexing so at worst case of 3000 nodes we should be having number froms [0......3001] say. if i am wrong do reply. thanks

[@shantanukumar4081]

Great explanation 👍👍👍

[@adityagandhi4712]

At 10:24 in the vid, won't it be 7 instead of 6, at the 4th level node ?? Since it will be 2*3 + 1

[@rakshayadav1892]

Python code: class Solution: def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int: q=[(root,0)] ans=0 while q: n=len(q) mn=q[0][1] for i in range(n): curr=q[0][1]-mn node=q[0][0] q.pop(0) if i==0: first=curr if i==n-1: last=curr if node.left: q.append((node.left,2*curr+1)) if node.right: q.append((node.right,2*curr+2)) ans=max(ans,last-first+1) return ans

[@PriyanshiYadav-e6c]

We can find the leftHeight and rightHeight of root node. Required value = 2^(min(leftHeight, rightHeight))

[@PuneetMohanpuria]

I we have level, we can say that maximum number of nodes in that level is 2^(level number) So we can simply find number of level, and use above formula

[@nitinkaplas1532]

If anyone face issue of overflow just a bit change where we subtract min index we have to subtract the max index of current level where we store negative value as index for long width which solve the overflow issue. Below is the code of it. int widthOfBinaryTree(TreeNode* root) { if(root==NULL) return 0; queueq; q.push({root,0}); int res=0; while(q.empty()==false) { int start=q.front().second; int end=q.back().second; res=max(res,end-start+1); int size=q.size(); for(int i=0;ileft!=NULL) q.push({x.first->left,2*index+1}); if(x.first->right!=NULL) q.push({x.first->right,2*index+2}); } } return res; }

[@sanjays2270]

bro for taking (last index-first index+1) we can use the formula to find maxx width at the level (2**level)

[@umayashaswi2822]

Heyyy after 3 it must be 7 right at 11:01 because 2*3+1=7 but you have written 6 ??

[@Kartikey30]

🙂 couldn't solve by myself. this question follows very nice apoorach

[@surbhirathore._]

Understood!❤

[@saurabhkumar521]

Just curious. Can we just identify level in binary tree and get the result as 2^(max(level)) ?

[@reshmah1497]

Awesome explanation bro👏

[@AppaniMadhavi]

Its simple to use level size right

[@ayushjain7130]

Understood!! ✨ But I have one question. Is solving these questions on leetcode after watching videos is right or wrong?

[@mohdhasnain3812]

Same doubt

[@namanchandra5270]

think for 10-15 min about the approach and then see the video. Here you are learning about the concept of binary tree not practicing the questions. After learning the basic concept you can go to leetcode to solve different problems on tree. I hope it will help you.

[@tejas7379]

No problem, if you understand the approach. Practice similar questions.

[@rohanraj2604]

This might look easy but very tricky question Thanks #Striverbhaiya for the beautiful explanation :)

[@atjhamit]

Hey thanks for the series, loving it. One doubt though : if what you mention is actually the width of the binary tree then couldn't you simply find this out using a formula? 2^n ?

[@Shourya_performs]

nope 4 / \ 5 7 \ / 8 9 Consider this tree and u will get ur ans..

[@varunvishwakarma9689]

This formula is valid for complete binary Tree only.....And binary tree can be of any type

[@atjhamit]

@@varunvishwakarma9689 got it, thank you.

[@surendradas8174]

wonderful explanation !

[@ishitaajaiswal392]

Hello @take U forward can we just not calculate the depth of the of the tree and then do 2^(depth-1) ? It is working for all the cases I thought of Please let me know if I am thinking in the right direction or not .

[@sujan_kumar_mitra]

Doubt: In GFG, maximum width is defined as maximum nodes present in a particular level. In Leetcode: maximum width is the distance between 2 corner nodes in a level(including nulls). Can you confirm that GFG article is false or not?

[@takeUforward]

Not read that, try to follow leetcode.

[@ssowvik]

if(node->left){ q.push({node->left, idx*2LL+1}); } if(node->right){ q.push({node->right, idx*2LL+2}); } do this on Line 31 and 33 instead before pushing it to the stack, that will fix the overflow!!!

[@AmitSingh-ut4wt]

Great Explanation. Tree series is so awesome

[@DeepakGupta-ko8lh]

Instead of doing minn stuff, we can simply use 2*i, 2*i+1 instead of 2*i+1, 2*i+2

[@MohanaKrishnaVH]

Awesome Explanation. Understood.

[@ayushgupta-ds9fg]

bahut bhadiya teaching skill

[@RamKumar-kz8gg]

doubt how width is 2 at 17:21. as only 1 is between 3 and 7, so the answer should be 1 !!

[@takeUforward]

Am talking about indexing..

[@getsnax]

Very well explained thank you striver

[@thapankt325]

if we just use 2*i for left, 2*i + 1 for right, with zero index tree. we can avoid over flow @takeUforward

[@shivanijain2192]

I think we can use vertical no and at each node and then subtract it

[@atifali3485]

Each level can can have multiple nodes too.. so it kinda fails

[@paraskumar693]

@20:53 I was also thinking 1 will be minimum index for all

[@samedev6792]

I guess the Vertical order traversal will be an easy approach. Also since we incorporate netative integers there , no overflow will occur .

[@jotsinghbindra8317]

easier but will lead to the extra Space Complexity of using the map also will increase the time complexity

[@lavanyaprakashjampana933]

WE LOVE YOUR CONTENT AND WE LOVE YOU.....🖤

[@dakshkaushik2kk]

The index of the first node of each level, also tells the width of that particular level. Isn't it?

[@DeadPoolx1712]

UNDERSTOOD;

[@nagavedareddy5891]

Huge respect...❤👏

[@AnkitSingh-tm5dp]

If u stuck with runtime error please take a long long variable in place of curr_id in leeetcode same question 662.

[@satendra6200]

Thanku bro

[@cinime]

Understood! So amazing explanation as always, thank you very much!!

[@pardhi8959]

bro you are genuis

[@CODIFYR_G]

why cant we use the concept of "vertical indexing" which we use on top view of binary tree. by using this, we can take the first and last element and find the answer can anyone answer my question?

[@vishadjain2696]

Great Explanation bhaiya!!

[@ahvgkjh]

Thank you very much for this vedio!

[@AmanChauhan-hr1wh]

you explained very well

[@Telugu_europe]

Can you please clarify my doubt. imagine there are 3 levels in a tree. first and second levels are completely filled (1 root, 2 (root's left child), 3(roots right child) but the third level has starting node( 4, (2's left child) ) and (5, (3's left child)). what should be the solution to the above case, your program is giving 3 as the answer. but should the answer be 2 or 4 or 3 ?

[@an__kit]

Ans will be 3 as there is only one node(2's right child) to be counted in width.

[@Learnprogramming-q7f]

Thank you Bhaiya

[@Shivi32590]

thank you

[@shivanshuagrawal9532]

can we use Math.min(lefthheight,rightheight)*2

[@shreyasinha-iitbhu8080]

curr_id should be of type ` long long`.

[@leepakshiyadav1643]

best explanation on yt

[@adityapandey23]

Understood

[@thatowlfromhogwarts490]

why cant we just find height and do 2^(height-1) as the maxm possible width??

[@abhinavprakashrai8306]

This code is giving wrong answer at 101/114 test case. Can anybody pointout possible mistakes in it? int widthOfBinaryTree(TreeNode* root) { long long int ans = 1, c = 1; queueq, q2; q.push(root); while(q.size()) { int k = q.size(); vectorv; for(int i = 0; ileft) { q.push(a->left); v.push_back(a->left->val); } else v.push_back(-101); if(a->right) { q.push(a->right); v.push_back(a->right->val); } else v.push_back(-101); } if(!q.size()) break; c *= 2; long long i = 0, j = v.size()-1; while(i=i && v[j] == -101) {j--; c--;} ans = max(ans, c); } return ans; }

[@biswajitbhunia7404]

Cant we solve it using 2^level

[@akritisharma2963]

At 10:43 it should be 7 instead of 6 as 2*3 + 1 = 7.

[@takeUforward]

Yeah slight typo.. hope you understand what i was trying to convey. P.S: human here

[@akritisharma2963]

@@takeUforward Yeah😅..Thank you so much for your reply and this tree series! Aise hi dp ki bhi leke aana 🙏🙏

[@samarthkaran2314]

Width is calculated between any two nodes as explained initially we ignored the node in second tree in the beginning of the video How will skew tree with single line nodes can even be a possible test case ?

[@bhuvaneshwarid3437]

It wont be a test case, skew tree will yield 0 I guess. Bcs there can never be another node in the same lvl to compare with.

[@pravvur]

Great explanation

[@Shantisingh-tz5sr]

In GFG why this is Giving TLE?

[@RahulYadav-jk7um]

Works by just writing long long in queue index class Solution { public: int widthOfBinaryTree(TreeNode* root) { if (root == NULL) { return 0; } int ans = 0; queue q; q.push({root, 0}); while (!q.empty()) { int size = q.size(); int first, last; for (int i = 0; i < size; i++) { int cur_id = q.front().second; TreeNode* node = q.front().first; q.pop(); if (i == 0) first = cur_id; if (i == size - 1) last = cur_id; if (node->left) { q.push({node->left, (long long)2 * cur_id + 1}); } if (node->right) { q.push({node->right, (long long)2 * cur_id + 2}); } } ans = max(ans, last - first + 1); } return ans; } };

[@isheep9025]

Personal note: Why we are not subtracting 1 at every level from the index instead taking minimum from queue? coz it mignt happen only right subtree exists at a level

[@UECAshutoshKumar]

Thank you sir

[@abhinavkumar8272]

Couldn't it also be done in the following way : I traverse to the left most leaf and store the level as lev1. Then, I traverse to the right most leaf and store the level as lev2. I get the minLevel = min(lev1, lev2) Max width = 2^(minLevel). Levels start from 0 index.

[@aswithasai4015]

no it gives you wrong answer because width is max possible nodes between the extreme two node of the tree on the same level

[@AyushYadav-lz5zc]

sir I am little bit confuse in the overflow part......like if we have 10^5 nodes int any tree then how it will be the part of stack over flow

[@namanchandra5270]

when calculating the index we are multiplying the index by two, so just imagine 2 raise to the power some big number exceed the range of the int

[@tejassrivastavaK_EE_]

@@namanchandra5270 cant we just simply use long long then?

[@ankitkumarghosh462]

wowwww what an explanation!.❤

[@abhinavnair4577]

Cant we say the max width of a binary tree is the max depth of that tree multiplied by 2?

[@LazyCoder20]

It might be possible that the max depth might not have the maxwidth at all. In a case where at the max depth/lowest level might have only one node or even if it had 2 nodes the number of nodes in between those two nodes might be lesser than some thing we got at a level above the max depth. Thus max depth * 2 would become wrong in such cases.

[@jagjotsingh5023]

Can't we just use pow(2,n) where n is the max depth of the tree?

[@anshumaan1024]

no, this doesn't work for all test cases , like 1:58, 2nd example

[@harshkushwaha5052]

if we push (root,1) intially and find cur_idx as cur_idx=q.front().second-1 then their will be no need of making mmin integer

[@JohnWick-kh7ow]

For 0 based indexing, Instead of doing (cur_id+1 and cur_id+2) we can do (cur_id and cur_id+1) also.

[@prashantgupta2339]

No we cant level 0 and 1 will work but in level 2 two nodes will have same value