DP 42. Printing Longest Increasing Subsequence | Tabulation | Algorithm

Lecture Notes/C++/Java Codes: takeuforward.org/dynamic-prog...
Problem Link: bit.ly/3rVoIoq
Please watch the video at 1.25x for a better experience.
Pre-req for this Series: • Re 1. Introduction to ...
a
Make sure to join our telegram group for discussions: linktr.ee/takeUforward
Full Playlist: • Striver's Dynamic Prog...
In this video, we solve the LIS DP using tabulation method, then we go on to print the LIS as well.
If you have not yet checked our SDE sheet, you should definitely do it: takeuforward.org/interviews/s...
You can also get in touch with me at my social handles: linktr.ee/takeUforward

[@krishnans1665]

Another approach which I found to be intuitive: We can store the elements of the array without duplicates in increasing order (Can be easily done with the help of TreeSet in java or set in cpp). Then again store these elements in a new array and find the LCS of the original array and the newly computed array. The LCS of these 2 arrays will be the LIS. For printing the LIS, we can use the same approach used for printing LCS.

[@goooo9561]

nice approach

[@pranavkorhale5089]

//Nice Approach -- JAVA Code import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int arr1[] = new int[n]; TreeSet ts =new TreeSet(); for(int i=0;idp[ind1-1][ind2]){ ind2--; }else{ ind1--; } } } //Reverse the LCS arrayList Collections.reverse(ans); System.out.println(ans); } }

[@rishabhgupta9846]

really intuitive,thanks

[@inderjotsingh5868]

better approach would be to just utilize the dp array for it , as we know the difference between the last element in our sequence and second last element is just 1 , so what we can do , we will start iterating over array from last --> 0, when ever we find dp[i] == max , we will add , or print , and then decrease our max to max--; so that no we try to find second last element and so on. for(int index = n - 1; index >= 0 ; index--){ if ( dp[index] == max){ System.out.print( arr[index] +" "); max--; } }

[@abhishekkarn8918]

But that will again be n2 solution. So doesn't help.

[@oblivion_5910]

Understood. Words cannot express how thankful we are to you for this series.

[@anmolverma2911]

To printing there is a simpler approach and here is the code with explanation for it => int mx = res; vectorlis; for(int i = n-1;i>=0;--i){ if(dp[i] == mx){ lis.emplace_back(v[i]); mx--; } } reverse(begin(lis),end(lis)); for(auto &it : lis) cout

[@ChillLavaRed]

