hdu 1503, LCS variants, find a LCS, not just the length, backtrack to find LCS, no extra markup

a typical variant of LCS algo.

the key point here is, the dp[][] array contains enough message to determine the LCS, not only the length, but all of LCS candidate, we can backtrack to find all of LCS.

for backtrack, one criteria is

dp[i-1][j]==dp[i][j]-1 && dp[i][j-1]==dp[i][j]-1

another is

dp[i][j]==dp[i-1][j-1]+1 && str1[i]==str2[j]

both is ok, here the first one is used.

//

#include <cstdio>
#include <cstring>
#include <algorithm>

struct myNode{ int x,y; };

#define MAXSIZE 105
int dp[MAXSIZE][MAXSIZE];
myNode pos[MAXSIZE];
char str1[MAXSIZE], str2[MAXSIZE];

int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
#endif
    int i,j,k,ch,len1,len2,len3;
    while(scanf("%s%s",str1+1, str2+1)==2) {
        len1=strlen(str1+1), len2=strlen(str2+1);
        for(i=1;i<=len1;++i) {
            for(ch=str1[i], j=1;j<=len2;++j) {
                if(ch==str2[j]) dp[i][j]=1+dp[i-1][j-1];
                else dp[i][j]=std::max(dp[i][j-1],dp[i-1][j]);
            }
        }
        for(i=len1, j=len2, len3=dp[len1][len2]-1;len3>=0;--len3) {
            while(1) {
                for(k=j;len3!=dp[i][k-1];--k) {}
                if(len3==dp[i-1][k]) {
                    pos[len3]={i,k};
                    --i, j=k-1;
                    break;
                }
                else {
                    --i;k=j;
                }
            }
        }
        len3=dp[len1][len2];
        pos[len3]={len1+1,len2};
        for( i=1, j=1, k=0;k<=len3;++k,++i,++j) {
            for(;i<pos[k].x;++i) putchar(str1[i]);
            for(;j<pos[k].y;++j) putchar(str2[j]);
            putchar(str2[j]);
        }
        putchar(‘\n‘);
    }

    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。// ps. If in any way improment can be achieved, better performance or whatever, it will be well-appreciated to let me know, thanks in advance.