【每日LeetCode】最大递增子序列

最大递增子序列

就是让你在一串无序数组中找到一串最大的递增数组。

思路就是定义俩数组，一个原数组一个上升序列数组，先将上升序列全部初始化为1，在原数组中找前后大小关系，后一个大于前一个则说明递增，那么上升序列中所对应的那个数等于前一个数+1，原数组中后一个数不大于前一个数说明不递增，这样的话上升序列数组中所对应的数保持不变，还是1.

import java.util.Arrays;
import java.util.Scanner;

public class Ma {
    static int n = 1010;
    static int[] a = new int[n];// 原数组
    static int[] dp = new int[n];// 拿来存储上升序列的

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();// n个数
        Arrays.fill(dp, 1);//填充上升数列每一个数都是1
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
//            dp[i] = 1;// 先初始化上升数列每一个数都是1
        }
        int max = -999999999;
        for (int i = 1; i < n; i++) {// i在后 从第二个数开始

            for (int j = 0; j < i; j++) {// j在前 从第一个数开始
                // 如果后大于前
                if (a[i] > a[j]) {// 说明递增 dp[i] = dp[j] + 1
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            max = Math.max(dp[i], max);
        }
        System.out.println(max);
    }
}

fill()该类的方法用Arrays给定值填充给定数组。该值必须与数组的数据类型匹配。

Arrays.fill(array, value)

Arrays.fill(array, start, end, value) 其中，array是要填充的数组，value是要填充到数组中的值。start也end可以指定索引，并且填充将被限制在给定的范围内。

fill()

fill()该类的方法用Arrays给定值填充给定数组。该值必须与数组的数据类型匹配。

Arrays.fill(array, value) / Arrays.fill(array, start, end, value) 其中，array是要填充的数组，value是要填充到数组中的值。start也end可以指定索引，并且填充将被限制在给定的范围内。

【leetcode300 最长递增子序列】

import java.lang.reflect.Array;
import java.util.Arrays;

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);//将上升序列全部填充为1
        int max = 1;
        for (int i = 1; i < nums.length; i++) {// i在后 从第二个数开始
            for (int j = 0; j < i; j++) {// j在前 从第一个数开始
                // 如果后大于前
                if (nums[i] > nums[j]) {// 说明递增 dp[i] = dp[j] + 1
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            max = Math.max(max,dp[i]);
        }
        return max;
    }
}

最长公共子序列

【leetcode1143 最长公共子序列】

// java
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(), n = text2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 获取两个串字符
                char c1 = text1.charAt(i), c2 = text2.charAt(j);
                if (c1 == c2) {
                    // 去找它们前面各退一格的值加1即可
                    dp[i + 1][j + 1] = dp[i][j] + 1;
                } else {
                    //要么是text1往前退一格，要么是text2往前退一格，两个的最大值
                    dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
                }
            }
        }
        return dp[m][n];
    }
}

找状态转移方程的方法是，思考每个状态有哪些「选择」，只要我们能用正确的逻辑做出正确的选择，算法就能够正确运行。

定义 base case。

我们专门让索引为 0 的行和列表示空串，dp[0][..] 和 dp[..][0] 都应该初始化为 0，这就是 base case。

用两个指针 i 和 j 从后往前遍历 s1 和 s2，如果 s1[i]==s2[j]，那么这个字符一定在 lcs 中；否则的话，s1[i] 和 s2[j] 这两个字符至少有一个不在 lcs 中，需要丢弃一个。关键就在这

关于我的图解

就是这个i,j在不在的问题，找一下俩字符串中也没有再这个LCS中就行，i、j 均不在包含在i不在，j在和i在，j不在中的，看我圈着的围着的列和行就知道是啥意思了。

import java.util.*;
public class Main{
    static int N=1010;
    static int f[][]=new int[N][N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        char a[]=(" "+sc.next()).toCharArray();
        char b[]=(" "+sc.next()).toCharArray();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                //情况1包含在情况2、3中
                //情况2、3取一个max
                f[i][j]=Math.max(f[i-1][j],f[i][j-1]);
                //满足a[i]==b[j]这一条件
                //再与情况4取一个max
                //a[i]==b[j] 就是遇到俩数组有共同字符的，且之前没有记过一次的就在之前的计数中+1
                //如果俩数组之前都出现过这个字符就不用加1了
                if(a[i]==b[j])f[i][j]=Math.max(f[i][j],f[i-1][j-1]+1);
            }
        }
        //输出集合定义
    System.out.println(f[n][m]);    
    }
}