consider for (int i = maxIndex; i >= 0 && maxLen > 0; --i) { if (dp[i] == maxLen && (ans.empty() || ans.back() > nums[i] ) { ans.push_back(nums[i]); maxLen--; } } to make sure its not a wrong ans

[@mightygerman]

But bro we have to return array with smaller indexwise lexographically. Note - A subsequence S1 is Index-wise lexicographically smaller than a subsequence S2 if in the first position where S1 and S2 differ, subsequence S1 has an element that appears earlier in the array arr than the corresponding element in S2.

[@vattiyeshwanth282]

I think this is wrong brother see for the case [5,4,5]--> dp array will be [1,2,1]--> which makes it to take [5,4] as the longest increasing subsequence, and which is not the case.

[@princiagrawal1428]

​@@vattiyeshwanth282I think that the DP array for case [5,4,5] will be [1, 1, 2]. First, I will insert 5 into my answer vector, then decrement `max`. `Max` will be 1, so I can push 4 into my answer vector. Finally, I will reverse the answer vector, resulting in [4, 5], which is correct.

[@atifmirza9168]

00:01 Tabulation approach is discussed as an alternative to memoization for solving the longest increasing subsequence problem 02:17 Copy the recurrence and follow coordinate shift 06:29 The longest increasing subsequence can have different lengths depending on the last element. 08:48 The algorithm computes the longest increasing subsequence (LIS) for a given sequence. 13:10 Printing longest increasing subsequence using tabulation. 15:28 Implementing the tabulation method to find the Longest Increasing Subsequence in an array 19:46 Finding the longest increasing subsequence using tabulation. 21:40 The longest increasing subsequence can be obtained by following the index values in reverse order 25:38 Printing longest increasing subsequence using tabulation algorithm. Crafted by Merlin AI.

[@muditkhanna8164]

the thing you did with the comparing dp[prev]+1

[@chandrachurmukherjeejucse5816]

Understood. Solved this with second approach just 2 days before. Great content!

[@anuragC819]

This is the only one that I have not understood properly till now. Till the memoization section it was fine but the tabulation, I did not exactly understand the inner loop

[@NomanKhanK-IT-]

me too bro

[@deepaktiwari7059]

inner loop is for prev as prev can be any index from (currInd - 1 ) to -1 (if their is no prev)

[@harpic949]

@@deepaktiwari7059 pata h yaar itna to..par ye utna intutive nahi h

[@altafmazhar7762]

@@harpic949 Bro tabulation intutive hota bhi nhi hai we just do it for auxillary space optimization, only recursive solution are inituitive

[@pk4288]

++

[@tori_bam]

I cannot thank you enough for this lesson. Really appreciate for this step by step build ups

[@studyonline3236]

6:03 The intuition behind this tabulation is Fibonacci (frog jump problem - similar to DP-04 of this playlist) but the condition could be like - Frog must jump in increasing fashion using maxing stones possible. In this regard, Plz spend 2 mins on this to get the intuition. (Input array can be used to simulate the frog-stone representation. EX - array = [2,5,1,7], the first stone is at a distance of 2 from the start, then the second stone is 5 units away from the previous stone etc) Frog(*), _____ = stones separated by a variable distance (based on the input array) __*__ **____** **____** __*__ ____ ____ __*__ (WITH 7 stones) "Frog can start from any of the stones" In the above example : frog jumped say a distance k from stone 1 to stone 4, then it cannot jump to another stone say 5 or 6 and it has only one stone left, which is >k distance -> stone 7 : So the number of stones it used are 3. Longest Increasing Sequence = 3. CASE - 2: stones distances = Input Array = [1, 2 ,5, 7, 15, 3], Ascending order Stone and frog representation: __1__ __2__ __5__ __7__ __15__ __3__ Now the frog can use 1,2,5,7,15 - LISubseq = 5 CASE - 3: stones distances = Input Array = [6,5,4,3,2,1], Descending order Stone and frog representation: (Stone 1 is already at a distance 6 from the start) __6__ __5__ __4__ __3__ __2__ __1__ Intuitively, * cannot go to next stone from any of the starting stone, the LIS = 1 (num of stones used). A recap of the concept of DP-4 (a variation - frog jump in increasing fashion - inspired by Fibonacci), TC=O(n^2), SC=O(n) for dp and O(n) for recursion stack. #Recursion LOGIC The main intent of this comment is to let you guys know that you can use the Fibonacci logic(that you already know). You can think it of a fibonacci problem - Assume a frog can jump from any of the valid index(0

[@studyonline3236]

Plz read the comment first. #code in python def f(): dp=[1]*n for i in range(n): for k in range(i): if a[k]

[@RAINING606]

thanks brother

[@karanprabhakar72]

Hi @take U forward this method can also be implemented with queue And one more thing, if the question changes to print all such subsets ( as in this case, you are printing only one ) , queue implementation will be handy #include #include #include #include #include #include using namespace std; int main() { int n = 10 ; vector arr = {10,22,9,33,21,50,41,60,80,1}; vector dp(n,0); dp[0] = 1; int omax = 0; int index = -1; for(int i = 1 ; i < n ; i++) { int max = 0; for(int j = 0 ; j < i ; j++) { if(arr[i] > arr[j]) { if(max < dp[j]) { max = dp[j]; } } } dp[i] = max+1; if(omax < dp[i]) { omax = dp[i]; index = i; } } if(omax == 0) { omax += 1; index = 0; } cout

[@harpic949]

Somethings are not right in this code.. instead of index==0...it should be dp[index]==1 to print lis...and d[pq]==value && nums[i]

[@karanprabhakar72]

@@harpic949 hi Aditya if you run it in c++ , it will work. I == 0 means you have reached start of it and hence you can safely exit

[@ajaysaini5314]

can you convert it into Tabulation aapne poori series mei aisi hi recursion likhwayi hai PLease REPLY ! 5 ghante se baitha hu shi answer nhi aa rha #include int fun(int i,int prev,int arr[],int n, vector &dp) { if(iarr[i]) len=max(len,1+fun(i-1,i,arr,n,dp)); return dp[i][prev]=len; } int longestIncreasingSubsequence(int arr[], int n) { // Write Your Code here vector dp(n,vector(n+1,-1)); return fun(n-1,n,arr,n,dp); }

[@stith_pragya]

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

[@siddheshpawar2823]

I think we don't have to use hash for printing sequence. We can start from an index in our array where we got maxi value and go in reverse manner. For every index we will check if our value in dp less by 1 as that of maxi then it will part of sequence we will reduce maxi by one for further finding the elements.

[@aayush5474]

that's what i thought too

[@takeUforward]

Yes, you can do that too, takes another N to backtrack if the length is smaller of lis.

[@niteshverma8281]

@@takeUforward # o(nlogn) solution int longestIncreasingSubsequence(int a[], int n) { vector dp; dp.push_back(a[0]); for(int i=1;idp.back()) dp.push_back(a[i]); else { int idx=lower_bound(dp.begin(),dp.end(),a[i])-dp.begin(); dp[idx]=a[i]; } } return dp.size(); }

[@Rk-tm8z]

same

[@himanshu6665]

@@Rk-tm8z best

[@Harshit126]

Understood, respect! The last method could actually be used for Longest Ideal Subsequence also which has been giving TLE eternally :P Thanks a ton!

[@Zunan263]

Dp on trees and graphs plz

[@sahilgagan2242]

he did already

[@ritikshandilya7075]

really really awesome approach , thanks for great learning Striver

[@sumitkevlani5740]

This approach comes to work when we have said to print only one LIS for the array but if we want to all the LIS of the array then we need to use BFS kind of algorithm.

[@ajaysaini5314]

#include int fun(int i,int prev,int arr[],int n, vector &dp) { if(iarr[i]) len=max(len,1+fun(i-1,i,arr,n,dp)); return dp[i][prev]=len; } int longestIncreasingSubsequence(int arr[], int n) { // Write Your Code here vector dp(n,vector(n+1,-1)); return fun(n-1,n,arr,n,dp); }

[@Area-fd8ht]

​@@ajaysaini5314bhai eska tabulation hai ??

[@arkasarkar3901]

6:17 optimised tabulation , 17:40 -> print lis ,23:13 final code

[@tushararora-uv1zp]

Earlier ( in previous video) it was not allowed ( was not getting ac ) to have n^2 dp but now in tabulation it got accepted how ?

[@Ayush-lq3fz]

Hey striver. What is the timeline for the updation of notes. It's not there in the DP notes section.

[@ratinderpalsingh5909]

Understood, sir. Thank you very much.

[@reggiehurley1479]

for next/curr to save space for this problem we only need one array since by the time we update the index it's already used

[@UECAshutoshKumar]

Thank you Understood!!!

[@TheDev05]

Similar prob. : 1626. Best Team With No Conflicts

[@aditithakur6226]

Understood Sir. Thank you so much.

[@iamnoob7593]

understood the initial tabulation , Thanks

[@sayandey2492]

A bit simpler and easier to understand code (without using the extra hash array) using the Tabulation method taught by striver: vector printingLongestIncreasingSubsequence(vector arr, int n) { //Step 1: Calculating length of one of the LIS vector dp(n,1); for(int ind=1;ind

[@jonu.1504]

It can be solved in O(NlogN) using Patience Sorting algorithm

[@abc-ym4zs]

How to learn these many algorithms and improve our thinking it really very scary bro

[@prabhakaran5542]

Understood ❤

[@garimakumari4346]

thanks man

[@techwithrajdeep7633]

could someone explain the while part. unfortunately i could not understand

[@harshitbhatt6822]

when i am checking (1+dp[j]>dp[i]) inside if then it is giving TLE but if i include this condition in if then it is passing all TCs. Can you explain plz?

[@shahidullahmuffakir668]

Thanks bro

[@ganeshkamath89]

Thanks Striver. Understood.

[@vivekverma4012]

Thankyou @striver

[@cinime]

Understood! I really really really appreciate your explanation!!

[@parvahuja7618]

thankyou so so much sir

[@GungunRamchandani]

UNDERSTOOD

[@daniyalhussain5231]

This is the Best DP series but, got to say that this question was the least intuitive one to solve.

[@lakshaysharma6550]

UNDERSTOOD!!!!🔥🔥🔥🔥

[@sanchitdeepsingh9663]

thanks

[@Raj-yr3vz]

similar question Longest Arithmetic subsequence

[@tot7997]

we have used N*N sized array in tabulation also then why it is giving error in memoization only ?

[@sameersahu4569]

Understood!!Thank you

[@devbhattdev1607]

please provide documentation or write ups of the this algorithms please

[@inderjotsingh5868]

better approach would be to just utilize the dp array for it , as we know the difference between the last element in our sequence and second last element is just 1 , so what we can do , we will start iterating over array from last --> 0, when ever we find dp[i] == max , we will add , or print , and then decrease our max to max--; so that no we try to find second last element and so on. for(int index = n - 1; index >= 0 ; index--){ if ( dp[index] == max){ System.out.print( arr[index] +" "); max--; } }

[@pratikshadhole6694]

how can you be sure than wo isika part hai, there is also a possibility that us index tak ka uska LIS 2 hai but wo current index ka part hi nahi hai

[@pritz9]

@@pratikshadhole6694 The elements in the subsequence does not matter, only the order must be maintained.

[@yashsinghal3404]

that space optimization trick using next and prev is dope!

[@danishsharma496]

bro I didnt get that can u tell which video is he refereing to

[@lucygaming9726]

@@danishsharma496 watch the first video of dp on strings

[@lephanthanhbinh6187]

always understand the recursive approach so far, but I can't understand why we always can convert it to tabulation. I think recursion is different from having 2 loops nested, can anyone explain to me?

[@pranavsharma7479]

any code written in recursion can be converted to loops, and vice and versa and loops method has benefit in time complexity and space too

[@premkamal4790]

For recursion we are using auxilary stack space for every function call. So, Inorder to omit the extra space complexity we use tabluation.

[@035asadali8]

even the time complexity of recursive approach and tabulation are same but internally tabulation is faster

[@gouravjha4042]

Try drawing the recursion tree, and then print the dp matrix of both recursion and tabulation. It's some hard work, but you'll get it once you compare.

[@pratikshadhole6694]

why hash[lastIndex] !=lastIndex ? As there can be a possibility that at 3rd index hash[lastIndex] is also 3 then at that place it will stop and won't go further

[@36_sachinkumar92]

Can anyone tell how prev_index start from index-1 in tabulation

[@shreyatiwari8239]

can we directly use this tabulation approach in interviews for prev lis question

[@shashankagrawal3171]

How to print LIS without using dp? I mean in O(NlogN)..?

[@chiragbansod8252]

Understood

[@ramakrishnakcr4417]

understood

[@barshapaul9461]

the best thing about striver vaiyya is he normalize unsuccessful submission, i mean i used to think coder like them get successful submission at the first time itself and are never wrong , now i dont get panic when i see LTS or error or anything , it feels like okk lets try again :)

[@kankanaki4368]

same

[@RitikKumar-lv8cm]

bhaiya confuse about co-ordinate change please clear doubt

[@nishanttomer2555]

1:45 -> its not clear why we are running outer loop from back side and inner from front side, Can anyone help?

[@adityapahujavines3684]

why are second parameter going in +1 states?

[@siddharth794]

Its not the most optimal and ideal way to print, there is no need of hash table, you can iterate max_idx in this way. We can start from an index in our array where we got maxi value and go in reverse manner. For every index we will check if our value in dp less by 1 as that of maxi then it will part of sequence we will reduce maxi by one for further finding the elements.. Have a look at my code. int lengthOfLIS(vector& nums) { int n = nums.size(); vector dp(n, 1); int maxi = 1; int max_idx = -1; for(int i = 0; i < n; i++){ for(int prev = 0; prev< i; prev++){ if(nums[prev] < nums[i]){ dp[i] = max(dp[i], 1 + dp[prev]); } } if(dp[i] > maxi){ maxi = dp[i]; max_idx = i; } } while(max_idx >= 0){ cout nums[idx] && dp[max_idx] == dp[idx] + 1) break; --idx; } max_idx = idx; } return maxi; } }; Striver please pin this comment if you find it appropriate

