代码随想录打卡第53天|1143.最长公共子序列；1035.不相交的线；53. 最大子序和（动态规划版）

1143.最长公共子序列

关键点1：dp数组的含义

dp[i][j]是以i-1,j-1为结尾的公共最长子数组的长度；

关键点2：递归公式的推导

 if(nums1[i-1] == nums2[j-1])，则i和j同时移动，所以为i-1,j-1；dp[i][j] = dp[i-1][j-1]+1;

如果不相等，则存在两种情况-> dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);

情况1：i往前退一步，j不退；

情况2：i不退，j往前退一步

关键点3：dp数组初始化

每个dp[i][j]元素都初始化为0，因为dp[0][j] =dp[-1][j-1]+1; ,dp[i][0] = dp[i-1][-1]+1;都出现了无意义的dp[-1]，所以dp[0][j] 和 dp[i][0] 都初始化为0 ，而其它元素也可初始化为0，所以整个数组初始化为0；

关键点4：遍历顺序

由于下一个dp值与上一个dp值有关，因此for循环从前往后遍历（0已经初始化，且为使递归公式的dp[i-1][j-1]有意义，i,j都从1开始遍历）。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        // dp[i][j] :从0到i-1,j-1字符串的最长公共子序列的长度
        int[][] dp = new int[text1.length()+1][text2.length()+1];

        for(int i = 1;i <= text1.length();i++){
            for(int j = 1;j <= text2.length();j++){
                // i-1的元素与j-1的元素相等时
                if(text1.charAt(i-1) == text2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else{
                // i-1的元素与j-1的元素不相等时，存在两种情况
                //情况1：i往前退一步，j不退；
                //情况2：i不退，j往前退一步
                    dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }
        return dp[text1.length()][text2.length()];

    }
}

1035.不相交的线

// 本题其实就是求最长公共子序列的长度，因为并未要求每个元素都要连续对应相等，所以不是最长重复子数组

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        // 本题其实就是求最长公共子序列的长度，因为并未要求每个元素都要连续对应相等，所以不是最长重复子数组
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        for(int i = 1;i <= nums1.length;i++){
            for(int j = 1;j <= nums2.length;j++){
                if(nums1[i-1] == nums2[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }
        return dp[nums1.length][nums2.length];

    }
}

53. 最大子序和（动态规划版）

关键点1：dp数组的含义

dp[i] 表示从0-nums[i]连续子数组的最大和是dp[i]

关键点2：递归公式的推导

只有两个状态 -> dp[i] = Math.max(dp[i-1]+ nums[i],nums[i]);

状态1：依据前面的dp值再加上目前的这个nums[i]；

状态2：将前面的值置0，从nums[i]重新计数

关键点3：dp数组初始化

dp[0]就是nums[0]的值，其它元素都初始化为0；

关键点4：遍历顺序

由于下一个dp值与上一个dp值有关，因此for循环从前往后遍历（0已经初始化，且为使递归公式的dp[i-1][j-1]有意义，i,j都从1开始遍历）。

关键点5：结果

由于并不是nums[nums.length-1]这最后一个值对应的连续子数组是最大和，最大和应该是整个数组求最大值得到，因此在for循环中逐步判断得到。

class Solution {
    public int maxSubArray(int[] nums) {
        // dp[i] 表示从0-nums[i]连续子数组的最大和是dp[i]
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int res = nums[0];
        for(int i = 1;i < nums.length;i++){
            // 只有两个状态，状态1：依据前面的dp值再加上目前的这个nums[i]；状态2：将前面的值置0，从nums[i]重新计数
            dp[i] = Math.max(dp[i-1]+ nums[i],nums[i]);
            res = Math.max(dp[i],res);
        }
        return res;
    }
}