最长公共子序列

Posted 2020-10-21 xfcnbkk

使用动态规划，关键是找出递推关系

定义矩阵dp,字符串s1="leet",s2="delete"

	d	e	l	e	t	e
l	0	0	1	1	1	1
e	0	1	1	0	0	0
e	0	1	1	2	2	3
t	0	1	1	2	3	3

 

 

 

 

细心观察，其实不难发现如下规律：

1. 如果s1[i] = s2[j],  dp[i][j] = dp[i-1][j-1] + 1;
2. 如果s1[i] != s2[j],  dp[i][j] = max(dp[i][j-1] , dp[i-1][j]);

我们可以这样来理解：

 

• 当计算dp[2][3]时，也就是要计算 "lee"和"dele"  的最长公共子序列。因为最后一位都相同，所以可以被看做是"del"和“le”的最长公共子序列+1，即dp[1][2]+1,而dp[1][2]在前面已经计算出来了。
• 当计算dp[2][4],即"lee"和"delet"的最长公共子序列。 因为最后一位不同，那么最长子序列取  “le”和“delet”、“lee”和“dele”之间的最大值。

　　数组右下角的数字就是最长公共子串的长度。

下面讲解如何从动态规划数组 dp 中得到所有最长公共子序列

得到数组dp后，最长公共子序列可以这样获得：

从数组dp右下角开始，定义i，j为数组右下角索引

如果s1[i] =s2[j] ，结果字符串 retult += s1[i], i--,j--;

如果不相等，就判断dp[i-1][j] dp[i][j-1]大小，将大者作为下一次迭代的初始值，如果一样的的话就都要遍历。

static void test(String s1,String s2){
        int[][] dp = new int[s1.length()+1][s2.length()+1];
        for(int i=1;i<=s1.length();i++) {
            for(int j=1;j<=s2.length();j++) {
                if(s1.charAt(i-1)==s2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1]+1;
                }else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        System.out.println("length: "+dp[dp.length-1][dp[0].length-1]);
    
        for(int i=0;i<dp.length;i++)
            System.out.println(Arrays.toString(dp[i]));
        List<StringBuilder> list = new ArrayList<>();
        StringBuilder cur = new StringBuilder();
        list.add(cur);
        get(list, dp.length-1, dp[0].length-1, cur, s1, s2, dp);
        for(StringBuilder sb : list)
            System.out.println(sb.reverse());
    }
    
    //得到所有子序列，可能会出现重复的
    static void get(List<StringBuilder> list,int pos1,int pos2,StringBuilder cur,String s1,String s2,int[][] dp) {
        if(pos1<=0 || pos2<=0)
            return;
        if(s1.charAt(pos1-1)==s2.charAt(pos2-1)) {
            cur.append(s1.charAt(pos1-1));
            get(list, pos1-1, pos2-1, cur, s1, s2, dp);
        }else if(dp[pos1-1][pos2]==dp[pos1][pos2-1]) {
            StringBuilder clone = new StringBuilder(cur);
            list.add(clone);
            get(list, pos1, pos2-1, cur, s1, s2, dp);
            get(list, pos1-1, pos2, clone, s1, s2, dp);
        }else if(dp[pos1-1][pos2]>dp[pos1][pos2-1]) {
            get(list, --pos1, pos2, cur, s1, s2, dp);
        }else {
            get(list, pos1, --pos2, cur, s1, s2, dp);
        }
    }