leetcode-动态规划

最长上升序列篇

解法一：动态规划
解题思路：
状态定义：

dp[i]的值代表 nums 前 i 个数字的最长子序列长度。
转移方程： 设 j∈[0,i)，考虑每轮计算新 dp[i]时，遍历 [0,i) 列表区间，做以下判断：

当 nums[i] > nums[j]时： nums[i] 可以接在 nums[j] 之后（此题要求严格递增），此情况下最长上升子序列长度为 dp[j] + 1；
当 nums[i]<=nums[j] 时： nums[i]无法接在nums[j] 之后，此情况上升子序列不成立，跳过。
上述所有 1. 情况 下计算出的dp[j]+1 的最大值，为直到 i 的最长上升子序列长度（即 dp[i]）。实现方式为遍历 j 时，每轮执行 dp[i]=max(dp[i],dp[j]+1)。
转移方程： dp[i] = max(dp[i], dp[j] + 1) for j in [0, i)。
初始状态：

dp[i] 所有元素置 1，含义是每个元素都至少可以单独成为子序列，此时长度都为 1。
返回值：

返回 dp 列表最大值，即可得到全局最长上升子序列长度。
复杂度分析：
时间复杂度 O(N^2) ： 遍历计算 dp 列表需 O(N)，计算每个 dp[i] 需 O(N)。
空间复杂度 O(N)： dp列表占用线性大小额外空间。

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null) {
            return 0;
        }
        int len = nums.length;
        if (len <= 1) {
            return len;
        }
        int[] dp = new int[len];
        Arrays.fill(dp, 1);
        int res = 0;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            res = Math.max(res, dp[i]);
        }
        return res;

    }
}

1035. 不相交的线

难度中等

我们在两条独立的水平线上按给定的顺序写下 A 和 B 中的整数。

现在，我们可以绘制一些连接两个数字 A[i] 和 B[j] 的直线，只要 A[i] == B[j]，且我们绘制的直线不与任何其他连线（非水平线）相交。

以这种方法绘制线条，并返回我们可以绘制的最大连线数。

示例 1：

输入：A = [1,4,2], B = [1,2,4]
输出：2
解释：
我们可以画出两条不交叉的线，如上图所示。
我们无法画出第三条不相交的直线，因为从 A[1]=4 到 B[2]=4 的直线将与从 A[2]=2 到 B[1]=2 的直线相交。

示例 2：

输入：A = [2,5,1,2,5], B = [10,5,2,1,5,2]
输出：3

示例 3：

输入：A = [1,3,7,1,7,5], B = [1,9,2,5,1]
输出：2

提示：

1. 1 <= A.length <= 500
2. 1 <= B.length <= 500
3. 1 <= A[i], B[i] <= 2000

class Solution {
    public int maxUncrossedLines(int[] A, int[] B) {
        int aLen = A.length;
        int bLen = B.length;
        int count = 0;
        int lastindex= 0;
        for (int i = 0; i < aLen; i++) {
            for (int j = lastindex; j < bLen; j++) {
                if (A[i] == B[j]) {
                    count++;
                    lastindex = j + 1;
                    break;
                }
            }
        }
        return count;
    }
}