代码随想录|1143.最长公共子序列，1035.不相交的线，53. 最大子序和(贪心或动规实现)

1143.最长公共子序列

1.确定dp数组（dp table）以及下标的含义

dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]。。这样定义是为了简化dp的初始化逻辑。

2.关于dp初始化

dp[i][0]含义是text1字符串和空字符串text2的共同部分长度，所以初始化为0

dp[0][j]含义是空字符串text1和字符串text2共同部分长度，所以初始化为0

3.递推公式

如果遍历到的两个字符相等，那么dp[i][j]=dp[i-1][j-1]+1

否则，我们需要在dp[i][j]记录下之前遍历到text1的前一个字符串或者text2的前一个字符串中公共字符串长度的较大者,即Math.max(dp[i-1][j],dp[i][j-1])

4.遍历顺序

从前往后，从上往下

5.举例推导dp

最后红框dp[text1.size()][text2.size()]为最终结果

代码实现

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp=new int[text1.length()+1][text2.length()+1];
        for(int i=1;i<dp.length;i++){//行
            for(int j=1;j<dp[0].length;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[text1.length()][text2.length()];
    }
}

1035.不相交的线

直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。

虽然是连线，但分析完成后，这道题目跟1143题基本一样，都要求在元素相对不变的情况下求出最长公共子序列,代码就跟上一题一模一样

代码实现

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. 最大子序和

这次先用贪心做一遍，

class Solution {
    public int maxSubArray(int[] nums) {
        //用贪心，只要当前和是大于0的，那么就是有效的，否则那么最大和子数组的初始下标从当前遍历的位置开始
        int sum=0;
        int result=nums[0];//初始化为nums[0]是为了使得nums:[-1]  这种情况可以返回-1.或者这里也可以初始化为Integer.MIN_VALUE

        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
            result=Math.max(sum,result);
            if(sum<=0){
                
                sum=0;
            }
        }
        return result;

    }
}

用动态规划实现

1.dp含义

dp[i]表示包括下标i的最大连续子序列和为dp[i]

2.递推公式

dp[i]可以由两个方向推导出来:dp[i-1]+nums[i],即nums[i]加入当前连续子序列和；nums[i]，即从当前位置计算连续子序列和

3.dp数组如何初始化

从递推公式可以看出dp[i]是依赖于dp[i-1]状态，dp[0]就是递推公式基础，跟据dp含义dp[0]=nums[0]

4.确定遍历顺序

递推公式中dp[i]依赖于dp[i - 1]的状态，需要从前向后遍历。

5.推导dp

注意一些特殊的测试用例，如

[-2,-1]，[-1,-2]

注意要返回的不是dp数组的最后一个元素，而是在过程中遇到的最大元素

代码实现

class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp=new int[nums.length];
       // if(nums.length==1){return nums[0];}
        dp[0]=nums[0];
        int result=dp[0];//result要等于dp[0]
        for(int i=1;i<nums.length;i++){
            dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);
            if(dp[i]>result){result=dp[i];}
        }
        return result;

    }
}