力扣刷题之动态规划

牛客nc 127
给定两个字符串str1和str2,输出两个字符串的最长公共子串
题目保证str1和str2的最长公共子串存在且唯一。
注意不是最大序列，最大序列可以不连续，最长公共子串必须连续。

定义dp[i][j]表示字符串str1中第i个字符和str2种第j个字符为最后一个元素所构成的最长公共子串。
如果不相等，那么他们就不能构成公共子串，也就是
dp[i][j]=0;
如果相等，我们还需要计算前面相等字符的个数，其实就是dp[i-1][j-1]，所以
dp[i][j]=dp[i-1][j-1]+1;

public String LCS(String str1, String str2) {
    int maxLenth = 0;//记录最长公共子串的长度
    //记录最长公共子串最后一个元素在字符串str1中的位置
    int maxLastIndex = 0;
    int[][] dp = new int[str1.length() + 1][str2.length() + 1];
    for (int i = 0; i < str1.length(); i++) {
        for (int j = 0; j < str2.length(); j++) {
            //递推公式，两个字符相等的情况
            if (str1.charAt(i) == str2.charAt(j)) {
                dp[i + 1][j + 1] = dp[i][j] + 1;
                //如果遇到了更长的子串，要更新，记录最长子串的长度，
                //以及最长子串最后一个元素的位置
                if (dp[i + 1][j + 1] > maxLenth) {
                    maxLenth = dp[i + 1][j+1];
                    maxLastIndex = i;
                }
            } else {
                //递推公式，两个字符不相等的情况
                dp[i + 1][j+1] = 0;
            }
        }
    }
    //最字符串进行截取，substring(a,b)中a和b分别表示截取的开始和结束位置
    return str1.substring(maxLastIndex - maxLenth + 1, maxLastIndex + 1);
}

给定两个字符串str1和str2，输出两个字符串的最长公共子序列。如果最长公共子序列为空，则返回"-1"。目前给出的数据，仅仅会存在一个最长的公共子序列
输入：
“1A2C3D4B56”,“B1D23A456A”
返回值：
"123456"

import java.util.*;
public class Solution {
    public String LCS (String text1, String text2) {
        // write code here\
        // 解析https://leetcode-cn.com/problems/qJnOS7/solution/zui-chang-gong-gong-zi-xu-lie-by-leetcod-ugg7/
        int m = text1.length(), n = text2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            char c1 = text1.charAt(i - 1);
            for (int j = 1; j <= n; j++) {
                char c2 = text2.charAt(j - 1);
                if (c1 == c2) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
//         这部分参考https://blog.csdn.net/hrn1216/article/details/51534607
        StringBuilder sb = new StringBuilder();
        int s1L = m, s2L = n;
        while(s1L != 0 && s2L != 0){
            if (text1.charAt(s1L-1) == text2.charAt(s2L-1)){
                sb.append(text1.charAt(s1L - 1));
                s1L--;
                s2L--;
            }else{
                if (dp[s1L-1][s2L] > dp[s1L][s2L-1]){
                    s1L--;
                }else{
                    s2L--;
                }
            }
        }
        if(sb.length() == 0)
            return "-1";
        return sb.reverse().toString();
    }
}

对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。
输入：
“ababc”
返回值：
3
说明：
最长的回文子串为"aba"与"bab"，长度都为3

import java.util.*;
public class Solution {
    public int getLongestPalindrome(String A, int n) {
        // 动态规划：i到j的子串是否是回文子串
        boolean[][] dp = new boolean[n][n];
        int max = 0;
        // 字符串长度差 c = j-i，即当前要比较的字符串长度，这里可以 c <= n / 2 + 1，减少判断次数
        for(int c = 0; c <= n + 1; c++) {
            // 起始下标，范围取决于要判断的字符串长度c
            // i 和 j 分别为要比较的字符串的左右边界指针
            for(int i = 0; i < n - c; i++) {
                // 终点下标
                int j = c + i;
                // 左右边界的字符相等
                if(A.charAt(i) == A.charAt(j)) {
                    // c <= 1表示只有两个字符的字符串，一个或两个字符肯定是回文串
                    if(c <= 1) {
                        dp[i][j] = true;
                    } else {
                        // 对于两个字符以上的字符串
                        // 因为最左右的字符已经相等，因此取决于内层的子串是否是回文子串
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                    // 更新回文串的最大长度，c代表判断的子串长度，越来越大
                    if(dp[i][j]) {
                        max = c + 1;
                    }
                }
            }
        }
        return max;
    }
}

给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。

public int minPathSum (int[][] matrix) {
        // write code here
        int len1 = matrix.length ;  // 4
        int len2 = matrix[0].length ; // 4
        int[][] dp = new int[len1][len2] ;
        dp[0][0] = matrix[0][0] ;
        for(int i = 1 ; i < len1 ; i ++) dp[i][0] = dp[i-1][0] + matrix[i][0] ;
        for(int i = 1 ; i < len2 ; i ++) dp[0][i] = dp[0][i-1] + matrix[0][i] ;
        for(int i = 1 ; i < len1 ; i ++){
            for(int j = 1 ; j < len2 ; j ++){
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+matrix[i][j] ;
            }
        }
        return dp[len1-1][len2-1] ;
    }

给定数组 arr ，设长度为 n ，输出 arr 的最长上升子序列。（如果有多个答案，请输出其中 按数值(注：区别于按单个字符的ASCII码值)进行比较的 字典序最小的那个）
输入：
[2,1,5,3,6,4,8,9,7]
返回值：
[1,3,4,8,9]
动态规划（超时）
核心思想：
定义dp[i]dp[i]为对前 ii 个数中，以第 ii 个数字结尾的最长上升子序列的长度，且arr[i]arr[i]必须被选取。
分析知最大上升序列需要满足 arr[i] > arr[j]arr[i]>arr[j], 其中 i > ji>j。
对dp[i]dp[i]，可以由在ii之前且满足arr[i] > arr[j]arr[i]>arr[j]的状态转移得到
可得状态转移方程为：dp[i] = max(dp[j]) + 1dp[i]=max(dp[j])+1,其中 0 ≤ j < i0≤j<i，且arr[j] < arr[i]arr[j]<arr[i].
在dp[i]dp[i]计算完成后，为了得到最长递增子序列，需要从后往前对dp数组进行一次遍历，找到符合条件的数填入答案中。由于dp[i]dp[i]的值绝对能在左侧找到更小值dp[j]dp[j],故只需要选取第一次遇见的满足条件的数即可
不超时方法见https://blog.nowcoder.net/n/42e08f2afe804c10b27910a13be9dce3

    public int[] LIS (int[] arr) {
        // write code here
        int[] dp = new int[arr.length] ;
        int maxn = 0, n = arr.length;
        for(int i = 1; i < n; ++i){
            //找到满足 j < i,arr[j] < arr[i],的最大dp[j]进行转移
            int res = 0;
            for(int j = 0; j < i; ++j){
                if(arr[i] > arr[j]) {
                    res = Math.max(res, dp[j]);
                }
            }
            dp[i] = res + 1;//加上arr[i]
            maxn = Math.max(maxn, dp[i]); //找到最大长度
        }
        int[] ans = new int[maxn];
        for(int i = n - 1, j = maxn; j > 0; --i){
            //逆向找到第一个满足所需大小的数
            if(dp[i] == j){
                ans[--j] = arr[i];//填入后继续寻找下一个数
            }
        }
        return ans;