[@hardikgupta7924]

why is it that if we apply increasing for loop that is 0 to n for index and -1 to index-1 for previous index rather than the decreasing way mentioned in the video the answer is coming wrong, it would be really helpful if anyone could explain💡

[@rohalkurup1350]

I also have the same doubt, not able to understand how Striver changed it from recursion to tabulation

[@kamalphoolwani6075]

Hi Hardik, you cannot apply index from 0->n because while calculating dp[i] it is dependent on dp[i+1] so if you do it from 0->n intilally all will zero ahead of that index and you will get wrong answer. But while calculating it from n->0 the ahead one will be already calculated and add to the answer. Hope this helps

[@pranavsharma7479]

bro its bottom up nah so we do it in reverse way only, for that you shd make recursive equation from the n-1 idx and ques will be longest decreasing sequence for that to implement

[@RaghavSharma-nt3hr]

17:49 - Print LIS Logic

[@keyurraval191]

Got the same question in my Capgemini test today. Thanks Bhaiya

[@gouravanand1749]

for which position?

[@Area-fd8ht]

Doggy style position ke liye😂😂

[@gouravanand1749]

thanks for sharing your experience👌

[@divyanshugupta5006]

🔥

[@tanishkarawat5266]

Trying all given possibilites on comments, I think the code striver is teaching is best though its not intutive

