动态规划dp（最长公共子串 + 最长公共序列）

动态规划思想：

    1.构建缓存数组和初始值；
    2.使用公式进行递推（如何列动态方程？？？）

 		//初始化二维数组:
 		**构建dp数组 二维数组 --横纵多添加一行一列保存初始化值为0**
        let dp = [];  
        for (let i = 0; i <= str1.length; i++) {
            dp[i] = []
            for (let j = 0; j <= str2.length; j++) {
                dp[i][j] = 0;
            }
        }

        // 最长公共子串（连续）- dp1
        function longestString(str1, str2) {

            const l1 = str1.length,
                  l2 = str2.length;
            const dp = new Array(l1 + 1).fill(0).map(() => new Array(l2 + 1).fill(0));

            let max = 0; // 最长公共子串的长度
            let end = 0; // 结束位置

            for (let i = 1; i <= l1; i++) {
                for (let j = 1; j <= l2; j++) {
                    if (str1[i - 1] == str2[j - 1]) { // 注意str1，str2的下标要修改，从0开始遍历
                        dp[i][j] = dp[i - 1][j - 1] + 1; // dp表达式

                    } else {
                        dp[i][j] = dp[i - 1][j - 1];
                    }

                    if (dp[i][j] > max) {
                        max = dp[i][j];
                        end = i - 1; // 保存最后位置
                    }
                }
            }
            console.log(str1.substring(end - max + 1, end + 1)); // 最长公共子串
            return max;  // return dp[l1][l2];
        }

        let str1 = "m2daxy";
        let str2 = "xamm2d";
        console.log(longestString(str1, str2));



        // 最长公共子序列 -- dp2
        var longestCommonSubsequence = function (text1, text2) {

            let max = 0;
            let end = 0;

            let len1 = text1.length,
                len2 = text2.length;
            let dp = new Array(len1 + 1).fill(0).map(() => new Array(len2 + 1).fill(0)); // 构建二维数组

            for (let i = 1; i <= len1; i++) {
                const s1 = text1[i - 1];
                for (let j = 1; j <= len2; j++) {
                    const s2 = text2[j - 1];
                    if (s1 === s2) {
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                    } else {
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
                    }

                    if (dp[i][j] > max) {
                        max = dp[i][j];
                        end = i - 1;
                    }
                }
            }
            console.log(text1.substring(end - max + 1, end + 1));
            return max;
        };

        let t1 = "oxcpqrsvwf";
        let t2 = "shmtulqrypy";

        console.log(longestCommonSubsequence(t1, t2));