子序列的问题

最新推荐文章于 2024-05-13 09:40:02 发布

alex-zhou96

最新推荐文章于 2024-05-13 09:40:02 发布

阅读量336

点赞数

分类专栏： leetcode刷题笔记

本文链接：https://blog.csdn.net/ZHOUJIAN_TANK/article/details/107897601

版权

leetcode刷题笔记专栏收录该内容

195 篇文章 2 订阅

订阅专栏

文章目录

两种模板
LeetCode120 三角形最小路径和
LeetCode516最长回文子序列
LeetCode5 最长回文子串（注意和回文子序列的对比)

两种模板

1 使用一维的dp数组（这个简单一点）


int n = array.length;
int[] dp = new int[n];

for (int i = 1; i < n; i++) {
    for (int j = 0; j < i; j++) {
        dp[i] = 最值(dp[i], dp[j] + ...)
    }
}

举个我们写过的例子最长递增子序列，在这个思路中dp数组的定义是：
在子数组 array[0…i]中，以nums[i]结尾的目标子序列(最长递增子序列）的长度是dp[i]
状态转移方程一般很简单，dp[i[] 和之前的dp[i-1] 最多是和之前的每一个dp[j]都发生一种关系
有时候需要一种附加状态

LeetCode42连续数组的最大子序和
LeetCode53 数组种最大子序和
LeetCode152乘机最大的子数组
LeetCode300最长上升子序列
LeetCode673最长上升子序列的个数
LeetCode376摆动序列，这题特殊点需要加上一个标志状态[i][0]或[i][1]
LeetCode646最长对数连
LeetCode368最大整除子集

2、使用一个二维的dp数组

int n = arr.length;
int[][] dp = new dp[n][n];

for (int i = 0; i < n; i++) {
    for (int j = 1; j < n; j++) {
        if (arr[i] == arr[j]) 
            dp[i][j] = dp[i][j] + ...
        else
            dp[i][j] = 最值(...)
    }
}

这种思路运用相对更多一些，尤其是涉及两个字符串/数组的子序列。本思路中 dp 数组含义又分为「只涉及一个字符串」和「涉及两个字符串」两种情况。

2.1、涉及两个字符串/数组时（比如最长公共子序列）

涉及两个字符串/数组时（比如最长公共子序列），dp 数组的含义如下：

在子数组arr1[0…i]和子数组arr2[0…j]中，我们要求的子序列（最长公共子序列）长度为dp[i][j]。

2.2、只涉及一个字符串/数组时

只涉及一个字符串/数组时（比如本文要讲的最长回文子序列），dp 数组的含义如下：

在子数组array[i…j]中，我们要求的子序列（最长回文子序列）的长度为dp[i][j]。

这种情况下状态转移方程，dp[i][j] 回和dp[i-1][j-1]或者dp[i-1][j-1],dp[i+1][j-1]，dp[i+1][j]这种一定要注意状态的确定方向，有时候画一个矩形就可以很快速的确定状态

LeetCode120 三角形最小路径和

在这里插入图片描述



  //分许
    /**
     * 若定义f(i,j)为(i,j)点到底边的最小路径和，则一直递归求解公式为
     * f(i,j)= min(f(i+1,j),f(i+1,j+1))+triangle[i][j]
     * 我们将任一点到底边的最小路径和，转化成了与该点相邻两点到底边的最小路径和中的较小值，再加上该点本身的值。
     *
     * dp[i][j]表示点(i,j)到底边的最小路径和
     * 状态转移方程：
     * dp[i][j]= min(dp[i+1]][j],dp[i+1]{j+1]}+triangle[i][j]
     */

    public int minimumTota1l(List<List<Integer>> triangle) {
        int n = triangle.size();
        // dp[i][j] 表示从点 (i, j) 到底边的最小路径和。
        int[][] dp = new int[n + 1][n + 1];
        // 从三角形的最后一行开始递推。
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] = Math.min(dp[i + 1][j], dp[i + 1][j + 1]) + triangle.get(i).get(j);
            }
        }
        return dp[0][0];
    }

LeetCode516最长回文子序列

在这里插入图片描述
这个问题对dp数组的定义是：在子串s[i…j]种，最长回文子序列的长度为dp[i][j]；为啥这个问题要这样定义，说白了就是如何从已经直到的结果推出位置的部分，这样定义容易归纳，容易发现状态专题一关系。

具体来说，如果我们想求dp[i][j]，假设你知道了子问题dp[i+1][j-1]的结果（s[i+1..j-1]中最长回文子序列的长度），你是否能想办法算出dp[i][j]的值（s[i…j]中，最长回文子序列的长度）呢

在这里插入图片描述

以上两种情况写成代码就是这样

if (s[i] == s[j])
    // 它俩一定在最长回文子序列中
    dp[i][j] = dp[i + 1][j - 1] + 2;
else
    // s[i+1..j] 和 s[i..j-1] 谁的回文子序列更长？
    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);

注意basecase: dp[i][i]=1
此外还有遍历的方向

在这里插入图片描述
至此，最长回文子序列的问题就解决了。

主要还是正确定义 dp 数组的含义，遇到子序列问题，首先想到两种动态规划思路，然后根据实际问题看看哪种思路容易找到状态转移关系。

