DP 42. Printing Longest Increasing Subsequence | Tabulation | Algorithm
Вставка
- Опубліковано 5 лют 2025
- Lecture Notes/C++/Java Codes: takeuforward.o...
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/take...
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.o...
You can also get in touch with me at my social handles: linktr.ee/take...
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.
nice approach
//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);
}
}
really intuitive,thanks
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--;
}
}
But that will again be n2 solution. So doesn't help.
Understood. Words cannot express how thankful we are to you for this series.
the thing you did with the comparing dp[prev]+1
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
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
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.
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.
@@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.
Understood. Solved this with second approach just 2 days before. Great content!
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.
I cannot thank you enough for this lesson. Really appreciate for this step by step build ups
UNDERSTOOD......Thank You So Much for this wonderful video............🙏🏻🙏🏻🙏🏻🙏🏻🙏🏻🙏🏻
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
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]
thanks brother
understood .....this time it takes time but finally smjh aa hi gya...thanku striver
It took me to watch the last 5 min three times to understand the algorithmic approach implementation.
I am so happy that you shared the recursive then memoized then came to this tabulation code. I never understood the videos that directly explained this 1D dp solution you explained in the end
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.
that's what i thought too
Yes, you can do that too, takes another N to backtrack if the length is smaller of lis.
@@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();
}
same
@@Rk-tm8z best
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
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]
@@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
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);
}
6:17 optimised tabulation , 17:40 -> print lis ,23:13 final code
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 ?
Dp on trees and graphs plz
he did already
really really awesome approach , thanks for great learning Striver
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
me too bro
inner loop is for prev as prev can be any index from (currInd - 1 ) to -1 (if their is no prev)
@@deepaktiwari7059 pata h yaar itna to..par ye utna intutive nahi h
@@harpic949 Bro tabulation intutive hota bhi nhi hai we just do it for auxillary space optimization, only recursive solution are inituitive
++
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.
#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);
}
@@ajaysaini5314bhai eska tabulation hai ??
It can be solved in O(NlogN) using Patience Sorting algorithm
How to learn these many algorithms and improve our thinking it really very scary bro
Understood Sir. Thank you so much.
Similar prob. : 1626. Best Team With No Conflicts
understood , thank you striver
Got the same question in my Capgemini test today. Thanks Bhaiya
for which position?
Doggy style position ke liye😂😂
thanks for sharing your experience👌
UNDERSTOOD!!!!🔥🔥🔥🔥
understood the initial tabulation , Thanks
Understood! Thank you sir.
Thank you
Understood!!!
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
Understood ❤
Understood, respect! The last method could actually be used for Longest Ideal Subsequence also which has been giving TLE eternally :P
Thanks a ton!
Hey!
Why are we running the loops in opp direction? Why can't we do it by running them in straight fashion?
I have been breaking my head over this but havent found a good explanation yet
This is the Best DP series but, got to say that this question was the least intuitive one to solve.
could someone explain the while part. unfortunately i could not understand
why are second parameter going in +1 states?
Understood, sir. Thank you very much.
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
similar question Longest Arithmetic subsequence
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.
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].
06:03 Alternative Method
17:21 Tabulation Method Code ends - Print LIS Explanation
Why do we do the co-ordinate shift?
does anyone know why taking reverse order in memoisation, and non reverse order in tabulation doesn't work? why Striver took non reverse order in the memoisation approach?
that space optimization trick using next and prev is dope!
bro I didnt get that can u tell which video is he refereing to
@@danishsharma496 watch the first video of dp on strings
UNDERSTOOD
Hey striver. What is the timeline for the updation of notes. It's not there in the DP notes section.
Hi @3:40 why he has taken dp[ind+1][ind+1] instead of dp[ind+1][ind]
yes. same doubt
at 3:45 why second i+1 in dp[i+1][i+1], please explain as simple as you can, really need help !
Really challanging for me to make it today >>>
Can someone please explain to me how both the current and the previous indexes are ending at n-1? Shouldn't the previous be from -1 to n-2?
Understood! I really really really appreciate your explanation!!
we could also trace our LIS from the previous method: once we have completed making our dp array, we start from location (0,0) in it. Now we check if this index has to be included in the LIS or not. If we are at a location (r,c), we can check this by looking at which one among dp[r+1][c] and dp[r+1][r+1] + 1 is bigger. If dp[r+1][r+1] + 1 is bigger, we include arr[r] and go to the location (r+1, r+1).Else we do not include arr[r] and go to the location (r+1, c). Now we repeat the same process. Here's the python code for it:
def printLIS(arr):
n = len(arr)
dp = [[0 for i in range(n+1)] for j in range(n+1)]
for r in range(n-1, -1, -1):
for c in range(r+1):
dp[r][c] = dp[r+1][c]
if(c == 0 or arr[r] > arr[c-1]):
dp[r][c] = max(dp[r][c], dp[r+1][r+1] + 1)
LIS = []
r,c = 0,0
while(r < n):
if(dp[r+1][r+1] + 1 > dp[r+1][c]):
LIS.append(arr[r])
r, c = r+1, r+1
else:
r, c = r+1, c
print(*LIS)
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);
}
Understood !!
please provide documentation or write ups of the this algorithms please
can we directly use this tabulation approach in interviews for prev lis question
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?
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
For recursion we are using auxilary stack space for every function call. So, Inorder to omit the extra space complexity we use tabluation.
even the time complexity of recursive approach and tabulation are same but internally tabulation is faster
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.
Thankyou @striver
i dont understad why did he add ind+1 in the second parameter,like how can the prev_ind can be ind+1 and current also ind +1,it should have been ind only if we are considering the take case???
Thanks Striver. Understood.
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
Sir why did you shift from 0 to n - 1 and now using n - 1 to 0. similar for recursion its vice versa. I mean whyyyy??????????????????????????
Understood!
Thanks for that 👍
why second parameter in take is ind+1 and not ind?
Didn't completely get that state shift approach. Could appreciate more problems involving that. Can you or someone pls suggest any related problems?
Please watch previous videos he explained we did shift so that it can work with dp as dp can't contain a negative index that is why we did +1 to make -1 prev_ind start from 0
@@ugthesep5706 oh ok. thanks!
thankyou so so much sir
Can anyone tell how prev_index start from index-1 in tabulation
bhaiya confuse about co-ordinate change please clear doubt
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--;
}
}
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
@@pratikshadhole6694 The elements in the subsequence does not matter, only the order must be maintained.
17:49 - Print LIS Logic
I think we can do it in NlogN + PlogP where P is LIS size
Last 4 mins ,.. Striver on God Mode
we have used N*N sized array in tabulation also then why it is giving error in memoization only ?
6:14 start
understood!!!
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💡
I also have the same doubt, not able to understand how Striver changed it from recursion to tabulation
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
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
Trying all given possibilites on comments, I think the code striver is teaching is best though its not intutive
If we optimize 2D array space optimization into 1D array space optimization then the code is almost similar to the code striver explained at 7:00
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 :)
same
Striver aka Raj brother one small correction @ 6:54
dp[i] = signifies the longest LIS that ends at i.
Correct is dp[i] = signifies LIS that starts at i
Bcoz ur Recursion call was f(0,-1) 0 to N. Thereby Tabulation code is N to 0.
So dp[i] is when LIS is starting from ith index till End (N-1).
I hope i am correct. Please someone let me know. Also like and support if it's correct.
But for the Next New Printing Code
Dp[i] = signifies the longest LIS that ends at i.
im not sure but his recurisive calls for tabulation approach are from n->0 hence tabulation from 0->n-1 , so dp[i] ends at i is correct imo
Why we cannot start from beginning like we used to do in other problems
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?
why are we adding +1 to prev if we're using range -1 to ind-1 in tabulation?
because prev's initial value is -1 which is not a valid array index.
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 .
thanks man
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
Understood! But the code is giving runtime error.
thanks
understood😄😄
🔥
Understood!!Thank you
How does it always gives lexicographically smallest array
But how to print multiple LIS this will just give one of the multiple lis posssible
Most Efficient Code:-
#include
int longestIncreasingSubsequence(int arr[], int n){
vector lis;
lis.push_back(arr[0]);
for(int i=1;i
How to print LIS without using dp? I mean in O(NlogN)..?
understood✨
I face problem while converting memo solution to tabulation solution how to overcome that?
not understood why index+1 at 3.40
is printing LIS asked in interviews I am planning on leaving this
Great video!! But he did not explain what is being stored in the dp table formed using nested loops. Can anyone please explain?
ok
ok
Understood
1:45
-> its not clear why we are running outer loop from back side and inner from front side, Can anyone help?
Same confusion