[@princepawar5655]

printing O(N) // printing lis int temp = omax; String lis = ""; for(int i = dp.length-1;i>=0 && omax!=0;i--){ if(dp[i] == omax){ lis = nums[i] +" "+lis; omax-- } }

[@satyampande684]

understood!!

[@adityavarma1334]

Understood! But the code is giving runtime error.

[@sanyamwalia217]

Thanks for that 👍

[@aditi1729]

why are we adding +1 to prev if we're using range -1 to ind-1 in tabulation?

[@gururajchadaga]

because prev's initial value is -1 which is not a valid array index.

[@amanmishra-vt8hk]

Because we are converting prevIndex whose range is between (n-1 to -1) to (n to 0) so, for every value that denotes prevIndex should be incremented by +1,that's why even when we are returning the answer instead of returning of [0][-1] we are return [0][-1+1] @aditi1729 .

[@rabiprakashshanitwarangal527]

can you provide the handwritten notes of dp series??

[@infinitibucket]

Understood !! ❤

[@deepaliverma08]

we can't find notes for these videos , and I know java only. Please provide with the source code also.PLease

[@immortal6978]

Really challanging for me to make it today >>>

[@imajt5]

Hi @3:40 why he has taken dp[ind+1][ind+1] instead of dp[ind+1][ind]

