Can I print the LCS using top down approach of dynamic programming? - dynamic-programming

Question

I know there is a solution using the bottom-up approach. But I couldn't find any solution using top-down approach anywhere. Here is the code I'm using for finding the number of characters in LCS:
#include <bits/stdc++.h>
using namespace std;
int memo[100][100];
int LCS(string a,string b,int x,int y){
if(x==a.size() || y==b.size())
{ memo[x][y]=0;
return 0;
}
if(a[x]==b[y])
{
if(memo[x][y]==-1){
memo[x][y]=LCS(a,b,x+1,y+1);
}
return 1+ memo[x][y];
}
else
{
if(memo[x][y]==-1)
memo[x][y]=max(LCS(a,b,x+1,y),LCS(a,b,x,y+1));
return memo[x][y];
}
}
int main(int argc, char const *argv[])
{
string a,b;
cin>>a>>b;
memset(memo,-1,sizeof(memo));
cout<<LCS(a,b,0,0)<<endl;
return 0;
}

Answer 1

You need to use your memo while you compare both strings to do it. If they are equal, you jump at the diagonal, and if the are different, you can look for up and left jumping to the major one.
I have a code similar to yours. The only difference is that I look from the end to the begin of the string:
int lcs(char *x, char *y, int px, int py)
{
int ans;
int m1, m2;
if (memo[px][py] > -1) {
return memo[px][py];
}
if ((px == 0) || (py == 0)) {
ans = 0;
} else if (x[px - 1] == y[py - 1]) {
ans = lcs(x, y, px - 1, py - 1) + 1;
} else {
m1 = lcs(x, y, px , py - 1);
m2 = lcs(x, y, px - 1, py );
//max (m1, m2)
if (m1 > m2) {
ans = m1;
} else {
ans = m2;
}
}
memo[px][py] = ans;
return ans;
}
To call lcs, you can do lcs("marvin", "panic", strlen("marvin"), strlen("panic")).
So, my memo (that is inverted considering your solution) will generate the following table:
+-------------------------+
| p a n i c |
+-------------------------+
| | -1 0 0 0 0 0 |
| m | 0 0 0 0 0 0 |
| a | 0 0 1 1 1 1 |
| r | 0 0 1 1 1 1 |
| v | 0 0 1 1 1 1 |
| i | 0 0 1 -1 2 2 |
| n | -1 -1 -1 2 2 2 |
+-------------------------+
To recover the substring, we start at the end of both strings ([6, 5]) and look for equal characters. If they aren't equals, we look to the content of the table in the up position. If this position is bigger than left, we go to up, otherwise we go to the left. This is represented for the following code:
px = strlen("marvin");
py = strlen("panic");
pos = 0;
while ((px != 0) && (py != 0)) {
if (x[px - 1] == y[py - 1]) {
res[pos++] = x[px - 1];
px--;
py--;
} else if (memo[px - 1][py] > memo[px][py -1]) {
px--;
} else {
py--;
}
}
res[pos] = '\0';
printf("%s\n", strrev(res));
This piece of code will start at the end, and will go left til it finds the the char n (location F).
+-------------------------+
| p a n i c |
+-------------------------+
| | -1 0 0 0 0 0 |
| m | 0 0 0 0 0 0 |
| a | 0 0 1 1 1 1 |
| r | 0 0 1 1 1 1 |
| v | 0 0 1 1 1 1 |
| i | 0 0 P -1 2 2 |
| n | -1 -1 -1 F - - |
+-------------------------+
When it finds the char n the algorithm position jumps at the superior-left-diagonal (location P). In the next steps, the algorithm go up until matches with the char a.
+-------------------------+
| p a n i c |
+-------------------------+
| | -1 0 0 0 0 0 |
| m | 0 P 0 0 0 0 |
| a | 0 0 F 1 1 1 |
| r | 0 0 | 1 1 1 |
| v | 0 0 | 1 1 1 |
| i | 0 0 | -1 2 2 |
| n | -1 -1 -1 \ - - |
+-------------------------+
And the last steps it will go left until the position of px reach zero and the algorithm stops.
+-------------------------+
| p a n i c |
+-------------------------+
| | -1 0 0 0 0 0 |
| m | - - 0 0 0 0 |
| a | 0 0 \ 1 1 1 |
| r | 0 0 | 1 1 1 |
| v | 0 0 | 1 1 1 |
| i | 0 0 | -1 2 2 |
| n | -1 -1 -1 \ - - |
+-------------------------+
Obs: The result will be na and needs to be reverted (an).