代码随想录算法训练营第四十六天| 714. 买卖股票的最佳时机含手续费 、300. 最长递增子序列、718. 最长重复子数组 、1143. 最长公共子序列、1035. 不相交的线

[LeetCode] 714. 买卖股票的最佳时机含手续费
[LeetCode] 714. 买卖股票的最佳时机含手续费 文章解释

[LeetCode] 714. 买卖股票的最佳时机含手续费 视频解释

题目：

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

示例 2：

输入：prices = [1,3,7,5,10,3], fee = 3
输出：6

提示：

• 1 <= prices.length <= 5 * 10^4
• 1 <= prices[i] < 5 * 10^4
• 0 <= fee < 5 * 10^4

[LeetCode] 714. 买卖股票的最佳时机含手续费

自己看到题目的第一想法

    卖出时候扣掉手续费就行了。

看完代码随想录之后的想法

    简单看了一下代码实现，是一样的。

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return dp[prices.length - 1][1];
    }
}

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int[] dp = new int[2];
        dp[0] = -prices[0];
        dp[1] = 0;
        for (int i = 1; i < prices.length; i++) {
            dp[0] = Math.max(dp[0], dp[1] - prices[i]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i] - fee);//把当天买卖的情况加了进来，当天买卖的话值为 -fee，不会高于 dp[1], 因此不影响
        }
        return dp[1];
    }
}

自己实现过程中遇到哪些困难

    无。

[LeetCode] 300. 最长递增子序列
[LeetCode] 300. 最长递增子序列 文章解释

[LeetCode] 300. 最长递增子序列 视频解释

题目：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的

子序列。

 

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

• 1 <= nums.length <= 2500
• -10^4 <= nums[i] <= 10^4

[LeetCode] 300. 最长递增子序列 

自己看到题目的第一想法

    dp[nums.length][2], dp[i][0] 表示 nums[i] 在以 nums[i] 为结尾递增字串中，最大的字串长度。 dp[i][1] 表示比 nums[i] 小的最大值。然而很难实现对应的递归。。。是错误的想法。

看完代码随想录之后的想法

class Solution {
    public int lengthOfLIS(int[] nums) {
        // dp[i] 表示以下标 i 对应的数字，在以该数字为结尾的子集中，最大递增子序列的长度，该长度包括当前数字本身
        int[] dp = new int[nums.length];
        // 递推公式：dp[i] = Math.max(dp[i], dp[j] + 1);
        // 初始化 dp[0] = 1， 第一个数字之前没有数字了，因此是该队列最大且唯一的元素，因此长度为 1
        dp[0] = 1;//别忘记了初始化
        int result = dp[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = 1;// 这里老忘记，所有的元素至少都为1，如果该元素比它之前所有的元素小，dp[i] 就为1
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            if (result < dp[i]) {
                result = dp[i];
            }
        }
        return result;
    }
}

自己实现过程中遇到哪些困难

     忘记初始化，而且几乎每次都会忘记。

[LeetCode] 718. 最长重复子数组

[LeetCode] 718. 最长重复子数组 文章解释

[LeetCode] 718. 最长重复子数组 视频解释

题目：

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

[LeetCode] 718. 最长重复子数组 

自己看到题目的第一想法

    无，最近都是想一会儿感觉没想法就直接看题解了，这样快一些。当然缺少了主动思考，也会有一定的思考深度不足的问题，但是当下效率更重要吧。二刷可以更细致一些。

看完代码随想录之后的想法

    dp[i][j] 表示以 nums1[i] 和 nums2[j] 为结尾的连续字符串子集中，连续字符串的最长长度。因此如果 nums1[i - 1] == nums2[j - 1], dp[i][j] = dp[i - 1][j - 1] + 1.

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        int result = 0;
        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;
                }
                if (result < dp[i][j]) {
                    result = dp[i][j];
                }
            }
        }
        return result;
    }
}