[@aakashgoswami2356]

yes. same doubt

[@pulkitranjan8189]

is printing LIS asked in interviews I am planning on leaving this

[@tikshavarshney213]

Understood !

[@manasranjanmahapatra3729]

Understood💯.

[@d_0364]

I think we can do it in NlogN + PlogP where P is LIS size

[@ITArchanaGK]

understood✨

[@zhunzargulhane6741]

second parameter was not always stored in +1 state in memoization as you stated in this video at 3.35. Why have you taken the index+1 as second parameter whereas in the memoization it was just index by updatiing about its current index which is actually greater than the previous index's value.

[@amanmishra-vt8hk]

Because we are converting prevIndex whose range is between (n-1 to -1) to (n to 0) so, for every value that denotes prevIndex should be incremented by +1,that's why even when we are returning the answer instead of returning of [0][-1] we are return [0][-1+1].

[@nileshb2471]

Great video!! But he did not explain what is being stored in the dp table formed using nested loops. Can anyone please explain?

[@aroonimgoswami5775]

ok

[@parthsalat]

ok

[@harishsharma6828]

Hi bhaiya!!great session For the efficient approach of O(n^2) can we also have a corresponding recursive approach??

[@_hulk748]

understood sir🙏🙏

[@jatinbhatoya8420]

but what is there are more than one LISs.

[@dpxy1599]

I face problem while converting memo solution to tabulation solution how to overcome that?

[@georgebell1927]

Striver could you please upload the code and the notes for the videos from 38.

[@aditikapoor8623]

How does it always gives lexicographically smallest array

[@prathamchoudhary6244]

Understood

[@sayakmondal3970]

When prev_ind == -1 then arr[ind] > arr[prev_ind] why this is not giving runtime error?

[@pkm754]

becoz of shortcircuit in logical or operator(if first statement is true then next statement will not execute)

[@aarifhannan4429]

Most Efficient Code:- #include int longestIncreasingSubsequence(int arr[], int n){ vector lis; lis.push_back(arr[0]); for(int i=1;i

[@venkateshvenky2880]

#understood

[@amankrsingh]

Understood, I think we can also do without hash array Where ever we find maxi we can store in ans And in every loop keeping value in some curr array

[@samverma3790]

But how to print multiple LIS this will just give one of the multiple lis posssible

[@anshumangupta1001]

Understood.

[@sourabhgarg2890]

not understood why index+1 at 3.40

[@Superheroic_Anime]

Understood bhaiya !!!

[@aryansinha1818]

06:03 Alternative Method

[@sahilgagan2242]

at 4:46 i write the same code but runtime error someone help pls

[@mohitrathore9307]

paste your code here, will try to correct it

[@vatsalagarwal2758]

in arr it should be prev_ind+1

[@mohitsingh7793]

Why do u want to create another array i.e. hash and make the things complicated ? My Approach : vectordp(n,1); for(int i=0;i

[@gamerglobe4839]

it is perfect!!

[@anshumaan1024]

But it fails @gfg where question ask to returns the Longest Increasing subsequence which is lexicographically smallest corresponding to the indices of the elements Overall nice 🙂

[@adityajhunjhunwala9739]

How to print longest LIS using memoization ???

[@ashusnapx]

why dp[0][-1+1], i'm unable to understand -1+1

[@priyanshvatsal9791]

Understood 🥰