力扣解题思路：1143. 最长公共子序列

    public int longestCommonSubsequence(String text1, String text2) {
        return helper(text1,text2,0,0,0);
    }
    public int helper(String text1,String text2,int start1,int start2,int res){
        if(start1 == text1.length() || start2 == text2.length()) return res;
        if(text1.charAt(start1) == text2.charAt(start2)){
            return helper(text1,text2,start1+1,start2+1,res+1);
        }else{
            return Math.max(helper(text1,text2,start1,start2+1,res),helper(text1,text2,start1+1,start2,res));
        }
    }

看起来相当简洁，然而一跑起来就超时，所以这种递归的方式并不能通过。那么就该动态规划出场了。

（方法2：动态规划法）我们定义dp[i][j] 的含义是：对于 s1[1…i] 和 s2[1…j]，它们的 LCS 长度是 dp[i][j]。->
接下来进行初始化：索引为 0 的行和列表示空串，所以dp[0][…] 和 dp[…][0] 都应该初始化为 0。例如，dp[0][3]=0 的含义是：对于字符串 “” 和 “bab”，其 LCS 的长度为 0。因为有一个字符串是空串，它们的最长公共子序列的长度显然应该是 0。->
有了这些前提，我们就可以定义动态方程了：

    if (text1.charAt(i - 1) == text2.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]);
    }

那么我们最终的答案就是dp[s1.length()][s2.length()]了，完整代码如下：

    public int longestCommonSubsequence(String text1, String text2) {
        int n1 = text1.length(), n2 = text2.length();
        int[][] dp = new int[n1 + 1][n2 + 1];
        for (int i = 1; i <= n1; i++) {
            for (int j = 1; j <= n2; j++) {
                if (text1.charAt(i - 1) == text2.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]);
                }
            }
        }
        return dp[n1][n2];
    }