// 一维数组版本
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[] dp = new int[nums2.length + 1];
        int result = 0;
        for (int i = 1; i <= nums1.length; i++) {
            int pre = dp[0];
            for (int j = 1; j <= nums2.length; j++) {
                int current = dp[j];
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[j] = pre + 1;
                } else {
                    dp[j] = 0;
                }
                if (result < dp[j]) {
                    result = dp[j];
                }
                pre = current;
            }
        }
        return result;
    }
}

 自己实现过程中遇到哪些困难

    老是和"公共子序列"混起来。。。脑子晕了。

[LeetCode] 1143. 最长公共子序列

[LeetCode] 1143. 最长公共子序列 文章解释

[LeetCode] 1143. 最长公共子序列 视频解释

题目：

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示：

• 1 <= text1.length, text2.length <= 1000
• text1 和 text2 仅由小写英文字符组成。

[LeetCode] 1143. 最长公共子序列

自己看到题目的第一想法

    字少事儿大。

看完代码随想录之后的想法

    dp[i][j] 表示两个数组中， 以下标为 i - 1 对应数字结尾的子集和以下标为 [j - 1] 对应数字结尾的子集，最长重复子数组的长度。对于 dp[nums1.length + 1][nums2.length + 1], 对于 dp[1][1 ~ j], 如果 nums1[0] == nums2[j - 1], 则 dp[1][j] = Math.max(dp[0][j - 1] + 1), dp[0][j - 1] 这里为 0，因此 dp[1][j] = 1. 如果 nums1[i - 1] != nums2[j - 1] 的话， dp[1][j] = Math.max(dp[0][j], dp[1][j - 1]), 这里dp[0][j] = 0， yinci  dp[1][j] = dp[1][j - 1];

    对于 dp[2 ~ i][1 ~ j], 如果 nums1[i] == nums2[j], 表示以nums1[i] 结尾的子集和以nums2[j]结尾的子集，至少有一个重复元素，去掉这个元素是否有其他的重复元素呢，这时候就要看 dp[i - 1][j - 1] 的了。因此如果 nums1[i] == nums2[j], 则 dp[i][j] = dp[i - 1][j - 1] + 1; 如果 nums1[i] != nums2[j]，此时 dp[i - 1][j] 和 dp[i][j - 1] 的值我们是知道的，此时 nums1[i] 可能出现在 nums2[1 ~ j - 1] 中， nums[j] 也可能出现在 nums1[1 ~ i - 1] 中。因此 dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); 这里我觉得对，但怎么也想不明白，就是那种"道理很简单，但为什么呢"的感觉。

class Solution {
    public int findLength(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 - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[nums1.length][nums2.length];
    }
}

// 一维数组版本，效率高一些。 一维数组也并不总是效率更高，目前做的题目看来，高一些的概率还是更大的。
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[] dp = new int[text2.length() + 1];
        for (int i = 1; i <= text1.length(); i++) {
            int pre = dp[0];
            for (int j = 1; j <= text2.length(); j++) {
                int current = dp[j];
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    // 这里在遍历 text2 的时候，需要依赖上一行的元素，而上一行的元素在遍历过程被覆盖了，因此需要拿 pre 记录一下
                    dp[j] = pre + 1;
                } else {
                    dp[j] = Math.max(dp[j], dp[j - 1]);
                }
                pre = current;
            }
        }
        return dp[text2.length()];
    }
}

自己实现过程中遇到哪些困难

    无

[LeetCode] 1035. 不相交的线
[LeetCode] 1035. 不相交的线 文章解释

[LeetCode] 1035. 不相交的线 视频解释

题目：

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：

•  nums1[i] == nums2[j]
• 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

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

示例 1：

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

示例 2：

输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3

示例 3：

输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

提示：

• 1 <= nums1.length, nums2.length <= 500
• 1 <= nums1[i], nums2[j] <= 2000

[LeetCode] 1035. 不相交的线

自己看到题目的第一想法

     这可真复杂，连线怎么和数组联系起来的？

看完代码随想录之后的想法

    这么简单的事情竟然没有发现，脑经急转弯这是。。。就是求最大公共子序列啊（非最大连续子集）。

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 - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[nums1.length][nums2.length];
    }
}

自己实现过程中遇到哪些困难

    for 的时候判断条件忘记加 = 号，导致结果错了.