另外，找到状态转移和 base case 之后，一定要观察 DP table，看看怎么遍历才能保证通过已计算出来的结果解决新的问题



package com.zj.FDynamicProgramming.taolu;

/**
 * @Author Zhou Jian
 * @Date 2020/8/9
 * 最长回文子序列
 */
public class Problem516 {

    /**
     * 给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
     * @param s
     * @return
     *
     *套用子序列的模板:
     *      dp[i][j] s字符串中 (i,j)的会问序列的长度
     *
     *      dp[i][i]=1 对叫先上的窦唯1
     *      dp[i][j] =   dp[i+1][j-1]+2  (if s[i]==s[j])
     *      我们说这个问题对 dp 数组的定义是：在子串s[i..j]中，最长回文子序列的长度为dp[i][j]。一定要记住这个定义才能理解算法。
     *
     * 为啥这个问题要这样定义二维的 dp 数组呢？我们前文多次提到，找状态转移需要归纳思维，说白了就是如何从已知的结果推出未知的部分，这样定义容易归纳，容易发现状态转移关系。
     *
     * 具体来说，如果我们想求dp[i][j]，假设你知道了子问题dp[i+1][j-1]的结果（s[i+1..j-1]中最长回文子序列的长度），你是否能想办法算出dp[i][j]的值（s[i..j]中，最长回文子序列的长度）呢？
     *
     * 总体来说，如果我们想求dp[i][j]，假设你知道了子问题dp[i+1][j-1]的结果（s[i+1..j-1]中最长回文子序列的长度），
     * 你是否能想办法算出dp[i][j]的值（s[i..j]中，最长回文子序列的长度）呢？
     *  xx [] yy
     */
    public int longestPalindromeSubseq(String s) {
        if (s==null||s.length()==0) return 0;
        if(s.length()==1) return 1;

        int[][] dp = new int[s.length()][s.length()];

        for(int i=0;i<s.length();i++){
            dp[i][i]=1;
        }

    //这个遍历的方向很和之前的不一样
        //这个还是从这个状态转移方程看出
        //是一种niaixnag 
        for(int i=s.length();i>=0;i--){
            for(int j=i+1;j<s.length()+1;j++){
                // s[i] == s[j]
                // dp[i][j]
                if(s.charAt(i-1)==s.charAt(j-1)){//相等
                    dp[i][j] = dp[i+1][j-1]+2;  //左下位置
                }else{//不相等
                    // s[i+1..j] 和 s[i..j-1] 谁的回文子序列更长？ 左  下
                    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][s.length()-1];
    }



}

在这里插入图片描述

LeetCode5 最长回文子串（注意和回文子序列的对比)

在这里插入图片描述



package com.zj.FDynamicProgramming.taolu;
/**
 * @Author Zhou Jian
 * @Date 2020/8/10
 * 最长回文子串
 */
public class Problem5 {


    /**
     * //这个是子序列的判定
     * dp[i][j]字符串中 s[i...j]的回文子串的最大长度
     *   s[i] == s[j] dp[i][j] = dp[i+1][j-1]+1
     *                 否则 dp[i][j] = max(dp[i][j-1],dp[i+1][j])
     *  // 下面的是子串是会问chaun的判定
     *          dp[i][j]字符串中 s[i...j]的回文子串的最大长度
     *      *    需要 partion(String s,int i,int j)
     *      *                 否则 dp[i][j] = max(dp[i][j-1],dp[i+1][j])
     *
     * @param s
     * @return
     */
    public String longestPalindrome(String s) {

        if(s==null||s.length()==0) return null;
        if(s.length()==1) return s;

        String[][] dp = new String[s.length()][s.length()];
       for(int i=0;i<s.length();i++){
           for(int j=0;j<s.length();j++)
               dp[i][j]="";
       }
        for(int i=0;i<s.length();i++) dp[i][i] = s.charAt(i)+"";


        for(int i=s.length()-1;i>=0;i--){
            for(int j = i+1;j<s.length();j++){
                // 加上s[i]喝s[j]构成回文子串
                // 注意喝子序列的区别
                if(partion(s,i,j)){
//                    System.out.println("s.charAt(i)"+s.charAt(i));
//                    System.out.println("s.charAt(j)"+s.charAt(j));
                    dp[i][j] = s.charAt(i)+dp[i+1][j-1]+s.charAt(j);
                }else {
                   if(dp[i][j-1].length()>dp[i+1][j].length()){
                       dp[i][j]=dp[i][j-1];
                   }else {
                       dp[i][j]=dp[i+1][j];
                   }
                }

            }

        }
        return dp[0][s.length()-1];
    }

    /**
     * 判断s[i,,,j]是否为回文穿
     * @param s
     * @param i
     * @param j
     * @return
     */
    private boolean partion(String s,int i,int j){
        int left = i;
        int right = j;
        while (left<=right){
            if(s.charAt(left)!=s.charAt(right)) return false;
            left++;
            right--;
        }
        return true;
    }


    public static void main(String[] args) {
        String  a = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
        Problem5 problem5 = new Problem5();
        String longestPalindrome = problem5.longestPalindrome(a);
        System.out.println(longestPalindrome);
    }




}