使用动态规划，关键是找出递推关系
定义矩阵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 |
细心观察，其实不难发现如下规律：
- 如果s1[i] = s2[j], dp[i][j] = dp[i-1][j-1] + 1;
- 如果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); } }
